maestro-flow 0.3.12 → 0.3.13

package/workflows/merge.md

@@ -106,28 +106,15 @@ incompletePhases = []
 // Read worktree state for artifact registry check
 Read {target.path}/.workflow/state.json → wtState (if exists)
 wtArtifacts = wtState?.artifacts ?? []
-useArtifactRegistry = wtArtifacts.length > 0
-
-IF useArtifactRegistry:
-  // Check phase completeness via artifact registry
-  for (phaseNum of target.owned_phases):
-    execArtifacts = wtArtifacts.filter(a => a.type === 'execute' && a.phase === phaseNum)
-    IF execArtifacts.some(a => a.status === 'completed'):
-      completedPhases.push({ phase: phaseNum })
-    ELSE:
-      status = execArtifacts.length > 0 ? execArtifacts[0].status : 'no_execute_artifact'
-      incompletePhases.push({ phase: phaseNum, status })
-ELSE:
-  // Legacy: check phases/ directory
-  for (phaseNum of target.owned_phases):
-    NN = String(phaseNum).padStart(2, '0')
-    Glob: {target.path}/.workflow/phases/{NN}-*/index.json
-    Read → wtIndex
 
-    IF wtIndex.status === "completed":
-      completedPhases.push({ phase: phaseNum, index: wtIndex })
-    ELSE:
-      incompletePhases.push({ phase: phaseNum, status: wtIndex.status })
+// Check phase completeness via artifact registry
+for (phaseNum of target.owned_phases):
+  execArtifacts = wtArtifacts.filter(a => a.type === 'execute' && a.phase === phaseNum)
+  IF execArtifacts.some(a => a.status === 'completed'):
+    completedPhases.push({ phase: phaseNum })
+  ELSE:
+    status = execArtifacts.length > 0 ? execArtifacts[0].status : 'no_execute_artifact'
+    incompletePhases.push({ phase: phaseNum, status })
 
 IF incompletePhases.length > 0 AND NOT force:
   WARN W002: "M{target.milestone_num} ({target.milestone}) has incomplete phases:"
@@ -199,88 +186,42 @@ Display "Syncing workflow artifacts for M{target.milestone_num} ({target.milesto
 
 Read .workflow/state.json → mainState
 
