maestro-flow 0.3.6 → 0.3.8

package/workflows/execute.md

@@ -37,7 +37,8 @@ ELSE (standard phase resolution):
 | Flag | Effect |
 |------|--------|
 | `--auto-commit` | Override config: commit after each task completion |
-| `--method agent\|cli` | Override execution method (default: config.json.execution.method) |
+| `--method agent\|cli\|auto` | Override execution method (default: config.json.execution.method) |
+| `--executor <tool>` | Default CLI tool: gemini\|codex\|qwen\|opencode\|claude (default: first enabled in cli-tools.json) |
 | `--dir <path>` | Use arbitrary directory instead of phase resolution (skip roadmap validation) |
 
 ---
@@ -53,7 +54,9 @@ If executionContext is available in memory:
   planObject = executionContext.planObject
   explorations = executionContext.explorations
   clarifications = executionContext.clarifications
-  executionMethod = executionContext.executionMethod
+  executionMethod = --method flag || executionContext.executionMethod
+  defaultExecutor = --executor flag || executionContext.defaultExecutor
+  executorAssignments = executionContext.executorAssignments || {}
   Skip disk reload
 ```
 
@@ -64,6 +67,8 @@ Read ${PHASE_DIR}/index.json
 Read ${PHASE_DIR}/plan.json
 
 executionMethod = --method flag || config.json.execution.method || "agent"
+defaultExecutor = --executor flag || config.json.execution.default_executor || "gemini"
+executorAssignments = index.json.plan.executor_assignments || {}
 ```
 
 ### Detect completed tasks (breakpoint resume)
@@ -110,7 +115,69 @@ Pass specs_content to each executor agent in E2.
 
 ## E2: Wave Parallel Execution
 
-**Purpose:** Execute tasks wave by wave, parallel within each wave.
+**Purpose:** Execute tasks wave by wave, parallel within each wave. Supports multi-backend dispatch — tasks route to Agent or CLI tools (via `maestro delegate`) based on executor resolution.
+
+### Executor Resolution
+
+```
+# Priority: per-task assignment > global method > auto fallback
+function resolveTaskExecutor(task_id):
+  If executorAssignments[task_id]:
+    return executorAssignments[task_id].executor   # "agent"|"gemini"|"codex"|"qwen"|"opencode"|"claude"
+  If executionMethod == "agent":
+    return "agent"
+  If executionMethod == "cli":
+    return defaultExecutor                         # e.g., "gemini"
+  # executionMethod == "auto":
+  task = loaded task definition
+  # Heuristic: tasks with many files or multi-step implementation → agent; otherwise → CLI
+  return (task.files.length > 5 || task.implementation.length > 8) ? "agent" : defaultExecutor
+```
+
+### Delegate Prompt Builder
+
+```
+# Unified prompt for CLI backends (maestro delegate). Same task info as Agent path.
+function buildDelegatePrompt(task_def, phase_context, specs_content, prior_summaries):
+  return """
+PURPOSE: Implement task ${task_def.id}: ${task_def.title}; success = all convergence criteria pass
+TASK: ${task_def.action} | Read existing code first | Verify convergence criteria after changes
+MODE: write
+CONTEXT: @${task_def.scope}/**/* | Phase: ${phase_context.goal}
+EXPECTED: Working code changes, all convergence criteria verified, summary of what was done
+CONSTRAINTS: Scope limited to task files | Follow project specs
+
+## Task Definition
+
+**Scope**: ${task_def.scope} | **Action**: ${task_def.action}
+
+### Files
+${task_def.files.map(f => '- ' + f.path + ' → ' + f.target + ': ' + f.change).join('\n')}
+
+### Read First
+${task_def.read_first.map(f => '- ' + f).join('\n')}
+
+### Implementation Steps
+${task_def.implementation.map(s => '- ' + s).join('\n')}
+
+### Convergence Criteria
+${task_def.convergence.criteria.map(c => '- [ ] ' + c).join('\n')}
+
+### Reference
+- Pattern: ${task_def.reference?.pattern || 'N/A'}
+- Files: ${task_def.reference?.files?.join(', ') || 'N/A'}
+
+## Phase Context
+- Goal: ${phase_context.goal}
+- Success criteria: ${phase_context.success_criteria}
+
+## Project Specs
+${specs_content}
+
+## Prior Task Summaries
+${prior_summaries}
+"""
+```
 
 ### Execution Loop
 
@@ -146,31 +213,59 @@ For each wave in execution_queue (sequential):
     1. Load task definition
        Read .task/${task_id}.json (lazy loading)
 
