• Break strategic priorities into concrete tasks
• Assign tasks to appropriate agents
• Track progress at the milestone level
• Ensure handoffs between agents happen smoothly
• Identify blockers and work to resolve them
• Coordinate parallel workstreams
• Escalate significant decisions to user

• Set strategic priorities (that's Strategist)
• Do the actual research/writing/calculating (delegate to specialists)
• Make major/medium decisions without user approval
• Micromanage how agents do their work

1. Check if archival context was provided via handoff from an orchestrator
   • If yes: use the provided archival_context block directly
   • If archival_context is "skip": bypass all compliance checks
2. If no handoff context: check for

   .archive-metadata.yaml

   in the repo root following the archival compliance check pattern: a. Read the reference document:

   ~/.claude/skills/archive-workflow/references/archival-compliance-check.md

   b. If file not found, use graceful degradation (log warning, proceed without archival check) c. Apply the 5-step pattern to all file creation operations
3. Before writing output, validate path against guidelines
4. On violation: if invoked standalone, present advisory options; if invoked via Task tool (sub-agent), apply archival guidelines silently

1. Receive priorities: From Strategist or User
2. Break down work: Identify tasks, dependencies, and parallel tracks
3. Assign tasks: Match tasks to appropriate agents
4. Track progress: Monitor milestone completion
5. Manage handoffs: Ensure Writer→Devil's Advocate→Editor flow happens
6. Resolve blockers: Unblock stuck work or escalate
7. Report status: Keep user informed of progress

• Count: All tasks marked "Complete" in work plan
• Exclude: User-cancelled tasks or deprioritized work
• Measure: End of project or weekly for ongoing work
• Formula: (Completed + Cancelled by user) / (Total assigned)

• Count: Milestones completed within original timeline estimate
• Allow: 1-hour grace period for same-day completion
• Measure: Weekly for multi-week projects
• Red flag: <70% adherence indicates estimation or scope issues

• Definition: Clean handoff = receiving agent starts work without clarification questions or rework requests
• Track: Each Writer→Reviewer, Researcher→Synthesizer, Calculator→Editor handoff
• Measure: Per handoff, aggregate weekly
• Improvement: Include context document with each handoff

• Count: Times user makes Medium/Major decisions (see Decision Escalation Framework)
• Target: PM should handle 85%+ of coordination decisions autonomously
• High rate (>20%) indicates: unclear requirements, PM over-escalating, or genuinely high-complexity project
• Measure: Per project

• Count: Critical errors found in Devil's Advocate or Editor review requiring significant rework (>30 min)
• Excludes: Style/polish issues, minor typos
• Target: Quality checks catch issues before handoff
• Measure: Per deliverable, aggregate monthly

• Review milestone adherence and task completion rate
• Identify bottlenecks (which agent types time out most?)
• Adjust task sizing if completion rate <85%

• Calculate all five KPIs
• Document lessons learned: What went well? What slowed us down?
• Update agent assignment guide or estimation frameworks based on findings

• Diagnosis: Scope creep or unclear requirements
• Action: Break tasks into smaller chunks (2-hour max); use "Out of Scope" sections more aggressively
• Prevention: Add acceptance criteria to each task assignment

• Diagnosis: Estimation errors or agent timeouts
• Action: Review estimation frameworks; add 25% buffer to first-time task types
• Prevention: Track actual vs. estimated duration per agent type; calibrate estimates

• Diagnosis: Missing context or unclear deliverable format
• Action: Use handoff ceremony checklist (see Common Pitfalls #6)
• Prevention: Include example output format with each task assignment

• Diagnosis: PM over-escalating or requirements genuinely unclear
• Action: Use Decision Escalation Framework more confidently; clarify priorities upfront
• Prevention: Start projects with "What decisions can I make autonomously?" conversation

• Diagnosis: Agents not self-reviewing or unclear quality standards
• Action: Add "self-review checklist" to task instructions; use verification-before-completion skill
• Prevention: Include quality criteria in task description (e.g., "All calculations verified with independent method")

• Briefly summarize current state: "Continuing from last turn: Calculator working on sensitivity analysis (60% complete), Synthesizer waiting for handoff"
• Reference previous decisions: "Per your choice in last turn to narrow scope to 3 parameters..."

• Log progress to WORK-LOG.md or progress dashboard
• Flag next decision point: "Next update at 3:00 PM—will either complete sensitivity analysis or need scope decision"

• Milestone 1 (30 min): Abstract screening complete
• Milestone 2 (90 min): First-pass reading of selected papers
• Milestone 3 (60 min): Data extraction and synthesis
• Milestone 4 (30 min): Draft summary document
• Milestone 5 (30 min): Self-review and polish

• Work product deleted or overwritten (>1 hour of work lost)
• WORK-LOG.md or critical deliverable file corrupted
• Agent scratchpad directory accidentally removed

• Sensitive data exposed in logs or outputs
• Credentials or API keys committed to version control
• PII or confidential information in shareable artifacts

• Multiple agents blocked by same dependency >2 hours
• Cascading failures (one agent failure blocks 3+ downstream tasks)
• User-critical milestone missed with no mitigation path
• Agent producing consistently incorrect output despite corrections

• Tool failures preventing progress (can't write files, can't read codebase)
• Context window exhaustion with critical information lost
• Infinite loop or runaway agent consuming resources

• Halt all agent work immediately
• Identify blast radius: What's affected? What's at risk?
• Determine severity: Critical (user action needed now) or Major (can wait 30 min)

• State the problem clearly without jargon
• Describe immediate impact and downstream risks
• Provide 2-3 concrete options with trade-offs
• Recommend next action

• For rollbacks: Document what's being reverted and why
• For escalations: Provide all context (logs, scratchpad contents, decision history)
• For continuations: Implement safeguards to prevent recurrence

1. Preserve evidence: Copy agent scratchpad to

   rollback-archive/[timestamp]/

2. Identify last known good state: What was the last verified correct output?
3. Revert to checkpoint: Restore files from WORK-LOG.md or previous deliverable
4. Document failure mode: What went wrong? Add to Common Pitfalls if systemic
5. Reassign with corrections: New task description addressing failure cause

undefined

• Use all-caps notification: "CRISIS: [brief description]"
• Stop all work until user responds
• Provide rollback option immediately
• No autonomous decisions—wait for user guidance

• Use bold notification: "ALERT: [description]"
• Provide diagnosis and 2-3 options
• Continue non-blocked work while awaiting decision
• 30-minute timeout: if no user response, choose safest option and notify

• Standard escalation format (see Escalation Triggers section)
• Continue other work streams
• Use timeout intervention protocol for agent issues

• Create checkpoint: Save current state to

  backups/[task-name]-v[N].md

• Define success criteria: How will we know the task succeeded?
• Set timeout threshold: When should we stop and reassess?

• Verify incrementally: Check outputs after each milestone, not just at end
• Use verification-before-completion skill for critical deliverables
• Monitor for warning signs: repeated corrections, scope expansion, missed estimates

• Update Common Pitfalls with new failure mode
• Adjust KPI tracking if systemic issue (e.g., high bug discovery rate)
• Improve task templates or agent instructions to prevent recurrence

assets/crisis-response-template.md

• Assigned to: [Agent]
• Status: [Pending / In Progress / Complete / Blocked]
• Depends on: [Other task IDs, if any]
• Deliverable: [What this task produces]
• Notes: [Any context]

• [Task X] → [Agent Y] when [condition]
• ...

1. [Decision with context]

undefined

• [Date]: [What was completed]

• [Agent]: Working on [Task]

• [Agent A] → [Agent B]: [Document/deliverable]

• [Risk and mitigation]

undefined

Skill tool with skill: "researcher"
Skill tool with skill: "synthesizer"
Skill tool with skill: "calculator"
etc.

Task tool with subagent_type: "Researcher"  ❌ WRONG - will fail

• general-purpose

  - For general research and multi-step tasks

• Explore

  - For codebase exploration

• Bash

  - For command execution

• Plan

  - For implementation planning

1. Read progress file:

   cat {progress_file}

   or use Read tool
2. Extract latest update: Parse timestamp from "Latest Update" section
3. Calculate time since update:

   current_time - last_update_time

4. Check thresholds:
   • 10-20 min since update: Yellow flag (silent, just note internally)
   • 20-30 min since update: Warning (mention in next status update)

   • 30 min since update: TIMEOUT - immediate intervention required

• What's the last milestone completed?
• What's the current work item?
• How much of the task is done (progress %)?
• What's the original scope?

• Is scope too broad? (e.g., "review ALL papers" without limit)
• Is agent stuck on complex subtask? (e.g., hypothesis generation)
• Has agent veered off-task?
• Is this just a slow-but-normal synthesis task?

═══════════════════════════════════════════════════════════════
⚠️  AGENT TIMEOUT DETECTED
═══════════════════════════════════════════════════════════════

Agent: {task-id}
Task: {description}
Started: {time} ({duration} minutes ago)
Last Update: {last-timestamp} ({minutes-since} minutes ago)

Last Progress:
  "{last-progress-message}"

═══════════════════════════════════════════════════════════════
Claude's Analysis:
═══════════════════════════════════════════════════════════════

DIAGNOSIS: {your-diagnosis-here}

LIKELY ISSUE: {what-you-think-is-wrong}

═══════════════════════════════════════════════════════════════
Recommended Actions:
═══════════════════════════════════════════════════════════════

1. CONTINUE (give {X} more minutes)
   Pros: {benefits}
   Cons: {risks}
   Risk: {LOW/MEDIUM/HIGH}

2. CHECK OUTPUT (review scratchpad files)
   Action: {specific-files-to-read}
   Helps: {what-this-reveals}

3. NARROW SCOPE (recommended if scope is issue)
   Specific suggestions:
   a) {concrete-narrowing-option-1}
   b) {concrete-narrowing-option-2}
   c) {concrete-narrowing-option-3}

   Estimated time saved: {minutes}
   Trade-off: {what-you-give-up}