-IF useArtifactRegistry:
-  // 7a: Copy scratch dirs from worktree to main
-  Read {target.path}/.workflow/state.json → wtState
-  wtArtifacts = wtState?.artifacts ?? []
-  milestoneArtifacts = wtArtifacts.filter(a =>
-    a.path && (a.milestone === target.milestone || target.owned_phases.includes(a.phase))
-  )
-  for (art of milestoneArtifacts):
-    srcDir = target.path + "/.workflow/" + art.path
-    dstDir = ".workflow/" + art.path
-    IF directory_exists(srcDir):
-      Bash("mkdir -p {dstDir} && cp -r {srcDir}/* {dstDir}/")
-
-  // 7b: Merge artifact registries
-  mainArtifacts = mainState.artifacts ?? []
-  existingIds = new Set(mainArtifacts.map(a => a.id))
-  for (art of wtArtifacts):
-    IF existingIds.has(art.id):
-      // Update existing artifact status
-      idx = mainArtifacts.findIndex(a => a.id === art.id)
-      mainArtifacts[idx] = art
-    ELSE:
-      mainArtifacts.push(art)
-  mainState.artifacts = mainArtifacts
-
-  // Record merge in transition history
-  mainState.transition_history = mainState.transition_history ?? []
-  mainState.transition_history.push({
-    milestone_num: target.milestone_num,
-    milestone: target.milestone,
-    action: "worktree_merge",
-    completed_at: getUtc8ISOString(),
-    branch: target.branch,
-    phases: target.owned_phases
-  })
-
-ELSE:
-  // Legacy: copy phase directories from worktree to main
-  // 7a: Copy all owned phase directories
-  for (phaseNum of target.owned_phases):
-    NN = String(phaseNum).padStart(2, '0')
-    Glob: {target.path}/.workflow/phases/{NN}-*/
-    phaseDir = matched directory name
-
-    srcDir = target.path + "/.workflow/phases/" + phaseDir + "/"
-    dstDir = ".workflow/phases/" + phaseDir + "/"
-
-    Bash("cp -r {srcDir}* {dstDir}")
-
-  // 7b: Update phase summaries
-  for (phaseNum of target.owned_phases):
-    NN = String(phaseNum).padStart(2, '0')
-    Glob: .workflow/phases/{NN}-*/index.json
-    Read → phaseIndex
-
-    IF phaseIndex.status === "completed":
-      mainState.phases_summary.completed += 1
-      mainState.phases_summary.pending -= 1
-      IF mainState.phases_summary.pending < 0:
-        mainState.phases_summary.pending = 0
-
-      mainState.transition_history = mainState.transition_history ?? []
-      mainState.transition_history.push({
-        milestone_num: target.milestone_num,
-        milestone: target.milestone,
-        phase: phaseNum,
-        action: "worktree_merge",
-        completed_at: phaseIndex.completed_at ?? getUtc8ISOString(),
-        branch: target.branch
-      })
-    ELSE IF phaseIndex.status !== "forked":
-      mainState.phases_summary.in_progress += 1
-      mainState.phases_summary.pending -= 1
-      IF mainState.phases_summary.pending < 0:
-        mainState.phases_summary.pending = 0
-
-    phaseIndex.updated_at = getUtc8ISOString()
-    Write .workflow/phases/{NN}-{slug}/index.json: phaseIndex
-
-// Merge accumulated context from worktree (both paths)
-IF NOT useArtifactRegistry:
-  Read target.path + "/.workflow/state.json" → wtState (if exists)
+// 7a: Copy scratch dirs from worktree to main
+Read {target.path}/.workflow/state.json → wtState
+wtArtifacts = wtState?.artifacts ?? []
+milestoneArtifacts = wtArtifacts.filter(a =>
+  a.path && (a.milestone === target.milestone || target.owned_phases.includes(a.phase))
+)
+for (art of milestoneArtifacts):
+  srcDir = target.path + "/.workflow/" + art.path
+  dstDir = ".workflow/" + art.path
+  IF directory_exists(srcDir):
+    Bash("mkdir -p {dstDir} && cp -r {srcDir}/* {dstDir}/")
+
+// 7b: Merge artifact registries
+mainArtifacts = mainState.artifacts ?? []
+existingIds = new Set(mainArtifacts.map(a => a.id))
+for (art of wtArtifacts):
+  IF existingIds.has(art.id):
+    // Update existing artifact status
+    idx = mainArtifacts.findIndex(a => a.id === art.id)
+    mainArtifacts[idx] = art
+  ELSE:
+    mainArtifacts.push(art)
+mainState.artifacts = mainArtifacts
+
+// Record merge in transition history
+mainState.transition_history = mainState.transition_history ?? []
+mainState.transition_history.push({
+  milestone_num: target.milestone_num,
+  milestone: target.milestone,
+  action: "worktree_merge",
+  completed_at: getUtc8ISOString(),
+  branch: target.branch,
+  phases: target.owned_phases
+})
+
+// Merge accumulated context from worktree
 IF wtState?.accumulated_context:
   for (decision of (wtState.accumulated_context.key_decisions ?? [])):
     IF NOT mainState.accumulated_context.key_decisions.includes(decision):
@@ -294,10 +235,7 @@ Write .workflow/state.json: mainState
 // 7c: Update roadmap.md (mark completed phases)
 Read .workflow/roadmap.md → roadmap
 for (phaseNum of target.owned_phases):
-  IF useArtifactRegistry:
-    isCompleted = completedPhases.some(p => p.phase === phaseNum)
-  ELSE:
-    Read phase index → isCompleted = (status === "completed")
+  isCompleted = completedPhases.some(p => p.phase === phaseNum)
   IF isCompleted:
     Append " ✅ COMPLETED" to phase title line in roadmap
 Write .workflow/roadmap.md: roadmap

