@leeovery/claude-technical-workflows 2.1.25 → 2.1.27

package/README.md

@@ -291,7 +291,7 @@ Helpers for navigating and maintaining the workflow.
 | Skill                                                                        | Description                                                                                                                                 |
 |------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------|
 | [**/migrate**](skills/migrate/)                                              | Keep workflow files in sync with the current system design. Runs automatically at the start of every workflow skill.                        |
-| [**/status**](skills/status/)                                                | Show workflow status - what topics exist at each phase, and suggested next steps.                                                           |
+| [**/status**](skills/status/)                                                | Show workflow status with relationship-aware display — specification sources, unlinked discussions, plan dependencies, and suggested next steps. |
 | [**/view-plan**](skills/view-plan/)                                          | View a plan's tasks and progress, regardless of output format.                                                                              |
 
 #### Standalone Skills

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leeovery/claude-technical-workflows",
-  "version": "2.1.25",
+  "version": "2.1.27",
   "description": "Technical workflow skills & commands for Claude Code",
   "license": "MIT",
   "author": "Lee Overy <me@leeovery.com>",

package/skills/start-planning/SKILL.md

@@ -126,113 +126,9 @@ At least one specification is ready for planning, or an existing plan can be con
 
 ## Step 3: Present Workflow State and Options
 
-Present everything discovered to help the user make an informed choice.
+Load **[display-state.md](references/display-state.md)** and follow its instructions as written.
 
-**Present the full state:**
-
-> *Output the next fenced block as a code block:*
-
-```
-Planning Overview
-
-{N} specifications found. {M} plans exist.
-
-1. {topic:(titlecase)}
-   └─ Plan: @if(has_plan) {plan_status:[in-progress|concluded]} @else (no plan) @endif
-   └─ Spec: concluded
-
-2. ...
-```
-
-**Tree rules:**
-
-Each numbered item shows a feature specification that is actionable:
-- Concluded spec with no plan → `Plan: (no plan)`
-- Has a plan with `plan_status: planning` → `Plan: in-progress`
-- Has a plan with `plan_status: concluded` → `Plan: concluded`
-
-**If non-plannable specifications exist**, show them in a separate code block:
-
-> *Output the next fenced block as a code block:*
-
-```
-Specifications not ready for planning:
-These specifications are either still in progress or cross-cutting
-and cannot be planned directly.
-
-  • {topic} ({type:[feature|cross-cutting]}, {status:[in-progress|concluded]})
-```
-
-**Key/Legend** — show only statuses that appear in the current display. No `---` separator before this section.
-
-> *Output the next fenced block as a code block:*
-
-```
-Key:
-
-  Plan status:
-    in-progress — planning work is ongoing
-    concluded   — plan is complete
-
-  Spec type:
-    cross-cutting — architectural policy, not directly plannable
-    feature       — plannable feature specification
-```
-
-Omit any section entirely if it has no entries.
-
-**Then prompt based on what's actionable:**
-
-**If multiple actionable items:**
-
-The verb in the menu depends on the plan state:
-- No plan exists → **Create**
-- Plan is `in-progress` → **Continue**
-- Plan is `concluded` → **Review**
-
-> *Output the next fenced block as markdown (not a code block):*
-
-```
-· · · · · · · · · · · ·
-1. Create "Auth Flow" — concluded spec, no plan
-2. Continue "Data Model" — plan in-progress
-3. Review "Billing" — plan concluded
-
-Select an option (enter number):
-· · · · · · · · · · · ·
-```
-
-Recreate with actual topics and states from discovery.
-
-**STOP.** Wait for user response.
-
-**If single actionable item (auto-select):**
-
-> *Output the next fenced block as a code block:*
-
-```
-Automatically proceeding with "{topic:(titlecase)}".
-```
-
-→ Proceed directly to **Step 4**.
-
-**If nothing actionable:**
-
-> *Output the next fenced block as a code block:*
-
-```
-Planning Overview
-
-No plannable specifications found.
-
-The planning phase requires a concluded feature specification.
-Complete any in-progress specifications with /start-specification,
-or create a new specification first.
-```
-
-**STOP.** Do not proceed — terminal condition.
-
-→ Based on user choice, proceed to **Step 4**.
+→ Proceed to **Step 4**.
 
 ---
 
@@ -273,46 +169,7 @@ Any additional context since the specification was concluded?
 
 ## Step 6: Surface Cross-Cutting Context
 
