@leeovery/claude-technical-workflows 2.1.31 → 2.1.33

package/skills/continue-feature/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: continue-feature
+description: "Continue a feature through the pipeline. Routes to the next phase (specification, planning, or implementation) based on artifact state. Can be invoked manually or from plan mode bridges."
+allowed-tools: Bash(.claude/skills/continue-feature/scripts/discovery.sh), Bash(.claude/hooks/workflows/write-session-state.sh)
+hooks:
+  PreToolUse:
+    - hooks:
+        - type: command
+          command: "$CLAUDE_PROJECT_DIR/.claude/hooks/workflows/system-check.sh"
+          once: true
+---
+
+Route a feature to its next pipeline phase.
+
+> **⚠️ ZERO OUTPUT RULE**: Do not narrate your processing. Produce no output until a step or reference file explicitly specifies display content. No "proceeding with...", no discovery summaries, no routing decisions, no transition text. Your first output must be content explicitly called for by the instructions.
+
+## Instructions
+
+Follow these steps EXACTLY as written. Do not skip steps or combine them.
+
+**CRITICAL**: This guidance is mandatory.
+
+- After each user interaction, STOP and wait for their response before proceeding
+- Never assume or anticipate user choices
+- Complete each step fully before moving to the next
+
+---
+
+## Resuming After Context Refresh
+
+Context refresh (compaction) summarizes the conversation, losing procedural detail. When you detect a context refresh has occurred — the conversation feels abruptly shorter, you lack memory of recent steps, or a summary precedes this message — follow this recovery protocol:
+
+1. **Re-read this skill file completely.** Do not rely on your summary of it. The full process, steps, and rules must be reloaded.
+2. **Identify the topic.** Check conversation history for the topic name. If unknown, ask the user.
+3. **Determine current step from artifacts** (check top-down, first match wins):
+   - Implementation tracking exists with `status: completed` → resume at **Step 6** (phase bridge — feature is done)
+   - Implementation tracking exists with `status: in-progress` → resume at **Step 5** (re-invoke begin-implementation)
+   - Plan exists with `status: concluded` → resume at **Step 5** (invoke begin-implementation)
+   - Plan exists with other status → resume at **Step 4** (re-invoke begin-planning)
+   - Specification exists with `status: concluded` → resume at **Step 4** (invoke begin-planning)
+   - Specification exists with other status → resume at **Step 3** (re-invoke technical-specification)
+   - Discussion exists with `status: concluded` → resume at **Step 3** (invoke technical-specification)
+   - Discussion exists with other status → terminal — suggest `/start-discussion`
+4. **Announce your position** to the user before continuing: what step you believe you're at, what's been completed, and what comes next. Wait for confirmation.
+
+Do not guess at progress or continue from memory. The files on disk and git history are authoritative — your recollection is not.
+
+---
+
+## Step 0: Run Migrations
+
+**This step is mandatory. You must complete it before proceeding.**
+
+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 no updates needed**: Proceed to Step 1.
+
+---
+
+## Step 1: Determine Topic
+
+Check whether a topic was provided by the caller (e.g., from a plan mode bridge: "invoke continue-feature for {topic}").
+
+#### If topic was provided
+
+Use the provided topic directly.
+
+→ Proceed to **Step 2**.
+
+#### If no topic provided (bare invocation)
+
+Run the discovery script to gather current state:
+
+```bash
+.claude/skills/continue-feature/scripts/discovery.sh
+```
+
+Parse the output to understand:
+
+**From `topics` array:** Each topic's name, discussion/specification/plan/implementation state, next_phase, and actionable flag.
+
+**From `state` section:** topic_count, actionable_count, scenario.
+
+**IMPORTANT**: Use ONLY this script for discovery. Do NOT run additional bash commands (ls, head, cat, etc.) to gather state.
+
+#### If scenario is "no_topics"
+
+> *Output the next fenced block as a code block:*
+
+```
+Continue Feature
+
+No workflow topics found.
+
+Start a new feature with /start-feature.
+```
+
+**STOP.** Do not proceed — terminal condition.
+
+#### If topics exist
+
+Present the discovered state as context, then ask the user to select:
+
+> *Output the next fenced block as a code block:*
+
+```
+Continue Feature
+
+This skill continues a feature through the pipeline phases:
+Discussion → Specification → Planning → Implementation
+
+It's designed for features started with /start-feature, but works
+with any topic that has workflow artifacts.
+
+Topics found:
+
+1. {topic:(titlecase)}
+   └─ Next: {next_phase}
+
+2. ...
+```
+
+> *Output the next fenced block as markdown (not a code block):*
+
+```
+· · · · · · · · · · · ·
+Which topic would you like to continue?
+
+Select by number, or enter a topic name directly:
+· · · · · · · · · · · ·
+```
+
+**STOP.** Wait for user response.
+
+→ Proceed to **Step 2**.
+
+---
+
+## Step 2: Detect Phase and Route
+
+Load **[detect-phase.md](references/detect-phase.md)** and follow its instructions.
+
+→ The reference file will route you to **Step 3**, **Step 4**, **Step 5**, or a terminal condition. Follow its routing.
+
+---
+
+## Step 3: Specification Phase
+
+Load **[invoke-specification.md](references/invoke-specification.md)** and follow its instructions.
+
+**CRITICAL**: When the specification concludes (status becomes "concluded"), you MUST proceed to **Step 6** below. Do not end the session — the feature pipeline continues to the phase bridge.
+
+---
+
+## Step 4: Planning Phase
+
+Load **[invoke-planning.md](references/invoke-planning.md)** and follow its instructions.
+
+**CRITICAL**: When the plan concludes (status becomes "concluded"), you MUST proceed to **Step 6** below. Do not end the session — the feature pipeline continues to the phase bridge.
+
+---
+
+## Step 5: Implementation Phase
+
+Load **[invoke-implementation.md](references/invoke-implementation.md)** and follow its instructions.
+
+**CRITICAL**: When implementation completes (tracking status becomes "completed"), you MUST proceed to **Step 6** below. Do not end the session — the feature pipeline continues to the phase bridge.
+
+---
+
+## Step 6: Phase Bridge
+
+Load **[phase-bridge.md](references/phase-bridge.md)** and follow its instructions.
+
+The bridge will enter plan mode with instructions to invoke continue-feature for the topic in the next session.