package/workflows/milestone-complete.md

@@ -66,24 +66,41 @@ Check existing entries to avoid duplicates when appending in Step 3.
    - Extract patterns discovered
    - Extract pitfalls encountered
 
-2. Aggregate learnings and append to `.workflow/specs/learnings.md`:
+2. Aggregate learnings and append to `.workflow/specs/learnings.md` using `<spec-entry>` closed-tag format:
    ```
    For each strategy adjustment:
-     ### [YYYY-MM-DD HH:mm] decision: {summary}
+     <spec-entry category="learning" keywords="{auto-extracted}" date="{YYYY-MM-DD}" source="milestone-complete">
+
+     ### {summary}
+
      {content}
-     Milestone: {milestone} | Source: milestone-complete
+     Milestone: {milestone}
+
+     </spec-entry>
 
    For each pattern:
-     ### [YYYY-MM-DD HH:mm] pattern: {summary}
+     <spec-entry category="learning" keywords="{auto-extracted}" date="{YYYY-MM-DD}" source="milestone-complete">
+
+     ### {summary}
+
      {content}
-     Milestone: {milestone} | Source: milestone-complete
+     Milestone: {milestone}
+
+     </spec-entry>
 
    For each pitfall:
-     ### [YYYY-MM-DD HH:mm] bug: {summary}
+     <spec-entry category="learning" keywords="{auto-extracted}" date="{YYYY-MM-DD}" source="milestone-complete">
+
+     ### {summary}
+
      {content}
-     Milestone: {milestone} | Source: milestone-complete
+     Milestone: {milestone}
+
+     </spec-entry>
    ```
 
+   **Keyword extraction**: Extract 3-5 domain-specific terms from the content (same rules as `spec-add`).
+
 ---
 
 ## Step 4: Update State

package/workflows/retrospective.md

@@ -9,7 +9,7 @@ This is a **post-execution analysis** workflow. It reads only — until the rout
 ## Prerequisites
 
 - `.workflow/` initialized (`.workflow/state.json` exists)
-- At least one completed phase (via artifact registry in state.json, or legacy `.workflow/phases/{NN}-{slug}/`)
+- At least one completed phase (via artifact registry in state.json)
 - Target phase has been executed (has `.task/` and `.summaries/`)
 - `maestro delegate` available (used for the four lens analyses via Agent calls)
 
@@ -64,43 +64,24 @@ candidates = []
 
 Read .workflow/state.json → state
 artifacts = state.artifacts ?? []