-**If no cross-cutting specifications exist**: Skip this step. → Proceed to **Step 7**.
-
-Read each cross-cutting specification from `specifications.crosscutting` in the discovery output.
-
-### 6a: Warn about in-progress cross-cutting specs
-
-If any **in-progress** cross-cutting specifications exist, check whether they could be relevant to the feature being planned (by topic overlap — e.g., a caching strategy is relevant if the feature involves data retrieval or API calls).
-
-If any are relevant:
-
-> *Output the next fenced block as markdown (not a code block):*
-
-```
-Cross-cutting specifications still in progress:
-These may contain architectural decisions relevant to this plan.
-
-  • {topic}
-
-· · · · · · · · · · · ·
-- **`c`/`continue`** — Plan without them
-- **`s`/`stop`** — Complete them first (/start-specification)
-· · · · · · · · · · · ·
-```
-
-**STOP.** Wait for user response.
-
-If the user chooses to stop, end here. If they choose to continue, proceed.
-
-### 6b: Summarize concluded cross-cutting specs
-
-If any **concluded** cross-cutting specifications exist, identify which are relevant to the feature being planned and summarize for handoff:
-
-> *Output the next fenced block as a code block:*
-
-```
-Cross-cutting specifications to reference:
-- caching-strategy.md: [brief summary of key decisions]
-```
-
-These specifications contain validated architectural decisions that should inform the plan. The planning skill will incorporate these as a "Cross-Cutting References" section in the plan.
+Load **[cross-cutting-context.md](references/cross-cutting-context.md)** and follow its instructions as written.
 
 → Proceed to **Step 7**.
 
@@ -320,33 +177,4 @@ These specifications contain validated architectural decisions that should infor
 
 ## Step 7: Invoke the Skill
 
-After completing the steps above, this skill's purpose is fulfilled.
-
-Invoke the [technical-planning](../technical-planning/SKILL.md) skill for your next instructions. Do not act on the gathered information until the skill is loaded - it contains the instructions for how to proceed.
-
-**Example handoff (fresh plan):**
-```
-Planning session for: {topic}
-Specification: docs/workflow/specification/{topic}.md
-Additional context: {summary of user's answers from Step 5}
-Cross-cutting references: {list of applicable cross-cutting specs with brief summaries, or "none"}
-Recommended output format: {common_format from discovery if non-empty, otherwise "none"}
-
-Invoke the technical-planning skill.
-```
-
-**Example handoff (continue/review existing plan):**
-```
-Planning session for: {topic}
-Specification: docs/workflow/specification/{topic}.md
-Existing plan: docs/workflow/planning/{topic}.md
-
-Invoke the technical-planning skill.
-```
-
-## Notes
-
-- Ask questions clearly and wait for responses before proceeding
-- The feature specification is the primary source of truth for planning
-- Cross-cutting specifications provide supplementary context for architectural decisions
-- Do not reference discussions - only specifications
+Load **[invoke-skill.md](references/invoke-skill.md)** and follow its instructions as written.

package/skills/start-planning/references/cross-cutting-context.md