-    2. Spawn workflow-executor agent (fresh 200k context)
-       Input:
-         - Task definition (.task/${task_id}.json)
-         - Phase context (index.json goal, success_criteria)
-         - Relevant summaries from prior waves (.summaries/ of deps)
-         - Execution method override (if --method cli)
-         - Project specs (specs_content from E1.5 — coding conventions, architecture constraints, quality rules)
-        - Phase context decisions (context.md — Locked/Free/Deferred classification)
-        - Phase analysis scores (analysis.md — 6-dimension evaluation)
-
-       Agent responsibilities:
-         a. Read task definition (read_first, files, action, convergence.criteria)
-         b. Implement the task (create/modify files per task.files)
-         c. Verify convergence.criteria pass
-         d. If verification fails: auto-fix (max 3 attempts)
-         e. If auto-fix fails: write checkpoint, mark task as "blocked"
-         f. Atomic commit (if auto-commit enabled):
+    2. Resolve executor and dispatch
+       executor = resolveTaskExecutor(task_id)
+
+       IF executor == "agent":
+         # --- Agent path (existing) ---
+         Spawn workflow-executor agent (fresh 200k context)
+         Input:
+           - Task definition (.task/${task_id}.json)
+           - Phase context (index.json goal, success_criteria)
+           - Relevant summaries from prior waves (.summaries/ of deps)
+           - Project specs (specs_content from E1.5)
+           - Phase context decisions (context.md)
+           - Phase analysis scores (analysis.md)
+
+         Agent responsibilities:
+           a. Read task definition (read_first, files, action, convergence.criteria)
+           b. Implement the task (create/modify files per task.files)
+           c. Verify convergence.criteria pass
+           d. If verification fails: auto-fix (max 3 attempts)
+           e. If auto-fix fails: write checkpoint, mark task as "blocked"
+           f. Atomic commit (if auto-commit enabled):
+              git add <task files>
+              git commit -m "{type}({slug}): {task.title}"
+           g. Write .summaries/${task_id}-summary.md
+           h. Update .task/${task_id}.json:
+              status = "completed" | "blocked"
+
+       ELSE:
+         # --- CLI path (via maestro delegate) ---
+         fixedId = "${PHASE_NUM || 'scratch'}-${PHASE_SLUG}-${task_id}"
+         prompt = buildDelegatePrompt(task_def, phase_context, specs_content, prior_summaries)
+
+         # Store delegate ID for resume tracking
+         index.json.execution.delegate_ids[task_id] = fixedId
+
+         # Dispatch — synchronous, returns when done
+         Bash("maestro delegate \"${prompt}\" --to ${executor} --mode write --id ${fixedId}")
+
+         # Post-dispatch processing (CLI tools don't do this internally):
+         a. Verify convergence criteria against actual file state
+            For each criterion in task_def.convergence.criteria:
+              Check file contents / grep / test command
+         b. Determine status:
+            If all criteria pass: status = "completed"
+            Else: status = "blocked", log which criteria failed
+         c. Write .summaries/${task_id}-summary.md (from delegate output + verification result)
+         d. Update .task/${task_id}.json: status = status
+         e. Auto-commit (if --auto-commit and status == "completed"):
             git add <task files>
             git commit -m "{type}({slug}): {task.title}"
-         g. Write .summaries/${task_id}-summary.md
-         h. Update .task/${task_id}.json:
-            status = "completed" | "blocked"
 
     3. Collect result
-       result = { task_id, status, summary_path, commit_hash }
+       result = { task_id, status, executor, summary_path, commit_hash, delegate_id }
 
     4. Clear current_task_id in state.json
        Read .workflow/state.json
@@ -198,20 +293,36 @@ For each wave in execution_queue (sequential):
   Log "=== Wave {wave.wave} complete ==="
 ```
 
+### Parallel Dispatch Rules
+
+```
+Within a wave, tasks execute in parallel regardless of executor type:
+- Agent tasks: multiple Agent() calls in single message (run_in_background: false)
+- CLI tasks: multiple Bash("maestro delegate ...") calls in single message (run_in_background: true)
+- Mixed: Agent() + Bash() calls together in single message
+- Each task = one independent dispatch (never merge tasks into one delegate prompt)
+```
+
 ### Deviation Rule
 
 ```
 Per task, max 3 auto-fix attempts:
-  Attempt 1: Re-read error, try alternative approach
-  Attempt 2: Simplify implementation
-  Attempt 3: Minimal viable implementation
+
+Agent path: auto-fix handled internally by workflow-executor agent.
+
+CLI path: auto-fix via session resume:
+  Attempt 1: Re-dispatch with --resume ${fixedId}
+  Attempt 2: Re-dispatch with simplified prompt (reduce to core action + criteria)
+  Attempt 3: Fallback to agent executor for this task
 
 If all 3 fail:
   Mark task as "blocked" with checkpoint data:
     .task/${task_id}.json.meta.checkpoint = {
       attempt: 3,
       last_error: "...",
-      partial_files: [...]
+      partial_files: [...],
+      executor: executor,
+      delegate_id: fixedId
     }
   Continue wave (other tasks unaffected)
 ```
@@ -403,6 +514,7 @@ If NOT SCRATCH_MODE:
 | No plan exists | Abort: "No plan found. Run /workflow:plan first." |
 | Task file missing | Skip task, log error, continue wave |
 | Agent spawn fails | Retry once, then mark task as "blocked" |
+| Delegate fails | Resume with `--resume ${fixedId}`, then fallback to agent |
 | Git commit fails | Log warning, continue (task still marked completed) |
 | All tasks in wave blocked | Stop execution, report blocked wave |
 
@@ -414,14 +526,22 @@ The execute workflow is fully resumable:
 
 ```
 State tracking in index.json.execution:
-  tasks_completed: N     # Count of finished tasks
-  current_wave: W        # Last active wave
-  commits: [...]         # All commits made
+  tasks_completed: N       # Count of finished tasks
+  current_wave: W          # Last active wave
+  commits: [...]           # All commits made
+  method: "agent"|"cli"|"auto"    # Execution method used
+  default_executor: "gemini"|...  # CLI tool used (if method != "agent")
+  delegate_ids: { task_id: fixedId, ... }  # CLI task delegate IDs
 
 Re-running /workflow:execute <phase>:
   1. Reads index.json.execution.tasks_completed
   2. Checks each .task/TASK-*.json status
-  3. Builds queue of remaining tasks
-  4. Continues from next pending wave
-  5. No duplicate execution of completed tasks
+  3. For CLI-dispatched tasks with status "in-progress":
+     fixedId = index.json.execution.delegate_ids[task_id]
+     Check maestro delegate status ${fixedId}
+     If completed: retrieve output, process as completed
+     If failed: add to retry queue with --resume ${fixedId}
+  4. Builds queue of remaining tasks
+  5. Continues from next pending wave
+  6. No duplicate execution of completed tasks
 ```

package/workflows/init.md

@@ -87,7 +87,7 @@ CHECK .workflow/state.json exists?
 1. Create `.workflow/` directory structure
 2. Create `.workflow/state.json` (status: "idle")
 3. Offer codebase mapping:
-   - "Map codebase first" → execute `/spec-map` to understand existing architecture, then return
+   - "Map codebase first" → execute `/manage-codebase-rebuild` to understand existing architecture, then return
    - "Skip mapping" → proceed
 4. Run Workflow Preferences (same as Path A step 2) → `.workflow/config.json`
 5. Ask user for project vision, goals, constraints (same deep questioning as Path A step 1)

package/workflows/maestro-coordinate.codex.md

@@ -230,7 +230,7 @@ const chainMap = {
   'spec_setup':         [{ cmd: 'spec-setup' }],
   'spec_add':           [{ cmd: 'spec-add',                args: '"{description}"' }],
   'spec_load':          [{ cmd: 'spec-load',               args: '"{description}"' }],
-  'spec_map':           [{ cmd: 'spec-map' }],
+  'spec_map':           [{ cmd: 'manage-codebase-rebuild' }],
   'memory_capture':     [{ cmd: 'manage-memory-capture',   args: '"{description}"' }],
   'memory':             [{ cmd: 'manage-memory',           args: '"{description}"' }],
   'issue':              [{ cmd: 'manage-issue',            args: '"{description}"' }],

package/workflows/maestro-coordinate.md

@@ -214,7 +214,7 @@ const chainMap = {
   'spec_setup':         [{ cmd: 'spec-setup' }],
   'spec_add':           [{ cmd: 'spec-add', args: '"{description}"' }],
   'spec_load':          [{ cmd: 'spec-load', args: '"{description}"' }],
-  'spec_map':           [{ cmd: 'spec-map' }],
+  'spec_map':           [{ cmd: 'manage-codebase-rebuild' }],
   'memory_capture':     [{ cmd: 'manage-memory-capture', args: '"{description}"' }],
   'memory':             [{ cmd: 'manage-memory', args: '"{description}"' }],
   'issue':              [{ cmd: 'manage-issue', args: '"{description}"' }],

package/workflows/maestro.md

@@ -520,7 +520,7 @@ const chainMap = {
   'spec_setup':         [{ cmd: 'spec-setup' }],
   'spec_add':           [{ cmd: 'spec-add', args: '"{description}"' }],
   'spec_load':          [{ cmd: 'spec-load', args: '"{description}"' }],
-  'spec_map':           [{ cmd: 'spec-map' }],
+  'spec_map':           [{ cmd: 'manage-codebase-rebuild' }],
   'memory_capture':     [{ cmd: 'manage-memory-capture', args: '"{description}"' }],
   'issue':              [{ cmd: 'manage-issue', args: '"{description}"' }],
   'issue_discover':     [{ cmd: 'manage-issue-discover', args: '"{description}"' }],
@@ -662,7 +662,7 @@ function resolvePhase(intent_analysis, project_state) {
   const noPhaseCommands = ['manage-status', 'manage-issue', 'manage-issue-discover',
     'manage-issue-analyze', 'manage-issue-plan', 'manage-issue-execute',
     'maestro-init', 'maestro-spec-generate',
-    'maestro-roadmap', 'spec-setup', 'spec-map', 'manage-memory', 'manage-memory-capture', 'manage-learn',
+    'maestro-roadmap', 'spec-setup', 'manage-memory', 'manage-memory-capture', 'manage-learn',
     'manage-codebase-rebuild', 'manage-codebase-refresh', 'maestro-milestone-audit',
     'maestro-milestone-complete', 'maestro-phase-transition', 'maestro-phase-add'];
   if (chain.every(s => noPhaseCommands.includes(s.cmd))) return null;

package/workflows/memory.md

@@ -99,7 +99,8 @@ Hints:
   View:    /manage-memory view <ID|filename>
   Edit:    /manage-memory edit <filename>
   Search:  /manage-memory search <query>
-  Capture: /manage-memory-capture [compact|tip]
+  Capture: /manage-memory-capture compact
+  Tips:    /manage-learn tip <text>
 ```
 
 ### Step 4: Execute Search (search mode)