package/skills/continue-feature/references/detect-phase.md

@@ -0,0 +1,92 @@
+# Detect Phase
+
+*Reference for **[continue-feature](../SKILL.md)***
+
+---
+
+Determine the next phase for the selected topic using its artifact state.
+
+## Phase Detection
+
+Either use the `next_phase` from discovery output (if discovery was run), or compute it by checking artifacts directly:
+
+### If discovery was not run (topic provided by caller)
+
+Check artifacts in this order (first match wins):
+
+1. Read `docs/workflow/implementation/{topic}/tracking.md`
+   - If exists with `status: completed` → next_phase is **"done"**
+   - If exists with `status: in-progress` → next_phase is **"implementation"**
+
+2. Read `docs/workflow/planning/{topic}/plan.md`
+   - If exists with `status: concluded` → next_phase is **"implementation"**
+   - If exists with other status → next_phase is **"planning"**
+
+3. Read `docs/workflow/specification/{topic}/specification.md`
+   - If exists with `status: concluded` → next_phase is **"planning"**
+   - If exists with other status → next_phase is **"specification"**
+
+4. Check `docs/workflow/discussion/{topic}.md`
+   - If exists with `status: concluded` → next_phase is **"specification"**
+   - If exists with other status → next_phase is **"discussion"**
+
+5. If none found → next_phase is **"unknown"**
+
+## Routing
+
+#### If next_phase is "specification"
+
+→ Proceed to **Step 3**.
+
+#### If next_phase is "planning"
+
+→ Proceed to **Step 4**.
+
+#### If next_phase is "implementation"
+
+→ Proceed to **Step 5**.
+
+#### If next_phase is "done"
+
+> *Output the next fenced block as a code block:*
+
+```
+Feature Complete
+
+"{topic:(titlecase)}" has completed implementation.
+
+Run /start-review to validate the implementation against the
+specification and plan.
+```
+
+**STOP.** Do not proceed — terminal condition.
+
+#### If next_phase is "discussion"
+
+> *Output the next fenced block as a code block:*
+
+```
+Discussion In Progress
+
+"{topic:(titlecase)}" has a discussion that is not yet concluded.
+
+Resume the discussion with /start-discussion, or use /start-feature
+to start a new feature from scratch.
+```
+
+**STOP.** Do not proceed — terminal condition.
+
+#### If next_phase is "unknown"
+
+> *Output the next fenced block as a code block:*
+
+```
+No Artifacts Found
+
+No workflow artifacts found for "{topic}".
+
+Start a new feature with /start-feature or begin a discussion
+with /start-discussion.
+```
+
+**STOP.** Do not proceed — terminal condition.