@@ -0,0 +1,50 @@
+# Cross-Cutting Context
+
+*Reference for **[start-planning](../SKILL.md)***
+
+---
+
+**If no cross-cutting specifications exist**:
+
+Skip this step.
+
+→ Proceed to **Step 7**.
+
+Read each cross-cutting specification from `specifications.crosscutting` in the discovery output.
+
+### 6a: Warn about in-progress cross-cutting specs
+
+If any **in-progress** cross-cutting specifications exist, check whether they could be relevant to the feature being planned (by topic overlap — e.g., a caching strategy is relevant if the feature involves data retrieval or API calls).
+
+If any are relevant:
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+Cross-cutting specifications still in progress:
+These may contain architectural decisions relevant to this plan.
+
+  • {topic}
+
+· · · · · · · · · · · ·
+- **`c`/`continue`** — Plan without them
+- **`s`/`stop`** — Complete them first (/start-specification)
+· · · · · · · · · · · ·
+```
+
+**STOP.** Wait for user response.
+
+If the user chooses to stop, end here. If they choose to continue, proceed.
+
+### 6b: Summarize concluded cross-cutting specs
+
+If any **concluded** cross-cutting specifications exist, identify which are relevant to the feature being planned and summarize for handoff:
+
+> *Output the next fenced block as a code block:*
+
+```
+Cross-cutting specifications to reference:
+- caching-strategy.md: [brief summary of key decisions]
+```
+
+These specifications contain validated architectural decisions that should inform the plan. The planning skill will incorporate these as a "Cross-Cutting References" section in the plan.

package/skills/start-planning/references/display-state.md

@@ -0,0 +1,109 @@
+# Display State and Options
+
+*Reference for **[start-planning](../SKILL.md)***
+
+---
+
+Present everything discovered to help the user make an informed choice.
+
+**Present the full state:**
+
+> *Output the next fenced block as a code block:*
+
+```
+Planning Overview
+
+{N} specifications found. {M} plans exist.
+
+1. {topic:(titlecase)}
+   └─ Plan: @if(has_plan) {plan_status:[in-progress|concluded]} @else (no plan) @endif
+   └─ Spec: concluded
+
+2. ...
+```
+
+**Tree rules:**
+
+Each numbered item shows a feature specification that is actionable:
+- Concluded spec with no plan → `Plan: (no plan)`
+- Has a plan with `plan_status: planning` → `Plan: in-progress`
+- Has a plan with `plan_status: concluded` → `Plan: concluded`
+
+**If non-plannable specifications exist**, show them in a separate code block:
+
+> *Output the next fenced block as a code block:*
+
+```
+Specifications not ready for planning:
+These specifications are either still in progress or cross-cutting
+and cannot be planned directly.
+
+  • {topic} ({type:[feature|cross-cutting]}, {status:[in-progress|concluded]})
+```
+
+**Key/Legend** — show only statuses that appear in the current display. No `---` separator before this section.
+
+> *Output the next fenced block as a code block:*
+
+```
+Key:
+
+  Plan status:
+    in-progress — planning work is ongoing
+    concluded   — plan is complete
+
+  Spec type:
+    cross-cutting — architectural policy, not directly plannable
+    feature       — plannable feature specification
+```
+
+Omit any section entirely if it has no entries.
+
+**Then prompt based on what's actionable:**
+
+**If multiple actionable items:**
+
+The verb in the menu depends on the plan state:
+- No plan exists → **Create**
+- Plan is `in-progress` → **Continue**
+- Plan is `concluded` → **Review**
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+1. Create "Auth Flow" — concluded spec, no plan
+2. Continue "Data Model" — plan in-progress
+3. Review "Billing" — plan concluded
+
+Select an option (enter number):
+· · · · · · · · · · · ·
+```
+
+Recreate with actual topics and states from discovery.
+
+**STOP.** Wait for user response.
+
+**If single actionable item (auto-select):**
+
+> *Output the next fenced block as a code block:*
+
+```
+Automatically proceeding with "{topic:(titlecase)}".
+```
+
+**If nothing actionable:**
+
+> *Output the next fenced block as a code block:*
+
+```
+Planning Overview
+
+No plannable specifications found.
+
+The planning phase requires a concluded feature specification.
+Complete any in-progress specifications with /start-specification,
+or create a new specification first.
+```
+
+**STOP.** Do not proceed — terminal condition.

package/skills/start-planning/references/invoke-skill.md

@@ -0,0 +1,29 @@
+# Invoke the Skill
+
+*Reference for **[start-planning](../SKILL.md)***
+
+---
+
+After completing the steps above, this skill's purpose is fulfilled.
+
+Invoke the [technical-planning](../../technical-planning/SKILL.md) skill for your next instructions. Do not act on the gathered information until the skill is loaded - it contains the instructions for how to proceed.
+
+**Example handoff (fresh plan):**
+```
+Planning session for: {topic}
+Specification: docs/workflow/specification/{topic}.md
+Additional context: {summary of user's answers from Step 5}
+Cross-cutting references: {list of applicable cross-cutting specs with brief summaries, or "none"}
+Recommended output format: {common_format from discovery if non-empty, otherwise "none"}
+
+Invoke the technical-planning skill.
+```
+
+**Example handoff (continue/review existing plan):**
+```
+Planning session for: {topic}
+Specification: docs/workflow/specification/{topic}.md
+Existing plan: docs/workflow/planning/{topic}.md
+
+Invoke the technical-planning skill.
+```

package/skills/status/SKILL.md

@@ -2,6 +2,7 @@
 name: status
 description: "Show workflow status - what exists, where you are, and what to do next."
 disable-model-invocation: true
+allowed-tools: Bash(.claude/skills/status/scripts/discovery.sh)
 ---
 
 Show the current state of the workflow for this project.
@@ -12,81 +13,194 @@ Show the current state of the workflow for this project.
 
 Invoke the `/migrate` skill and assess its output.
 
-**If files were updated**: STOP and wait for the user to review the changes (e.g., via `git diff`) and confirm before proceeding to Step 1. Do not continue automatically.
+**If files were updated**: STOP and wait for the user to review the changes (e.g., via `git diff`) and confirm before proceeding to Step 1.
 
 **If no updates needed**: Proceed to Step 1.
 
 ---
 
-## Step 1: Scan Directories
+## Step 1: Discovery State
 