package/workflows/plan.md

@@ -401,7 +401,8 @@ Build plan.json with gap-fix tasks
      task_ids: [extracted from plan.json],
      task_count: plan.json.task_count,
      complexity: plan.json.complexity,
-     waves: plan.json.waves
+     waves: plan.json.waves,
+     executor_assignments: {}  # populated by user override or auto-assignment in P5
    }
    index.json.status = "planning"
    index.json.updated_at = now()
@@ -442,6 +443,10 @@ Build plan.json with gap-fix tasks
 
 3. **executionContext handoff** (if "Execute now")
    ```
+   executionMethod = config.json.execution.method || "agent"
+   defaultExecutor = config.json.execution.default_executor || "gemini"
+   executorAssignments = index.json.plan.executor_assignments || {}
+
    executionContext = {
      planObject: {
        plan: plan.json contents,
@@ -449,7 +454,9 @@ Build plan.json with gap-fix tasks
      },
      explorations: [ exploration-*.json contents ],
      clarifications: clarificationContext,
-     executionMethod: config.json.execution.method || "agent",
+     executionMethod: executionMethod,
+     defaultExecutor: defaultExecutor,
+     executorAssignments: executorAssignments,
      phaseIndex: index.json contents,
      specRef: spec-ref contents (if loaded)
    }

package/workflows/retrospective.md

@@ -507,14 +507,14 @@ insight.routed_id = "SPEC-retro-{phase_num}-{INS_id}-{slug}.md"
 
 #### Target: note
 
-Reuse the existing `manage-memory-capture` skill in tip mode — do not duplicate the memory pipeline.
+Reuse the existing `manage-learn` skill in tip mode — do not duplicate the learning pipeline.
 
 ```
 note_text = "[Retro phase {NN} / {lens}] {insight.title}: {insight.summary}"
 tags = insight.tags + ["retrospective", "phase-{NN}", insight.lens]
 
 Skill({
-  skill: "manage-memory-capture",
+  skill: "manage-learn",
   args: "tip \"{note_text}\" --tag " + tags.join(",")
 })
 

package/workflows/roadmap.md

@@ -61,7 +61,7 @@ IF .workflow/state.json exists:
     - key_decisions[] → architectural_constraints
     - blockers[] → known_risks
 