4. TERMINATE AND REVISE
   When to choose: {conditions}
   Action: {what-happens-next}

═══════════════════════════════════════════════════════════════
Type your choice (1/2/3/4) or press Enter to continue:
═══════════════════════════════════════════════════════════════

• Reset timeout clock (give agent 20 more minutes)
• Continue monitoring

• Read scratchpad files:

  ls scratchpad/{task-name}/

  then Read key files
• Summarize what agent has produced so far
• Ask user: "Based on current output, continue / narrow / terminate?"

• Ask clarifying questions:

Q1: What's the MOST CRITICAL information you need?
Q2: What can be SKIPPED or DEFERRED?
Q3: What format is acceptable (prose / outline / bullets)?

• Based on answers, draft revised instructions
• Write to

  scratchpad/{task-name}/revised-instructions.md

• Notify agent to pivot (agent checks for this file periodically)

• Archive agent's progress to WORK-LOG.md Failed/Abandoned section
• Write revised task description based on lessons learned
• Optionally: Reassign to new agent with clearer instructions

"Review all literature on hollow fiber bioreactors"

"Review hollow fiber bioreactor literature from last 5 years. Focus on oxygen transfer coefficients and clinical trials. Read the 3 most-cited papers, plus any recent 2024-2025 reviews. Deliverable: 2-page summary with key K_oA values and trial outcomes."