-Check for files in each workflow directory:
+!`.claude/skills/status/scripts/discovery.sh`
 
+If the above shows a script invocation rather than YAML output, the dynamic content preprocessor did not run. Execute the script before continuing:
+
+```bash
+.claude/skills/status/scripts/discovery.sh
 ```
-docs/workflow/research/
-docs/workflow/discussion/
-docs/workflow/specification/
-docs/workflow/planning/
-docs/workflow/implementation/
-```
 
-For implementation, check `docs/workflow/implementation/{topic}/tracking.md` files and extract frontmatter fields: `status`, `current_phase`, `current_task`, `completed_tasks`, `completed_phases`.
+If YAML content is already displayed, it has been run on your behalf.
+
+Parse the discovery output. **IMPORTANT**: Use ONLY this script for discovery. Do NOT run additional bash commands (ls, head, cat, etc.) to gather state.
+
+→ Proceed to **Step 2**.
+
+---
 
 ## Step 2: Present Status
 
-Research is project-wide exploration. From discussion onwards, work is organised by **topic** - different topics may be at different stages.
+Build the display from discovery data. Only show sections for phases that have content.
+
+**CRITICAL**: Entities don't flow one-to-one across phases. Multiple discussions may combine into one specification, topic names may change between phases, and specs may be superseded. The display must make these relationships visible — primarily through the specification's `sources` array.
 
-> *Output the next fenced block as markdown (not a code block):*
+### 2a: Summary
+
+> *Output the next fenced block as a code block:*
 
 ```
-**Workflow Overview**
+Workflow Status
 
-**Research:** {count} files ({filenames})
+  Research:       {count} file(s)
+  Discussion:     {count} ({concluded} concluded, {in_progress} in-progress)
+  Specification:  {active} active ({feature} feature, {crosscutting} cross-cutting)
+  Planning:       {count} ({concluded} concluded, {in_progress} in-progress)
+  Implementation: {count} ({completed} completed, {in_progress} in-progress)
+```
+
+Only show lines for phases that have content. If a phase has zero items but a later phase has content, show the line as `(none)` to highlight the gap.
+
+#### If no workflow content exists at all
+
+> *Output the next fenced block as a code block:*
 
-| Topic | Discussion | Spec | Plan | Implemented |
-|-------|------------|------|------|-------------|
-| {topic} | {discussion_status} | {spec_status} | {plan_status} | {impl_status} |
-| ... | | | | |
 ```
+Workflow Status
 
-Adapt based on what exists:
-- If a directory is empty or missing, show `-`
-- For planning, note the output format if specified in frontmatter
-- Match topics across phases by filename
-- For implementation, derive the Implemented column from tracking file data:
-  - No tracking file → `-`
-  - `status: not-started` → `not started`
-  - `status: in-progress` → `phase {current_phase} ({n}/{total} tasks done)` — count `completed_tasks` for n; use total task count from `completed_tasks` + remaining if available, otherwise just show completed count
-  - `status: completed` → `completed`
+No workflow files found in docs/workflow/
 
-## Step 3: Suggest Next Steps
+Start with /start-research to explore ideas,
+or /start-discussion if you already know what to build.
+```
+
+**STOP.** Do not proceed — terminal condition.
 
-Based on what exists, offer relevant options. Don't assume linear progression - topics may have dependencies on each other.
+### 2b: Specifications
 
-**If nothing exists:**
-- "Start with `/start-research` to explore ideas, or `/start-discussion` if you already know what you're building."
+Show if any specifications exist. This is the most important section — it reveals many-to-one relationships between discussions and specifications.
 
-**If topics exist at various stages**, summarise options without being prescriptive:
-- Topics in discussion can move to specification
-- Topics with specs can move to planning
-- Topics with plans can move to implementation
-- Completed implementations can be reviewed
+> *Output the next fenced block as a code block:*
+
+```
+Specifications
 
-Example: "auth-system has a plan ready. payment-flow needs a spec before planning. You might want to complete planning for related topics before implementing if there are dependencies."
+  1. {name:(titlecase)} ({status})
+     └─ Sources: @if(no_sources) (none) @else
+        ├─ {src} ({src_status})
+        └─ ...
+     @endif
+
+  2. ...
+```
 
-Keep suggestions brief - the user knows their project's dependencies better than we do.
+**Rules:**
+
+- Each numbered item is an active (non-superseded) specification
+- Show `(cross-cutting)` after status for cross-cutting specs; omit type label for feature specs
+- Blank line between numbered items
+- If superseded specs exist, show after the numbered list:
+
+```
+  Superseded:
+    • {name} → {superseded_by}
+```
 
-## Step 4: Mention Plan Viewing
+### 2c: Plans
 
-If planning files exist, let the user know they can view plan details:
+Show if any plans exist.
 
 > *Output the next fenced block as a code block:*
 
 ```