-IF .workflow/codebase/ exists (from spec-map or codebase-rebuild):
+IF .workflow/codebase/ exists (from codebase-rebuild or codebase-refresh):
   Read available codebase docs for feature inventory
 ```
 

package/.claude/commands/learn-retro-decision.md

@@ -1,198 +0,0 @@
----
-name: learn-retro-decision
-description: Decision trace and evaluation with multi-perspective analysis and lifecycle classification
-argument-hint: "[--phase N] [--tag <tag>] [--id <decision-id>]"
-allowed-tools:
-  - Read
-  - Write
-  - Bash
-  - Glob
-  - Grep
-  - Agent
-  - AskUserQuestion
----
-<purpose>
-Decision retrospective that traces architectural and design decisions across wiki, specs, phase contexts, and git history. Evaluates each decision from 3 perspectives (technical soundness, cost assessment, alternative hindsight) and classifies its lifecycle status.
-
-Inspired by gstack's cross-functional review pipeline (CEO/Eng/Design perspectives). Unlike `quality-retrospective` which reviews completed phases holistically, this command focuses specifically on decision quality and evolution.
-</purpose>
-
-<context>
-Arguments: $ARGUMENTS
-
-**Scope:**
-- No arguments → scan all sources for decisions, prompt for selection
-- `--phase N` → decisions from phase N's context and related specs
-- `--tag <tag>` → decisions tagged with specific tag in wiki/specs
-- `--id <id>` → single decision by wiki ID or lessons.jsonl INS-id
-
-**Storage written:**
-- `.workflow/learning/retro-decision-{YYYY-MM-DD}.md` — Decision evaluation report
-- `.workflow/learning/lessons.jsonl` — Decision evaluation insights (source: "retro-decision")
-- `.workflow/learning/learning-index.json` — Updated index
-
-**Storage read:**
-- `maestro wiki list --type spec --json` — Spec entries (many contain decisions)
-- `maestro wiki search "decision"` — Decision-tagged entries
-- `.workflow/specs/architecture-constraints.md` — Documented architectural decisions
-- `.workflow/phases/*/context.md` — Phase context with Locked/Free/Deferred decisions (if exists)
-- `.workflow/learning/lessons.jsonl` — Entries with `category: "decision"`
-- Git log — Implementation evidence for decision tracing
-</context>
-
-<execution>
-
-### Stage 1: Collect Decisions
-Gather decisions from all sources in parallel:
-
-```bash
-# Wiki decisions
-maestro wiki search "decision" --json
-maestro wiki list --type spec --json  # specs often contain decision entries
-
-# Git evidence
-git log --oneline --all --grep="decision\|chose\|decided\|architecture" -20
-```
-
-Also read:
-- `.workflow/specs/architecture-constraints.md` — grep for `### [decision]` heading blocks
-- `.workflow/phases/*/context.md` — scan for "Locked:", "Deferred:" sections
-- `.workflow/learning/lessons.jsonl` — filter entries where `category == "decision"`
-
-Apply scope filter (--phase, --tag, --id) to reduce the set.
-
-If no decisions found, AskUserQuestion: "No decisions found in wiki/specs. Would you like to: A) Scan git commit messages for implicit decisions, B) Provide a specific decision to evaluate"
-
-### Stage 2: Build Decision Registry
-For each decision, build a structured record:
-
-```json
-{
-  "id": "decision source id",
-  "title": "what was decided",
-  "source": "wiki|spec|phase-context|lesson|git",
-  "date": "when decided",
-  "rationale": "why (if documented)",
-  "alternatives": "what was considered (if documented)",
-  "phase": "which phase",
-  "tags": ["related tags"],
-  "implementation_evidence": ["file paths from git that implement this"]
-}
-```
-
-For implementation evidence: search git log for commits that reference the decision topic, and grep source files for patterns consistent with the decision.
-
-### Stage 3: Multi-Perspective Evaluation
-Spawn 3 Agents in a single message, each evaluating all decisions from one perspective:
-
-**Agent 1 — Technical Soundness:**
-- Does the implementation match the stated intent?
-- Are there code-level violations of the decision?
-- Has the technical context changed since the decision was made?
-- Grade: sound / degraded / violated
-
-**Agent 2 — Cost Assessment:**
-- What complexity did this decision add?
-- How many files/modules are affected?
-- Is the decision creating coupling or technical debt?
-- Grade: low-cost / acceptable / expensive / debt-creating
-
-**Agent 3 — Alternative Hindsight:**
-- With what we know now, was this the right call?
-- What alternative would we choose today?
-- Would reversing this decision be feasible?
-- Grade: confirmed / questionable / should-revisit
-
-Each agent receives the full decision registry and returns evaluations per decision.
-
-### Stage 4: Classify Decision Lifecycle
-Based on the 3 perspectives, classify each decision:
-
-| Status | Criteria |
-|--------|---------|
-| **Validated** | Sound + Low/Acceptable cost + Confirmed | 
-| **Aging** | Sound but Expensive + Confirmed (still right but costly) |
-| **Questionable** | Degraded or Violated + Any cost + Questionable |
-| **Stale** | Any soundness + Any cost + Should-revisit |
-| **Reversed** | Evidence in code contradicts the decision |
-
-### Stage 5: Generate Recommendations
-For each non-Validated decision:
-- **Aging**: flag for tech debt review, suggest cost reduction
-- **Questionable**: create issue for investigation, suggest brainstorm
-- **Stale**: suggest decision refresh (re-evaluate with current context)
-- **Reversed**: suggest documenting the reversal and updating specs/wiki
-
-### Stage 6: Write Report
-`.workflow/learning/retro-decision-{date}.md`:
-
-```markdown
-# Decision Retrospective: {scope}
-**Date:** {date} | **Decisions evaluated:** {count}
-
-## Decision Health Dashboard
-| Status | Count | Decisions |
-|--------|-------|-----------|
-| Validated | N | {list} |
-| Aging | N | {list} |
-| Questionable | N | {list} |
-| Stale | N | {list} |
-
-## Per-Decision Evaluation
-
-### {Decision Title}
-**Source:** {wiki/spec/phase} | **Date:** {when} | **Status:** {lifecycle}
-
-| Perspective | Grade | Assessment |
-|------------|-------|-----------|
-| Technical | sound/degraded/violated | {one-line} |
-| Cost | low/acceptable/expensive | {one-line} |
-| Hindsight | confirmed/questionable/revisit | {one-line} |
-
-**Implementation evidence:** {file references}
-**Recommendation:** {action if non-validated}
-
-## Recommended Actions
-1. {action}: {reason}
-```
-
-### Stage 7: Persist
-1. Write report file
-2. Append decision evaluation insights to `lessons.jsonl`:
-   - `source: "retro-decision"`, `category: "decision"`
-   - Tags: `["retro-decision", "{lifecycle-status}"]`
-   - One insight per non-Validated decision with the recommendation
-3. Update `learning-index.json`
-4. Optionally: update wiki entries with evaluation metadata via `maestro wiki update`
-5. Display health dashboard summary
-
-**Next-step routing:**
-- Create issue for questionable decision → `Skill({ skill: "manage-issue", args: "create ..." })`
-- Brainstorm alternatives → `Skill({ skill: "maestro-brainstorm", args: "<decision topic>" })`
-- Investigate stale decision → `Skill({ skill: "learn-investigate", args: "<question>" })`
-- Update spec → `Skill({ skill: "spec-add", args: "decision <updated rationale>" })`
-</execution>
-
-<error_codes>
-| Code | Severity | Condition | Recovery |
-|------|----------|-----------|----------|
-| E001 | error | No decisions found in any source | Check wiki/specs content, or provide --id |
-| E002 | error | --id not found in wiki or lessons | Verify the decision ID exists |
-| W001 | warning | One perspective agent failed — partial evaluation | Proceed with available perspectives, note gap |
-| W002 | warning | No git implementation evidence found for a decision | Decision evaluation is theoretical only |
-| W003 | warning | Phase context files not found | Skip phase-context decisions, proceed with wiki/spec sources |
-</error_codes>
-
-<success_criteria>
-- [ ] Decisions collected from all available sources (wiki, specs, phase-context, lessons, git)
-- [ ] Scope filter applied correctly (--phase, --tag, or --id)
-- [ ] Decision registry built with structured records
-- [ ] 3 perspective agents spawned in parallel
-- [ ] Each decision classified: Validated / Aging / Questionable / Stale / Reversed
-- [ ] Recommendations generated for non-Validated decisions
-- [ ] Report written to `retro-decision-{date}.md` with health dashboard
-- [ ] Insights appended to `lessons.jsonl` (source: "retro-decision")
-- [ ] `learning-index.json` updated
-- [ ] No files modified outside `.workflow/learning/`
-- [ ] Health dashboard displayed with next-step routing
-</success_criteria>