package/skills/continue-feature/references/invoke-implementation.md

@@ -0,0 +1,43 @@
+# Invoke Implementation
+
+*Reference for **[continue-feature](../SKILL.md)***
+
+---
+
+Invoke the begin-implementation bridge skill for this topic.
+
+## Save Session State
+
+Before invoking the processing skill, save a session bookmark.
+
+> *Output the next fenced block as a code block:*
+
+```
+Saving session state so Claude can pick up where it left off and continue the feature pipeline if the conversation is compacted.
+```
+
+```bash
+.claude/hooks/workflows/write-session-state.sh \
+  "{topic}" \
+  "skills/technical-implementation/SKILL.md" \
+  "docs/workflow/implementation/{topic}/tracking.md" \
+  --pipeline "This session is part of the feature pipeline. After implementation completes, return to the continue-feature skill and execute Step 6 (Phase Bridge). Load: skills/continue-feature/references/phase-bridge.md"
+```
+
+## Handoff
+
+Invoke the [begin-implementation](../../begin-implementation/SKILL.md) skill:
+
+```
+Implementation pre-flight for: {topic}
+Plan: docs/workflow/planning/{topic}/plan.md
+
+PIPELINE CONTINUATION — When implementation completes (tracking status: completed),
+you MUST return to the continue-feature skill and execute Step 6 (Phase Bridge).
+Load: skills/continue-feature/references/phase-bridge.md
+Do not end the session after implementation — the feature pipeline continues.
+
+Invoke the begin-implementation skill.
+```
+
+The bridge skill handles dependency checking, environment setup, and the handoff to technical-implementation.

package/skills/continue-feature/references/invoke-planning.md

@@ -0,0 +1,43 @@
+# Invoke Planning
+
+*Reference for **[continue-feature](../SKILL.md)***
+
+---
+
+Invoke the begin-planning bridge skill for this topic.
+
+## Save Session State
+
+Before invoking the processing skill, save a session bookmark.
+
+> *Output the next fenced block as a code block:*
+
+```
+Saving session state so Claude can pick up where it left off and continue the feature pipeline if the conversation is compacted.
+```
+
+```bash
+.claude/hooks/workflows/write-session-state.sh \
+  "{topic}" \
+  "skills/technical-planning/SKILL.md" \
+  "docs/workflow/planning/{topic}/plan.md" \
+  --pipeline "This session is part of the feature pipeline. After the plan concludes, return to the continue-feature skill and execute Step 6 (Phase Bridge). Load: skills/continue-feature/references/phase-bridge.md"
+```
+
+## Handoff
+
+Invoke the [begin-planning](../../begin-planning/SKILL.md) skill:
+
+```
+Planning pre-flight for: {topic}
+Specification: docs/workflow/specification/{topic}/specification.md
+
+PIPELINE CONTINUATION — When planning concludes (plan status: concluded),
+you MUST return to the continue-feature skill and execute Step 6 (Phase Bridge).
+Load: skills/continue-feature/references/phase-bridge.md
+Do not end the session after planning — the feature pipeline continues.
+
+Invoke the begin-planning skill.
+```
+
+The bridge skill handles cross-cutting context, additional context gathering, and the handoff to technical-planning.

package/skills/continue-feature/references/invoke-specification.md

@@ -0,0 +1,55 @@
+# Invoke Specification
+
+*Reference for **[continue-feature](../SKILL.md)***
+
+---
+
+Invoke the specification skill for this topic.
+
+## Check Source Material
+
+The specification needs source material. Check what's available:
+
+1. **Discussion document**: `docs/workflow/discussion/{topic}.md`
+   - If exists and concluded → use as primary source
+   - If exists and in-progress → this shouldn't happen (detect-phase would have routed to discussion)
+
+2. If no discussion exists, this is an error — the pipeline expects a concluded discussion before specification. Report it and stop.
+
+## Save Session State
+
+Before invoking the processing skill, save a session bookmark.
+
+> *Output the next fenced block as a code block:*
+
+```
+Saving session state so Claude can pick up where it left off and continue the feature pipeline if the conversation is compacted.
+```
+
+```bash
+.claude/hooks/workflows/write-session-state.sh \
+  "{topic}" \
+  "skills/technical-specification/SKILL.md" \
+  "docs/workflow/specification/{topic}/specification.md" \
+  --pipeline "This session is part of the feature pipeline. After the specification concludes, return to the continue-feature skill and execute Step 6 (Phase Bridge). Load: skills/continue-feature/references/phase-bridge.md"
+```
+
+## Handoff
+
+Invoke the [technical-specification](../../technical-specification/SKILL.md) skill:
+
+```
+Specification session for: {topic}
+
+Source material:
+- Discussion: docs/workflow/discussion/{topic}.md
+
+Topic name: {topic}
+
+PIPELINE CONTINUATION — When this specification concludes (status: concluded),
+you MUST return to the continue-feature skill and execute Step 6 (Phase Bridge).
+Load: skills/continue-feature/references/phase-bridge.md
+Do not end the session after the specification — the feature pipeline continues.
+
+Invoke the technical-specification skill.
+```