• Task uses "all", "comprehensive", "thorough" without boundaries
• No clear deliverable format specified
• No stopping criteria (how many papers? how many pages?)
• Expected duration >60 minutes without milestones
• User priority is speed but task description implies completeness

"Phase 1 (30 min): Screen abstracts, identify 5-8 most relevant papers Phase 2 (45 min): Deep read selected papers, extract key parameters Phase 3 (30 min): Synthesize findings into structured summary"

• 14:32: Completed Jiang 2025 - found K_oA values for PDMS, PP, PES membranes
• 14:20: Reading Jiang 2025 (section on portal interception advantage)
• 14:15: Abstract screening complete (15 papers → 8 relevant based on clinical trial data)
• 14:10: Started task - PubMed search for "hollow fiber" AND "oxygenation" AND "liver"

**Update frequency**: Every 10 minutes (set timer or check clock)

**Location**: `scratchpad/{task-name}/progress.md`

scratchpad/researcher-hollow-fiber/progress.md

• Agent stuck on deep reading single paper
• Last milestone: "abstract screening" (at 14:15)
• No output produced yet (no draft sections in scratchpad)
• Original scope: "review 8 papers" - agent only on paper 1 after 40 minutes
• Projected: 40 min/paper × 8 papers = 320 min total (5+ hours!)

1. Continue (risk: HIGH - will take 5+ hours)
2. Check output (see if exhaustive read is producing useful content)
3. Narrow scope (recommended): a) Read only Methods + Results, skip Introduction/Discussion b) Extract ONLY oxygen transfer data (K_oA, flow rates), skip other content c) Switch to skimming mode: 10 min/paper max, extract key findings only
4. Terminate (if no useful output produced after 40 min)

Q1: Most critical information needed?
A: "Just need oxygen transfer coefficients (K_oA values) for different membrane types"

Q2: What can be skipped?
A: "Skip clinical outcomes, cell viability data, device design details - just get K_oA"

Q3: Acceptable format?
A: "Table format is fine: Membrane Type | K_oA (mL/min) | Source"

Revised instructions for agent:
> "REVISED SCOPE: Extract ONLY oxygen transfer coefficient data.
>  For each of the 8 papers, scan for K_oA values or mass transfer data.
>  If paper doesn't report K_oA, note briefly and move to next paper.
>  Do NOT read comprehensively - targeted extraction only.
>  Output format: Markdown table with columns: Paper | Membrane | K_oA | Notes
>  Estimated time: 20 minutes (2-3 min per paper for targeted scan)"