-useArtifactRegistry = artifacts.length > 0
-
-IF useArtifactRegistry:
-  // Resolve completed phases from artifact registry
-  phaseNums = [...new Set(artifacts.map(a => a.phase).filter(Boolean))]
-  FOR each phaseNum in phaseNums:
-    execArt = artifacts.find(a => a.type === 'execute' && a.phase === phaseNum && a.status === 'completed')
-    IF execArt:
-      scratchDir = ".workflow/" + execArt.path
-      has_retro = file exists at "{scratchDir}/retrospective.json"
-      candidates.push({
-        number: phaseNum,
-        slug: execArt.slug ?? "phase-" + phaseNum,
-        title: execArt.title ?? execArt.slug ?? "Phase " + phaseNum,
-        completed_at: execArt.completed_at,
-        has_retro: has_retro,
-        phase_dir: scratchDir,
-        gaps: 0,
-        review_verdict: "—"
-      })
-ELSE:
-  // Legacy: scan phases/ directory
-  FOR each .workflow/phases/{NN}-{slug}/index.json:
-    Read index.json
-    IF index.json.status == "completed":
-      phase_dir = ".workflow/phases/{NN}-{slug}"
-      has_retro = file exists at "{phase_dir}/retrospective.json"
-      candidates.push({
-        number: NN,
-        slug: slug,
-        title: index.json.title or slug,
-        completed_at: index.json.completed_at,
-        has_retro: has_retro,
-        phase_dir: phase_dir,
-        gaps: index.json.verification?.gaps?.length or 0,
-        review_verdict: index.json.review?.verdict or "—"
-      })
+
+// Resolve completed phases from artifact registry
+phaseNums = [...new Set(artifacts.map(a => a.phase).filter(Boolean))]
+FOR each phaseNum in phaseNums:
+  execArt = artifacts.find(a => a.type === 'execute' && a.phase === phaseNum && a.status === 'completed')
+  IF execArt:
+    artifact_dir = ".workflow/" + execArt.path
+    has_retro = file exists at "{artifact_dir}/retrospective.json"
+    candidates.push({
+      number: phaseNum,
+      slug: execArt.slug ?? "phase-" + phaseNum,
+      title: execArt.title ?? execArt.slug ?? "Phase " + phaseNum,
+      completed_at: execArt.completed_at,
+      has_retro: has_retro,
+      phase_dir: artifact_dir,
+      gaps: 0,
+      review_verdict: "—"
+    })
 ```
 
 ### Display backlog
@@ -130,7 +111,7 @@ ELSE:
 
 If overwriting existing retrospective.json:
 ```
-mkdir -p "{candidate.phase_dir}/.history"
+mkdir -p "{candidate.phase_dir}/.history"   // phase_dir is artifact_dir from registry
 TIMESTAMP = format(now(), "YYYY-MM-DDTHH-mm-ss")
 mv "{candidate.phase_dir}/retrospective.json" "{candidate.phase_dir}/.history/retrospective-{TIMESTAMP}.json"
 mv "{candidate.phase_dir}/retrospective.md"   "{candidate.phase_dir}/.history/retrospective-{TIMESTAMP}.md"
@@ -143,20 +124,20 @@ mv "{candidate.phase_dir}/retrospective.md"   "{candidate.phase_dir}/.history/re
 For each selected phase (using `candidate.phase_dir` resolved in Stage 2), build the in-memory artifacts bundle:
 
 ```
-phase_dir = candidate.phase_dir  // already resolved: scratch path (artifact registry) or legacy phases/ path
+phase_dir = candidate.phase_dir  // already resolved from artifact registry (e.g. .workflow/scratch/plan-auth-2026-04-20)
 
 artifacts = {
   phase_num: NN,
   phase_slug: slug,
-  phase_dir: phase_dir,
-  index: read "{phase_dir}/index.json" or null,
+  artifact_dir: artifact_dir,
+  index: read "{artifact_dir}/index.json" or null,
   state: read .workflow/state.json,
-  plan: read "{phase_dir}/plan.json" or null,
-  verification: read "{phase_dir}/verification.json" or null,
-  review: read "{phase_dir}/review.json" or null,
-  uat: read "{phase_dir}/uat.md" or null,
-  task_summaries: read all "{phase_dir}/.summaries/TASK-*-summary.md",
-  task_jsons: read all "{phase_dir}/.task/TASK-*.json",
+  plan: read "{artifact_dir}/plan.json" or null,
+  verification: read "{artifact_dir}/verification.json" or null,
+  review: read "{artifact_dir}/review.json" or null,
+  uat: read "{artifact_dir}/uat.md" or null,
+  task_summaries: read all "{artifact_dir}/.summaries/TASK-*-summary.md",
+  task_jsons: read all "{artifact_dir}/.task/TASK-*.json",
   phase_issues: filter ".workflow/issues/issues.jsonl" + ".workflow/issues/issue-history.jsonl"
                 where issue.phase_ref == phase_slug or issue.phase_ref == NN,
   prior_retro: null
@@ -164,12 +145,9 @@ artifacts = {
 
 // Resolve --compare target
 IF --compare M:
-  IF useArtifactRegistry:
-    compareArt = state.artifacts.find(a => a.type === 'execute' && a.phase === M)
-    IF compareArt:
-      artifacts.prior_retro = read ".workflow/" + compareArt.path + "/retrospective.json"
-  ELSE:
-    artifacts.prior_retro = read .workflow/phases/{MM}-*/retrospective.json
+  compareArt = state.artifacts.find(a => a.type === 'execute' && a.phase === M)
+  IF compareArt:
+    artifacts.prior_retro = read ".workflow/" + compareArt.path + "/retrospective.json"
 }
 ```
 