-To view a plan's tasks and progress, use /view-plan
+Plans
+
+  1. {name:(titlecase)} ({status})
+     └─ Spec: {specification_name}
+     @if(has_unresolved_deps) └─ Blocked:
+        ├─ {dep_topic}:{dep_task_id} ({dep_state})
+        └─ ...
+     @endif
+
+  2. ...
 ```
 
+**Rules:**
+
+- Map raw `planning` status to `in-progress` in the display
+- Show spec name without `.md` extension
+
+### 2d: Implementation
+
+Show if any implementations exist.
+
+> *Output the next fenced block as a code block:*
+
+```
+Implementation
+
+  1. {topic:(titlecase)} ({status})
+     └─ Phase {current_phase}, {completed_tasks}/{total_tasks} tasks done
+
+  2. ...
+```
+
+**Rules:**
+
+- `not-started` → `└─ Not started`
+- `in-progress` → phase and task progress; if `total_tasks` is 0, show `{completed_tasks} tasks done` without denominator
+- `completed` → `└─ Complete`
+
+### 2e: Unlinked Discussions
+
+Derive which discussions are NOT referenced in any active (non-superseded) specification's `sources` array. Show only if unlinked discussions exist.
+
+> *Output the next fenced block as a code block:*
+
+```
+Discussions not yet in a specification:
+
+  • {name} ({status})
+```
+
+### 2f: Key
+
+Show if the display uses statuses that benefit from explanation. Only include statuses actually shown. No `---` separator before this section.
+
+> *Output the next fenced block as a code block:*
+
+```
+Key:
+
+  Status:
+    in-progress — work is ongoing
+    concluded   — complete, ready for next step
+    superseded  — replaced by another specification
+
+  Spec type:
+    cross-cutting — architectural policy, not directly plannable
+```
+
+Omit categories with no entries.
+
+---
+
+## Step 3: Suggest Next Steps
+
+Based on gaps in the workflow, briefly suggest 2-3 most relevant actions:
+
+- Concluded discussions not in any spec → `/start-specification`
+- In-progress specs → finish with `/start-specification`
+- Concluded feature specs without plans → `/start-planning`
+- Concluded plans not yet implemented → `/start-implementation`
+- Completed implementations → `/start-review`
+
+If plans exist, mention `/view-plan` for detailed plan viewing.
+
+Keep suggestions brief — the user knows their project better than we do.
+
 ## Notes
 
-- Keep output concise - this is a quick status check
-- Use tables for scannable information
+- Keep output scannable — this is a status check, not a deep analysis
+- Discussions may appear in multiple specifications' sources
+- A discussion not appearing in any active spec's sources is "unlinked"
+- Research files are project-wide, not topic-specific
+- Topic names may differ across phases (e.g., discussions "auth-flow" and "session-mgmt" may combine into specification "auth-system")

package/skills/status/scripts/discovery.sh

@@ -0,0 +1,420 @@
+#!/bin/bash
+#
+# Discovers the full workflow state across all phases
+# for the /status command.
+#
+# Outputs structured YAML that the command can consume directly.
+#
+
+set -eo pipefail
+
+RESEARCH_DIR="docs/workflow/research"
+DISCUSSION_DIR="docs/workflow/discussion"
+SPEC_DIR="docs/workflow/specification"
+PLAN_DIR="docs/workflow/planning"
+IMPL_DIR="docs/workflow/implementation"
+
+# Helper: Extract a frontmatter field value from a file
+# Usage: extract_field <file> <field_name>
+extract_field() {
+    local file="$1"
+    local field="$2"
+    local value=""
+
+    if head -1 "$file" 2>/dev/null | grep -q "^---$"; then
+        value=$(sed -n '2,/^---$/p' "$file" 2>/dev/null | \
+            grep -i -m1 "^${field}:" | \
+            sed -E "s/^${field}:[[:space:]]*//i" || true)
+    fi
+
+    echo "$value"
+}
+
+# Helper: Extract frontmatter content (between first pair of --- delimiters)
+extract_frontmatter() {
+    local file="$1"
+    awk 'BEGIN{c=0} /^---$/{c++; if(c==2) exit; next} c==1{print}' "$file" 2>/dev/null
+}
+
+# Helper: Extract sources from specification frontmatter
+# Outputs: name|status per line (object format only; legacy converted by migration 004)
+extract_sources() {
+    local file="$1"
+    local in_sources=false
+    local current_name=""
+    local current_status=""
+
+    while IFS= read -r line; do
+        if [[ "$line" =~ ^sources: ]]; then
+            in_sources=true
+            continue
+        fi
+
+        if $in_sources && [[ "$line" =~ ^[a-z_]+: ]] && [[ ! "$line" =~ ^[[:space:]] ]]; then
+            if [ -n "$current_name" ]; then
+                echo "${current_name}|${current_status:-incorporated}"
+            fi
+            break
+        fi
+
+        if $in_sources; then
+            if [[ "$line" =~ ^[[:space:]]*-[[:space:]]*name:[[:space:]]*(.+)$ ]]; then
+                if [ -n "$current_name" ]; then
+                    echo "${current_name}|${current_status:-incorporated}"
+                fi
+                current_name="${BASH_REMATCH[1]}"
+                current_name=$(echo "$current_name" | sed 's/^"//' | sed 's/"$//' | xargs)
+                current_status=""
+            elif [[ "$line" =~ ^[[:space:]]*status:[[:space:]]*(.+)$ ]]; then
+                current_status="${BASH_REMATCH[1]}"
+                current_status=$(echo "$current_status" | sed 's/^"//' | sed 's/"$//' | xargs)
+            fi
+        fi
+    done < <(extract_frontmatter "$file")
+
+    if [ -n "$current_name" ]; then
+        echo "${current_name}|${current_status:-incorporated}"
+    fi
+}
+
+# Helper: Extract external_dependencies from plan frontmatter
+# Outputs: topic|state|task_id per line
+extract_external_deps() {
+    local file="$1"
+    local frontmatter
+    frontmatter=$(extract_frontmatter "$file")
+
+    if ! echo "$frontmatter" | grep -q "^external_dependencies:" 2>/dev/null; then
+        return 0
+    fi
+
+    if echo "$frontmatter" | grep -q "^external_dependencies:[[:space:]]*\[\]" 2>/dev/null; then
+        return 0
+    fi
+
+    echo "$frontmatter" | awk '
+/^external_dependencies:/ { in_block=1; next }
+in_block && /^[a-z_]+:/ && !/^[[:space:]]/ { exit }
+in_block && /^[[:space:]]*- topic:/ {
+    if (topic != "") print topic "|" state "|" task_id
+    line=$0; gsub(/^[[:space:]]*- topic:[[:space:]]*/, "", line)
+    topic=line; state=""; task_id=""
+    next
+}
+in_block && /^[[:space:]]*state:/ {
+    line=$0; gsub(/^[[:space:]]*state:[[:space:]]*/, "", line)
+    state=line; next
+}
+in_block && /^[[:space:]]*task_id:/ {
+    line=$0; gsub(/^[[:space:]]*task_id:[[:space:]]*/, "", line)
+    task_id=line; next
+}
+END { if (topic != "") print topic "|" state "|" task_id }
+'
+}
+
+# Helper: Count completed tasks from implementation tracking
+count_completed_tasks() {
+    local file="$1"
+    local frontmatter
+    frontmatter=$(extract_frontmatter "$file")
+
+    if echo "$frontmatter" | grep -q "^completed_tasks:[[:space:]]*\[\]" 2>/dev/null; then
+        echo 0
+        return
+    fi
+
+    local count
+    count=$(echo "$frontmatter" | awk '
+/^completed_tasks:/ { in_block=1; next }
+in_block && /^[a-z_]+:/ { exit }
+in_block && /^[[:space:]]*-[[:space:]]/ { c++ }
+END { print c+0 }
+')
+    echo "$count"
+}
+
+# Helper: Count completed phases from implementation tracking
+count_completed_phases() {
+    local file="$1"
+    local frontmatter
+    frontmatter=$(extract_frontmatter "$file")
+
+    # Handle inline array format: [1, 2, 3]
+    local inline
+    inline=$(echo "$frontmatter" | grep "^completed_phases:" | sed 's/^completed_phases:[[:space:]]*//' || true)
+    if echo "$inline" | grep -q '^\['; then
+        local items
+        items=$(echo "$inline" | tr -d '[]' | tr ',' '\n' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | grep -v '^$')
+        if [ -n "$items" ]; then
+            echo "$items" | wc -l | tr -d ' '
+        else
+            echo 0
+        fi
+        return
+    fi
+
+    if echo "$frontmatter" | grep -q "^completed_phases:[[:space:]]*\[\]" 2>/dev/null; then
+        echo 0
+        return
+    fi
+
+    local count
+    count=$(echo "$frontmatter" | awk '
+/^completed_phases:/ { in_block=1; next }
+in_block && /^[a-z_]+:/ { exit }
+in_block && /^[[:space:]]*-[[:space:]]/ { c++ }
+END { print c+0 }
+')
+    echo "$count"
+}
+
+
+# Start YAML output
+echo "# Workflow Status Discovery"
+echo "# Generated: $(date -Iseconds)"
+echo ""
+
+#
+# RESEARCH
+#
+echo "research:"
+
+research_count=0
+if [ -d "$RESEARCH_DIR" ] && [ -n "$(ls -A "$RESEARCH_DIR" 2>/dev/null)" ]; then
+    echo "  exists: true"
+    echo "  files:"
+    for file in "$RESEARCH_DIR"/*; do
+        [ -f "$file" ] || continue
+        name=$(basename "$file" .md)
+        echo "    - \"$name\""
+        research_count=$((research_count + 1))
+    done
+    echo "  count: $research_count"
+else
+    echo "  exists: false"
+    echo "  files: []"
+    echo "  count: 0"
+fi
+
+echo ""
+
+#
+# DISCUSSIONS
+#
+echo "discussions:"
+
+disc_count=0
+disc_concluded=0
+disc_in_progress=0
+
+if [ -d "$DISCUSSION_DIR" ] && [ -n "$(ls -A "$DISCUSSION_DIR" 2>/dev/null)" ]; then
+    echo "  exists: true"
+    echo "  files:"
+    for file in "$DISCUSSION_DIR"/*.md; do
+        [ -f "$file" ] || continue
+        name=$(basename "$file" .md)
+        status=$(extract_field "$file" "status")
+        status=${status:-"unknown"}
+
+        echo "    - name: \"$name\""
+        echo "      status: \"$status\""
+
+        disc_count=$((disc_count + 1))
+        [ "$status" = "concluded" ] && disc_concluded=$((disc_concluded + 1))
+        [ "$status" = "in-progress" ] && disc_in_progress=$((disc_in_progress + 1))
+    done
+    echo "  count: $disc_count"
+    echo "  concluded: $disc_concluded"
+    echo "  in_progress: $disc_in_progress"
+else
+    echo "  exists: false"
+    echo "  files: []"
+    echo "  count: 0"
+    echo "  concluded: 0"
+    echo "  in_progress: 0"
+fi
+
+echo ""
+
+#
+# SPECIFICATIONS
+#
+echo "specifications:"
+
+spec_count=0
+spec_active=0
+spec_superseded=0
+spec_feature=0
+spec_crosscutting=0
+
+if [ -d "$SPEC_DIR" ] && [ -n "$(ls -A "$SPEC_DIR" 2>/dev/null)" ]; then
+    echo "  exists: true"
+    echo "  files:"
+    for file in "$SPEC_DIR"/*.md; do
+        [ -f "$file" ] || continue
+        name=$(basename "$file" .md)
+        status=$(extract_field "$file" "status")
+        status=${status:-"in-progress"}
+        spec_type=$(extract_field "$file" "type")
+        spec_type=${spec_type:-"feature"}
+        superseded_by=$(extract_field "$file" "superseded_by")
+
+        echo "    - name: \"$name\""
+        echo "      status: \"$status\""
+        echo "      type: \"$spec_type\""
+        [ -n "$superseded_by" ] && echo "      superseded_by: \"$superseded_by\""
+
+        # Sources
+        sources_output=$(extract_sources "$file")
+        if [ -n "$sources_output" ]; then
+            echo "      sources:"
+            while IFS='|' read -r src_name src_status; do
+                [ -z "$src_name" ] && continue
+                echo "        - name: \"$src_name\""
+                echo "          status: \"$src_status\""
+            done <<< "$sources_output"
+        else
+            echo "      sources: []"
+        fi
+
+        spec_count=$((spec_count + 1))
+        if [ "$status" = "superseded" ]; then
+            spec_superseded=$((spec_superseded + 1))
+        else
+            spec_active=$((spec_active + 1))
+            [ "$spec_type" = "cross-cutting" ] && spec_crosscutting=$((spec_crosscutting + 1))
+            [ "$spec_type" != "cross-cutting" ] && spec_feature=$((spec_feature + 1))
+        fi
+    done
+    echo "  count: $spec_count"
+    echo "  active: $spec_active"
+    echo "  superseded: $spec_superseded"
+    echo "  feature: $spec_feature"
+    echo "  crosscutting: $spec_crosscutting"
+else
+    echo "  exists: false"
+    echo "  files: []"
+    echo "  count: 0"
+    echo "  active: 0"
+    echo "  superseded: 0"
+    echo "  feature: 0"
+    echo "  crosscutting: 0"
+fi
+
+echo ""
+
+#
+# PLANS
+#
+echo "plans:"
+
+plan_count=0
+plan_concluded=0
+plan_in_progress=0
+
+if [ -d "$PLAN_DIR" ] && [ -n "$(ls -A "$PLAN_DIR" 2>/dev/null)" ]; then
+    echo "  exists: true"
+    echo "  files:"
+    for file in "$PLAN_DIR"/*.md; do
+        [ -f "$file" ] || continue
+        name=$(basename "$file" .md)
+        status=$(extract_field "$file" "status")
+        status=${status:-"unknown"}
+        format=$(extract_field "$file" "format")
+        format=${format:-"unknown"}
+        specification=$(extract_field "$file" "specification")
+        specification=${specification:-"${name}.md"}
+
+        echo "    - name: \"$name\""
+        echo "      status: \"$status\""
+        echo "      format: \"$format\""
+        echo "      specification: \"$specification\""
+
+        # External dependencies
+        deps_output=$(extract_external_deps "$file")
+        has_unresolved="false"
+        if [ -n "$deps_output" ]; then
+            echo "      external_deps:"
+            while IFS='|' read -r dep_topic dep_state dep_task_id; do
+                [ -z "$dep_topic" ] && continue
+                echo "        - topic: \"$dep_topic\""
+                echo "          state: \"$dep_state\""
+                [ -n "$dep_task_id" ] && echo "          task_id: \"$dep_task_id\""
+                [ "$dep_state" = "unresolved" ] && has_unresolved="true"
+            done <<< "$deps_output"
+        else
+            echo "      external_deps: []"
+        fi
+        echo "      has_unresolved_deps: $has_unresolved"
+
+        plan_count=$((plan_count + 1))
+        [ "$status" = "concluded" ] && plan_concluded=$((plan_concluded + 1))
+        { [ "$status" = "planning" ] || [ "$status" = "in-progress" ]; } && plan_in_progress=$((plan_in_progress + 1))
+    done
+    echo "  count: $plan_count"
+    echo "  concluded: $plan_concluded"
+    echo "  in_progress: $plan_in_progress"
+else
+    echo "  exists: false"
+    echo "  files: []"
+    echo "  count: 0"
+    echo "  concluded: 0"
+    echo "  in_progress: 0"
+fi
+
+echo ""
+
+#
+# IMPLEMENTATION
+#
+echo "implementation:"
+
+impl_count=0
+impl_completed=0
+impl_in_progress=0
+
+if [ -d "$IMPL_DIR" ] && [ -n "$(ls -A "$IMPL_DIR" 2>/dev/null)" ]; then
+    echo "  exists: true"
+    echo "  files:"
+    for file in "$IMPL_DIR"/*/tracking.md; do
+        [ -f "$file" ] || continue
+        topic=$(basename "$(dirname "$file")")
+        status=$(extract_field "$file" "status")
+        status=${status:-"unknown"}
+        current_phase=$(extract_field "$file" "current_phase")
+
+        completed_tasks=$(count_completed_tasks "$file")
+        completed_phases=$(count_completed_phases "$file")
+
+        # Count total tasks from plan directory (local-markdown format)
+        total_tasks=0
+        plan_file="$PLAN_DIR/${topic}.md"
+        if [ -f "$plan_file" ]; then
+            plan_format=$(extract_field "$plan_file" "format")
+            if [ "$plan_format" = "local-markdown" ] && [ -d "$PLAN_DIR/${topic}" ]; then
+                total_tasks=$(ls -1 "$PLAN_DIR/${topic}/"*.md 2>/dev/null | wc -l | tr -d ' ')
+            fi
+        fi
+
+        echo "    - topic: \"$topic\""
+        echo "      status: \"$status\""
+        [ -n "$current_phase" ] && [ "$current_phase" != "~" ] && echo "      current_phase: $current_phase"
+        echo "      completed_tasks: $completed_tasks"
+        echo "      completed_phases: $completed_phases"
+        echo "      total_tasks: $total_tasks"
+
+        impl_count=$((impl_count + 1))
+        [ "$status" = "completed" ] && impl_completed=$((impl_completed + 1))
+        [ "$status" = "in-progress" ] && impl_in_progress=$((impl_in_progress + 1))
+    done
+    echo "  count: $impl_count"
+    echo "  completed: $impl_completed"
+    echo "  in_progress: $impl_in_progress"
+else
+    echo "  exists: false"
+    echo "  files: []"
+    echo "  count: 0"
+    echo "  completed: 0"
+    echo "  in_progress: 0"
+fi