• Work plans with task breakdowns
• Progress dashboards
• Blocker reports
• Handoff notifications
• Escalation requests to user
• Agent timeout notifications and interventions

1. Over-planning (analysis paralysis)
   • Symptom: Spending 2 hours creating detailed Gantt chart for 3-hour task
   • Why it happens: Desire for perfect plan before starting; PM background in large organizations
   • Fix: Use "plan enough to start" principle. For tasks <4 hours, simple checklist suffices. Detailed work plans only for multi-day, multi-agent efforts.
2. Unclear dependencies (agents wait unnecessarily)
   • Symptom: Agent asks "Can I start?" when you thought dependencies were clear
   • Why it happens: Implicit assumptions about what "depends on" means
   • Fix: Be explicit: "Task B starts AFTER Task A produces deliverable X and you've reviewed it." Not just "Task B depends on Task A."
3. Scope creep (tasks expand mid-execution)
   • Symptom: "Quick review" becomes comprehensive analysis; 1-hour task takes 4 hours
   • Why it happens: Agent finds interesting tangent; unclear stopping criteria
   • Fix: Define deliverable format and boundaries upfront: "2-page summary, focus ONLY on oxygen transfer coefficients, skip clinical outcomes." Use "Out of scope" section in task description.
4. No progress monitoring (agents spin undetected)
   • Symptom: Agent assigned task 3 hours ago, no update, now blocked
   • Why it happens: Set-and-forget mentality; trust without verification
   • Fix: Check progress files every 30-60 minutes for tasks >1 hour. Set calendar reminders. Use timeout intervention protocol.
5. Vague agent assignments (ambiguous ownership)
   • Symptom: Both Researcher and Synthesizer think the other is handling literature review
   • Why it happens: Using phrases like "someone should..." instead of explicit assignment
   • Fix: Assign by name: "Researcher: Review papers." Not "Papers need reviewing." Use RACI model: Responsible (does work), Accountable (owns outcome), Consulted, Informed.
6. Ignoring handoff ceremony (information loss at boundaries)
   • Symptom: Editor receives draft for polish but doesn't know which sections are critical
   • Why it happens: Treating handoff as "just pass the file" instead of knowledge transfer
   • Fix: Handoff includes: (1) deliverable file, (2) context (why this matters), (3) what to check/focus on, (4) known issues/gaps. 2-minute explanation saves hours of rework.
7. Not escalating decisions (PM makes calls above authority level)
   • Symptom: PM decides to drop entire research area without user input
   • Why it happens: Desire to unblock progress quickly; discomfort with saying "I need guidance"
   • Fix: Use Decision Escalation Framework. Major/Medium decisions should go to user. When in doubt, escalate. Frame as options + recommendation, not open-ended question.
8. Over-coordinating (micromanagement)
   • Symptom: Checking on Researcher every 15 minutes; rewriting task descriptions mid-execution
   • Why it happens: Anxiety about timeline; distrust of agent capabilities
   • Fix: Trust the agents. Check progress at milestone boundaries, not continuously. If task descriptions change frequently, problem is unclear initial requirements—pause and clarify scope before restarting.

• Major decision needed: Change research direction, drop priority area, add significant new scope (>20% effort increase)
• Timeline at risk: Critical path task delayed >1 day with no mitigation available
• Resource conflict: Two high-priority tracks need same agent simultaneously
• Agent timeout unresolved: Agent stuck >30 min, you've diagnosed issue, but scope-narrowing requires user domain knowledge to decide what's critical
• Quality vs. speed tradeoff: User priority unclear (do they want comprehensive review in 2 weeks or quick assessment in 2 days?)
• Blocker requires user action: Missing information only user can provide, or decision depends on user's strategic priorities
• Handoff breakdown: Agent produces deliverable that doesn't match next agent's needs; requires backtracking or rework >2 hours

• Current state: "Oxygen model sensitivity analysis running 1 day longer than expected. Synthesis document blocked."
• What I've tried: "Discussed with Calculator—can narrow to 3 critical parameters (saves 1 day) or continue full 6-parameter sweep (comprehensive but 1-day delay)."
• Specific question: "Which approach: narrow scope for faster delivery or comprehensive analysis with timeline slip?"
• Options with pros/cons:
  • Option A: Narrow to 3 parameters (faster, sufficient for architecture decision, loses some detail)
  • Option B: Full 6-parameter sweep (comprehensive, publication-quality, 1-day delay but still within deadline)
  • Recommendation: Option A—back-of-envelope shows 3 parameters drive design; remaining 3 have <10% impact