package/skills/continue-feature/references/phase-bridge.md

@@ -0,0 +1,58 @@
+# Phase Bridge
+
+*Reference for **[continue-feature](../SKILL.md)***
+
+---
+
+The phase bridge clears context between pipeline phases using plan mode. This is necessary because each phase can consume significant context, and starting fresh prevents degradation.
+
+## Determine Next Phase
+
+Check which step just completed to determine what continue-feature will route to next:
+
+- Just completed **specification** (Step 3) → next session routes to planning
+- Just completed **planning** (Step 4) → next session routes to implementation
+- Just completed **implementation** (Step 5) → feature is done
+
+#### If implementation just completed
+
+> *Output the next fenced block as a code block:*
+
+```
+Feature Complete
+
+"{topic:(titlecase)}" has completed all pipeline phases.
+
+Run /start-review to validate the implementation.
+```
+
+**STOP.** Do not proceed — terminal condition.
+
+## Enter Plan Mode
+
+Enter plan mode and write the following plan:
+
+```
+# Continue Feature: {topic}
+
+The previous phase for "{topic}" has concluded. The next session should
+continue the feature pipeline.
+
+## Instructions
+
+1. Invoke the `/continue-feature` skill for topic "{topic}"
+2. The skill will detect the current phase and route accordingly
+
+## Context
+
+- Topic: {topic}
+- Previous phase: {phase that just completed}
+- Expected next phase: {next phase based on routing above}
+
+## How to proceed
+
+Clear context and continue. Claude will invoke continue-feature
+with the topic above and route to the next phase automatically.
+```
+
+Exit plan mode. The user will approve and clear context, and the fresh session will pick up with continue-feature routing to the correct phase.

package/skills/continue-feature/scripts/discovery.sh