@@ -245,12 +223,12 @@ the project's spec / note / issue stores.
 - Completed at: {index.completed_at}
 
 ## Artifacts (read these from disk)
-- Plan:           {phase_dir}/plan.json
-- Verification:   {phase_dir}/verification.json
-- Review:         {phase_dir}/review.json
-- UAT notes:      {phase_dir}/uat.md
-- Task summaries: {phase_dir}/.summaries/
-- Task JSONs:     {phase_dir}/.task/
+- Plan:           {artifact_dir}/plan.json
+- Verification:   {artifact_dir}/verification.json
+- Review:         {artifact_dir}/review.json
+- UAT notes:      {artifact_dir}/uat.md
+- Task summaries: {artifact_dir}/.summaries/
+- Task JSONs:     {artifact_dir}/.task/
 - Phase issues:   .workflow/issues/issues.jsonl (filter phase_ref == "{phase_slug}")
 - Project state:  .workflow/state.json (decisions, deferred)
 
@@ -287,7 +265,7 @@ Return ONLY a single JSON object, no prose, matching this schema:
       "title": "Short imperative title",
       "summary": "1–3 sentences a future planner can act on",
       "confidence": "high|medium|low",
-      "evidence_refs": ["{phase_dir}/verification.json#gaps[2]", "..."],
+      "evidence_refs": ["{artifact_dir}/verification.json#gaps[2]", "..."],
       "routed_to": "spec|note|issue|none",
       "tags": ["..."]
     }