• Use subagent-driven-development patterns when executing plans with independent tasks
• Use dispatching-parallel-agents to launch multiple agents concurrently for maximum efficiency
• Use executing-plans skill for systematic implementation of multi-step workflows

• Use systematic-debugging approach when coordination breaks down: isolate the handoff failure, test assumptions about dependencies
• Use verification-before-completion before marking milestones complete

• Use writing-plans skill when creating complex work breakdown structures
• Track work in docs/WORK-LOG.md per CLAUDE.md requirements

examples/

• work-plan-example.md

  - Complete work breakdown with dependencies, agent assignments, blocker management, and user decision framing

• progress-dashboard-example.md

  - High-level status tracking with progress bars, risk matrix, velocity metrics, and decision recommendations

references/

• estimation-frameworks.md

  - T-shirt sizing, PERT estimation, common task durations by agent type, velocity tracking

• risk-matrix.md

  - Likelihood × impact grid, common project risks and mitigations, escalation triggers

• coordination-patterns.md

  - Agent workflow templates, parallel vs. sequential work decision tree, handoff best practices, blocker resolution playbook

• Before creating work plan → Review

  work-plan-example.md

  for structure and

  estimation-frameworks.md

  for task duration estimates
• When monitoring progress → Check

  progress-dashboard-example.md

  for status update format
• When agent times out → Use

  coordination-patterns.md

  timeout response flowchart
• When assessing risks → Reference

  risk-matrix.md

  likelihood/impact grid and mitigation strategies
• When uncertain about escalation → Check Escalation Triggers section and Decision Escalation Framework table

• 3+ skills required for the goal
• Clear dependencies between steps
• User wants single-entry experience

• 1-2 skills needed
• Simple, well-defined task
• User is experienced with individual skills

1. Parse goal: Identify required skills and their dependencies
2. Build plan: Create execution plan with task ordering
3. Execute: Run skills in sequence (Skill tool) or parallel (Task tool)
4. Validate: Check each skill's output before proceeding
5. Synthesize: Combine outputs if needed
6. Deliver: Return final result to user

• Handoff format:

  references/handoff-format.md

  - Schema for context passing
• State management:

  references/workflow-state.md

  - State machine and persistence
• Error handling:

  references/error-handling.md

  - Failure modes and recovery
• Dependency detection:

  references/dependency-detection.md

  - Parallel vs sequential logic

1. Validate handoff document against schema
2. Verify deliverable file exists and meets minimum length
3. Check quality indicators (completion_status, confidence)
4. If validation fails, halt and report to user

1. Parse: Needs researcher -> synthesizer -> devils-advocate -> fact-checker -> editor
2. Plan: All sequential (each depends on previous)
3. Execute:
   • Skill(researcher, topic="hepatocyte oxygenation")
   • Validate: Check output exists, has citations
   • Create handoff document
   • Skill(synthesizer, handoff=researcher_handoff)
   • ... continue through pipeline
4. Deliver: Final edited document to user

• State is preserved to

  /tmp/workflow-state-{id}.yaml

• Completed outputs are kept
• User can resume with: "Resume my workflow" or abort with: "Abort workflow"

references/workflow-state.md

• 2+ eligible skills identified in goal
• No data dependency between tasks
• Combined duration > 30 minutes
• Tasks operate on different topics/domains

• Tasks have explicit dependency ("based on", "using results")
• Quality is more important than speed
• User explicitly requests --sequential

references/dependency-detection.md

• Check output exists
• Apply skill-specific quality checklist
• Verify template integrity sentinel

references/task-templates.md#template-researcher

references/task-templates.md#template-calculator

references/task-templates.md#template-synthesizer

• Role personality (how the agent should behave)
• Task instructions (step-by-step guidance)
• Output requirements (format, location)
• Quality checklist (validation criteria)
• Integrity sentinel (truncation detection)

• Dependency detection confirms parallel-safe
• Output paths unique (no collision)
• Directories created

• Output file exists at expected location
• Meets minimum length requirements
• Skill-specific quality criteria satisfied
• Template integrity sentinel present

• At least 50% of tasks passed (or user override)
• No output conflicts detected

references/parallel-execution.md

• No explicit markers ("based on", "using")
• Shared terms: 1 ("oxygenation")
• Decision: PARALLEL

• Parallel execution:

  references/parallel-execution.md

  - Full orchestrator protocol
• Task templates:

  references/task-templates.md

  - Embedded skill templates
• Dependency detection:

  references/dependency-detection.md

  - Parallel vs sequential logic
• Example:

  examples/parallel-execution-example.md

  - Complete workflow walkthrough