@@ -0,0 +1,216 @@
+#!/bin/bash
+#
+# Cross-phase discovery script for /continue-feature.
+#
+# Scans all workflow directories (discussion, specification, planning,
+# implementation) and builds a unified topic list with phase state
+# and next_phase computation.
+#
+# Outputs structured YAML that the command can consume directly.
+#
+
+set -eo pipefail
+
+DISC_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=""
+
+    # Extract from YAML frontmatter (file must start with ---)
+    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"
+}
+
+# Start YAML output
+echo "# Continue-Feature Cross-Phase Discovery"
+echo "# Generated: $(date -Iseconds)"
+echo ""
+
+#
+# Collect all unique topic names from discussion + specification
+#
+declare -a all_topics=()
+declare -A topic_seen=()
+
+# Scan discussions
+if [ -d "$DISC_DIR" ]; then
+    for file in "$DISC_DIR"/*.md; do
+        [ -f "$file" ] || continue
+        name=$(basename "$file" .md)
+        if [ -z "${topic_seen[$name]+x}" ]; then
+            all_topics+=("$name")
+            topic_seen[$name]=1
+        fi
+    done
+fi
+
+# Scan specifications
+if [ -d "$SPEC_DIR" ]; then
+    for dir in "$SPEC_DIR"/*/; do
+        [ -d "$dir" ] || continue
+        [ -f "${dir}specification.md" ] || continue
+        name=$(basename "$dir")
+        if [ -z "${topic_seen[$name]+x}" ]; then
+            all_topics+=("$name")
+            topic_seen[$name]=1
+        fi
+    done
+fi
+
+#
+# Build topic entries
+#
+echo "topics:"
+
+topic_count=0
+actionable_count=0
+
+if [ ${#all_topics[@]} -eq 0 ]; then
+    echo "  []"
+else
+    for topic in "${all_topics[@]}"; do
+        # Discussion state
+        disc_exists="false"
+        disc_status=""
+        disc_file="$DISC_DIR/${topic}.md"
+        if [ -f "$disc_file" ]; then
+            disc_exists="true"
+            disc_status=$(extract_field "$disc_file" "status")
+            disc_status=${disc_status:-"in-progress"}
+        fi
+
+        # Specification state
+        spec_exists="false"
+        spec_status=""
+        spec_type=""
+        spec_file="$SPEC_DIR/${topic}/specification.md"
+        if [ -f "$spec_file" ]; then
+            spec_exists="true"
+            spec_status=$(extract_field "$spec_file" "status")
+            spec_status=${spec_status:-"in-progress"}
+            spec_type=$(extract_field "$spec_file" "type")
+            spec_type=${spec_type:-"feature"}
+        fi
+
+        # Skip cross-cutting specs — they aren't features
+        if [ "$spec_type" = "cross-cutting" ]; then
+            continue
+        fi
+
+        # Plan state
+        plan_exists="false"
+        plan_status=""
+        plan_format=""
+        plan_file="$PLAN_DIR/${topic}/plan.md"
+        if [ -f "$plan_file" ]; then
+            plan_exists="true"
+            plan_status=$(extract_field "$plan_file" "status")
+            plan_status=${plan_status:-"in-progress"}
+            plan_format=$(extract_field "$plan_file" "format")
+            plan_format=${plan_format:-"unknown"}
+        fi
+
+        # Implementation state
+        impl_exists="false"
+        impl_status=""
+        impl_file="$IMPL_DIR/${topic}/tracking.md"
+        if [ -f "$impl_file" ]; then
+            impl_exists="true"
+            impl_status=$(extract_field "$impl_file" "status")
+            impl_status=${impl_status:-"in-progress"}
+        fi
+
+        #
+        # Compute next_phase (check from top down, first match wins)
+        #
+        next_phase=""
+
+        if [ "$impl_exists" = "true" ] && [ "$impl_status" = "completed" ]; then
+            next_phase="done"
+        elif [ "$impl_exists" = "true" ] && [ "$impl_status" = "in-progress" ]; then
+            next_phase="implementation"
+        elif [ "$plan_exists" = "true" ] && [ "$plan_status" = "concluded" ]; then
+            next_phase="implementation"
+        elif [ "$plan_exists" = "true" ] && [ "$plan_status" != "concluded" ]; then
+            next_phase="planning"
+        elif [ "$spec_exists" = "true" ] && [ "$spec_status" = "concluded" ]; then
+            next_phase="planning"
+        elif [ "$spec_exists" = "true" ] && [ "$spec_status" != "concluded" ]; then
+            next_phase="specification"
+        elif [ "$disc_exists" = "true" ] && [ "$disc_status" = "concluded" ]; then
+            next_phase="specification"
+        elif [ "$disc_exists" = "true" ]; then
+            next_phase="discussion"
+        else
+            next_phase="unknown"
+        fi
+
+        # Actionable = can continue in the pipeline (not done, not unknown)
+        actionable="false"
+        if [ "$next_phase" != "done" ] && [ "$next_phase" != "unknown" ]; then
+            actionable="true"
+            actionable_count=$((actionable_count + 1))
+        fi
+
+        echo "  - name: \"$topic\""
+
+        echo "    discussion:"
+        echo "      exists: $disc_exists"
+        if [ "$disc_exists" = "true" ]; then
+            echo "      status: \"$disc_status\""
+        fi
+
+        echo "    specification:"
+        echo "      exists: $spec_exists"
+        if [ "$spec_exists" = "true" ]; then
+            echo "      status: \"$spec_status\""
+        fi
+
+        echo "    plan:"
+        echo "      exists: $plan_exists"
+        if [ "$plan_exists" = "true" ]; then
+            echo "      status: \"$plan_status\""
+            echo "      format: \"$plan_format\""
+        fi
+
+        echo "    implementation:"
+        echo "      exists: $impl_exists"
+        if [ "$impl_exists" = "true" ]; then
+            echo "      status: \"$impl_status\""
+        fi
+
+        echo "    next_phase: \"$next_phase\""
+        echo "    actionable: $actionable"
+
+        topic_count=$((topic_count + 1))
+    done
+fi
+
+echo ""
+
+#
+# STATE SUMMARY
+#
+echo "state:"
+echo "  topic_count: $topic_count"
+echo "  actionable_count: $actionable_count"
+
+if [ "$topic_count" -eq 0 ]; then
+    echo "  scenario: \"no_topics\""
+elif [ "$topic_count" -eq 1 ]; then
+    echo "  scenario: \"single_topic\""
+else
+    echo "  scenario: \"multiple_topics\""
+fi