@@ -463,8 +441,8 @@ retrospective = {
 
 Write both files (phase_dir already resolved in Stage 2):
 ```
-Write "{phase_dir}/retrospective.json"
-Write "{phase_dir}/retrospective.md"
+Write "{artifact_dir}/retrospective.json"
+Write "{artifact_dir}/retrospective.md"
 ```
 
 ---
@@ -493,46 +471,31 @@ Accept all? [Y/n/i for individual]
 
 #### Target: spec
 
-Write a stub spec file directly. Do NOT invoke `spec-generate` (heavyweight 7-phase pipeline).
+Route spec-routed insights as `<spec-entry>` entries into the appropriate category file. Map insight type to category:
+- `pattern` / `convention` → `coding`
+- `adr-candidate` / architecture → `arch`
+- quality-related → `quality`
 
 ```
-mkdir -p ".workflow/specs"
-slug = slugify(insight.title)
-spec_file = ".workflow/specs/SPEC-retro-{phase_num}-{INS_id}-{slug}.md"
-
-Write spec_file:
----
-status: draft
-type: pattern | convention | adr-candidate
-source: retrospective
-source_phase: {NN}
-source_insight: {INS_id}
-created_at: {now ISO}
-tags: {insight.tags}
-confidence: {insight.confidence}
----
-
-# {insight.title}
+category = map_insight_to_category(insight.type)
+target_file = category_to_file(category)  # e.g., coding → coding-conventions.md
 
-## Context
+keywords = extract_keywords(insight.title + insight.summary)  # 3-5 domain-specific terms
 
-Extracted from phase {NN} ({phase_slug}) retrospective by the {lens} lens.
-This stub captures a reusable {category} surfaced during execution; expand it
-into a full spec via `/maestro-spec-generate` if it warrants project-wide adoption.
+Append to .workflow/specs/{target_file}:
+  <spec-entry category="{category}" keywords="{keywords}" date="{YYYY-MM-DD}" source="retrospective">
 
-## Pattern / Convention
+  ### {insight.title}
 
-{insight.summary}
+  {insight.summary}
 
-## Evidence
+  **Evidence:** {FOR ref in evidence_refs:} `{ref}` {END FOR}
+  **Phase:** {NN} ({phase_slug}) | **Lens:** {lens} | **Insight:** {INS_id} | **Confidence:** {insight.confidence}
 
-{FOR ref in evidence_refs:} - `{ref}`{END FOR}
-
-## Open Questions
+  </spec-entry>
+```
 
-- Is this pattern already documented elsewhere?
-- Should existing code be migrated to this pattern, or is it forward-only?
-- What is the failure mode if this pattern is violated?
+If the target file does not exist, create it with category frontmatter first (same as `spec-add` on-demand creation).
 
 ## Routing trail
 
@@ -541,7 +504,7 @@ into a full spec via `/maestro-spec-generate` if it warrants project-wide adopti
 - Insight: {INS_id}
 - Confidence: {confidence}
 
-insight.routed_id = "SPEC-retro-{phase_num}-{INS_id}-{slug}.md"
+insight.routed_id = "{category_file}#INS-{INS_id}"  # e.g., coding-conventions.md#INS-a1b2c3d4
 ```
 
 #### Target: note
@@ -561,7 +524,7 @@ Capture the returned TIP-{id} from the skill output.
 insight.routed_id = "TIP-{captured_id}"
 ```
 
-If the skill call cannot be intercepted to capture the ID, fall back to writing the tip file directly using the schema in `workflows/memory.md` Part B Step 3 (Tip mode), and update `memory-index.json` per Step 4.
+If the skill call cannot be intercepted to capture the ID, fall back to writing the tip file directly using the schema in `workflows/memory.md` Part B Step 3 (Tip mode), and update `wiki-index.json` per Step 4.
 
 #### Target: issue
 
@@ -706,19 +669,24 @@ Write .workflow/learning/learning-index.json
 
 ### Backward-compat append to specs/learnings.md
 
-Append learnings to `.workflow/specs/learnings.md` (shared with milestone-complete's learning extraction). Append a one-line summary per insight:
+Append learnings to `.workflow/specs/learnings.md` (shared with milestone-complete's learning extraction) using `<spec-entry>` closed-tag format:
 
 ```
 IF .workflow/specs/learnings.md exists:
   FOR each insight:
-    Append under "## Entries":
-      ### [{YYYY-MM-DD HH:mm}] {category}: {title}
+    keywords = extract_keywords(insight.title + insight.summary)  # 3-5 domain-specific terms
+    Append:
+      <spec-entry category="learning" keywords="{keywords}" date="{YYYY-MM-DD}" source="retrospective">
+
+      ### {title}
 
       {summary}
-      Phase: {NN} | Source: retrospective | Insight: {INS_id} | Lens: {lens}
+      Phase: {NN} | Lens: {lens} | Insight: {INS_id}
+
+      </spec-entry>
 ```
 
-If the file does not exist, create it with a `## Entries` header.
+If the file does not exist, create it with category frontmatter and a `## Entries` header.
 
 ---
 
@@ -733,14 +701,14 @@ Lenses run:      {lenses joined by ", "}
 Insights:        {count}
 
 Routing summary:
-  Specs drafted:   {N}  → .workflow/specs/SPEC-retro-*
+  Spec entries:    {N}  → .workflow/specs/{category-file}.md
   Notes saved:     {N}  → .workflow/memory/TIP-*
   Issues opened:   {N}  → .workflow/issues/issues.jsonl
   Lessons logged:  {N}  → .workflow/learning/lessons.jsonl
 
 Files:
-  {phase_dir}/retrospective.md
-  {phase_dir}/retrospective.json
+  {artifact_dir}/retrospective.md
+  {artifact_dir}/retrospective.json
 
 Next steps (suggested):
   Skill({ skill: "manage-status" })                                    — Review project state
@@ -809,12 +777,12 @@ Total issues:        {sum}
       "summary": "Refresh-on-use prevents replay attacks. Implemented in src/auth/refresh.ts; should become a project-wide convention.",
       "confidence": "high",
       "evidence_refs": [
-        ".workflow/phases/01-auth/verification.json#gaps[2]",
-        ".workflow/phases/01-auth/.summaries/TASK-005-summary.md:42"
+        ".workflow/scratch/plan-auth-2026-04-15/verification.json#gaps[2]",
+        ".workflow/scratch/plan-auth-2026-04-15/.summaries/TASK-005-summary.md:42"
       ],
       "tags": ["auth", "jwt", "security"],
       "routed_to": "spec",
-      "routed_id": "SPEC-retro-1-INS-a1b2c3d4-jwt-refresh-rotation.md"
+      "routed_id": "coding-conventions.md#INS-a1b2c3d4"
     }
   ],
   "routing_recommendations": [
@@ -829,7 +797,7 @@ Total issues:        {sum}
 One JSON object per line:
 
 ```json
-{"id":"INS-a1b2c3d4","phase":1,"phase_slug":"01-auth","lens":"technical","category":"pattern","title":"JWT refresh tokens must rotate on every use","summary":"...","confidence":"high","tags":["auth","jwt","security"],"evidence_refs":["..."],"routed_to":"spec","routed_id":"SPEC-retro-1-INS-a1b2c3d4-jwt-refresh-rotation.md","source":"retrospective","captured_at":"2026-04-11T10:00:00Z"}
+{"id":"INS-a1b2c3d4","phase":1,"phase_slug":"01-auth","lens":"technical","category":"pattern","title":"JWT refresh tokens must rotate on every use","summary":"...","confidence":"high","tags":["auth","jwt","security"],"evidence_refs":["..."],"routed_to":"spec","routed_id":"coding-conventions.md#INS-a1b2c3d4","source":"retrospective","captured_at":"2026-04-11T10:00:00Z"}
 ```
 
 ### learning-index.json
@@ -850,7 +818,7 @@ One JSON object per line:
       "phase_slug": "01-auth",
       "confidence": "high",
       "routed_to": "spec",
-      "routed_id": "SPEC-retro-1-INS-a1b2c3d4-jwt-refresh-rotation.md"
+      "routed_id": "coding-conventions.md#INS-a1b2c3d4"
     }
   ],
   "_metadata": {

package/workflows/review.md

@@ -18,18 +18,11 @@ Input: <phase> argument (number or slug)
 
 Read .workflow/state.json → state
 artifacts = state.artifacts ?? []
-useArtifactRegistry = artifacts.length > 0
 
-IF useArtifactRegistry:
-  IF number: art = artifacts.find(a => a.type === 'execute' && a.phase === number)
-  IF slug:   art = artifacts.find(a => a.type === 'execute' && a.slug?.includes(slug))
-  IF art:    PHASE_DIR = ".workflow/" + art.path
-  ELSE:      ERROR "Phase not found in artifact registry"
-ELSE:
-  // Legacy: resolve from phases/ directory
-  IF number: find .workflow/phases/{NN}-*/index.json
-  IF slug:   find .workflow/phases/*-{slug}/index.json
-  PHASE_DIR = resolved path
+IF number: art = artifacts.find(a => a.type === 'execute' && a.phase === number)
+IF slug:   art = artifacts.find(a => a.type === 'execute' && a.slug?.includes(slug))
+IF art:    PHASE_DIR = ".workflow/" + art.path
+ELSE:      ERROR "Phase not found in artifact registry"
 
 Validate execution has occurred (tasks_completed > 0 or .task/ exists)
 ```
@@ -587,7 +580,7 @@ Verdict: {PASS | WARN | BLOCK}
 Issues Created: {count}
 
 Files:
-  {phase_dir}/review.json
+  {artifact_dir}/review.json
 
 Next steps:
   {suggested_next_command}