maestro-flow 0.1.3 → 0.2.0

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

@@ -0,0 +1,160 @@
+---
+name: learn-retro-git
+description: Git activity retrospective with metrics, session detection, per-author breakdown, and trend tracking
+argument-hint: "[--days N] [--author <name>] [--area <path>] [--compare]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+<purpose>
+Git-activity retrospective that works on raw git history regardless of workflow phase state. Complements `quality-retrospective` (which requires completed phase artifacts) by analyzing commit metrics, detecting work sessions, computing test ratios, and tracking trends over time.
+
+Inspired by gstack `/retro`: per-author breakdown, session clustering, LOC metrics, file hotspot detection, and comparison against prior retrospectives.
+
+All insights are persisted to `.workflow/learning/lessons.jsonl` (source: "git-retro") so they're queryable via `manage-learn search/list`.
+</purpose>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Flags:**
+- `--days N` — Time window in days (default: 7)
+- `--author <name>` — Filter commits by author name (substring match)
+- `--area <path>` — Scope to files under a specific directory
+- `--compare` — Compare against the previous retro-git report if one exists
+
+**Storage written:**
+- `.workflow/learning/retro-git-{YYYY-MM-DD}.json` — Structured metrics (machine-readable)
+- `.workflow/learning/retro-git-{YYYY-MM-DD}.md` — Human-readable retrospective report
+- `.workflow/learning/lessons.jsonl` — Appended insights (source: "git-retro")
+- `.workflow/learning/learning-index.json` — Updated index
+
+**Storage read:**
+- `.workflow/state.json` — Current phase context (optional)
+- `.workflow/learning/retro-git-*.json` — Prior retro for trend comparison
+- `.workflow/learning/lessons.jsonl` — Existing insights for dedup
+</context>
+
+<execution>
+
+### Stage 1: Parse Arguments
+- Resolve date range: `--days N` or default 7. Compute absolute start date at midnight.
+- Extract `--author`, `--area`, `--compare` flags.
+- Check `.workflow/learning/` exists; bootstrap if missing.
+
+### Stage 2: Gather Raw Data (parallel git commands)
+Run ALL these git commands in parallel (they are independent):
+
+```bash
+# 1. Commit stats with author, timestamp, subject, files changed
+git log --since="<start-date>T00:00:00" --format="%H|%aN|%ae|%ai|%s" --shortstat
+
+# 2. Per-commit numstat for test vs production LOC split
+# Test files: match test/|spec/|__tests__/|*.test.*|*.spec.*
+git log --since="<start-date>T00:00:00" --format="COMMIT:%H|%aN" --numstat
+
+# 3. Timestamps for session detection (sorted)
+git log --since="<start-date>T00:00:00" --format="%at|%aN|%ai|%s" | sort -n
+
+# 4. File hotspots (most frequently changed files)
+git log --since="<start-date>T00:00:00" --format="" --name-only | grep -v '^$' | sort | uniq -c | sort -rn | head -20
+
+# 5. Per-author commit counts
+git shortlog --since="<start-date>T00:00:00" -sn --no-merges
+
+# 6. Per-author file hotspots
+git log --since="<start-date>T00:00:00" --format="AUTHOR:%aN" --name-only
+```
+
+Apply `--author` filter and `--area` path filter to all commands if provided.
+
+### Stage 3: Compute Metrics
+Calculate and build a metrics object:
+
+| Metric | Computation |
+|--------|-------------|
+| Commits | Count of non-merge commits |
+| Contributors | Unique author count |
+| Total insertions / deletions | Sum from shortstat |
+| Net LOC | insertions - deletions |
+| Test LOC (insertions) | Sum insertions for test files from numstat |
+| Test ratio | test_insertions / total_insertions × 100% |
+| Churn rate | Files changed >2 times / total unique files |
+| Active days | Distinct dates with commits |
+| Area concentration | Top directory % of total commits (Herfindahl) |
+
+### Stage 4: Detect Work Sessions
+Cluster commits by >2hr gaps in timestamps:
+- Group consecutive commits within 2-hour windows into sessions
+- Per session: start time, end time, duration, commit count, primary focus area (most-touched directory)
+- Compute: total sessions, avg session duration, avg LOC/session-hour
+
+### Stage 5: Per-Author Breakdown
+For each author:
+- Commit count, LOC added/removed, top 3 file areas
+- Test ratio (their test LOC / their total LOC)
+- Session count and patterns
+
+### Stage 6: Trend Comparison (if --compare or prior report exists)
+- Find most recent `.workflow/learning/retro-git-*.json`
+- If found, compute deltas: commits Δ, LOC Δ, test ratio Δ, churn rate Δ, session count Δ
+- Flag significant changes (>20% delta) as trend highlights
+
+### Stage 7: Distill Insights
+Identify actionable insights from metrics:
+- **High churn files** (changed >3 times): instability signal → suggest refactor or test coverage
+- **Low test ratio areas** (<20%): testing gap → suggest test generation
+- **Session patterns**: scattered sessions (many short) vs deep sessions (few long)
+- **Area drift**: if commits don't align with current roadmap phase
+
+Each insight: title, description, category (pattern/antipattern/technique), tags, confidence.
+
+### Stage 8: Persist & Report
+1. Write `.workflow/learning/retro-git-{date}.json` with full metrics structure
+2. Write `.workflow/learning/retro-git-{date}.md` with formatted report:
+   - Summary metrics table
+   - Per-author leaderboard
+   - Session timeline
+   - File hotspots
+   - Insights with recommendations
+   - Trend deltas (if comparing)
+3. Append each insight to `lessons.jsonl` with `source: "git-retro"`, `lens: null`, using stable INS-id from `hash(metric_name + date)`
+4. Update `learning-index.json`
+5. Display summary and next-step suggestions
+
+**Next-step routing:**
+- Browse insights → `Skill({ skill: "manage-learn", args: "list --tag git-retro" })`
+- Deep dive on high-churn file → `Skill({ skill: "learn-follow", args: "<path>" })`
+- Fix test gaps → `Skill({ skill: "quality-test-gen", args: "<area>" })`
+</execution>
+
+<error_codes>
+| Code | Severity | Condition | Recovery |
+|------|----------|-----------|----------|
+| E001 | error | Not inside a git repository | Navigate to a git repo directory |
+| E002 | error | No commits found in the specified time window | Increase --days or check --author/--area filters |
+| W001 | warning | `.workflow/learning/` not found, bootstrapping | Auto-created; proceed normally |
+| W002 | warning | No prior retro-git report for comparison | Skip trend section; first retro establishes baseline |
+| W003 | warning | Author filter matched 0 commits | Show available authors and re-prompt |
+</error_codes>
+
+<success_criteria>
+- [ ] Date range parsed correctly (absolute midnight-aligned start date)
+- [ ] All 6 git commands executed successfully
+- [ ] Metrics computed: commits, LOC, test ratio, churn rate, sessions, area concentration
+- [ ] Sessions detected with >2hr gap clustering
+- [ ] Per-author breakdown generated for all contributors
+- [ ] Trend comparison computed if prior report exists and --compare used
+- [ ] At least 1 actionable insight distilled from metrics
+- [ ] `retro-git-{date}.json` written with valid JSON
+- [ ] `retro-git-{date}.md` written and human-readable
+- [ ] `lessons.jsonl` appended with insights (source: "git-retro", stable INS-ids)
+- [ ] `learning-index.json` updated
+- [ ] No files modified outside `.workflow/learning/`
+- [ ] Summary displayed with next-step routing
+</success_criteria>

package/.claude/commands/learn-second-opinion.md

@@ -0,0 +1,167 @@
+---
+name: learn-second-opinion
+description: Multi-perspective analysis with review, challenge, and consult modes
+argument-hint: "<target> [--mode review|challenge|consult]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+<purpose>
+Structured second-opinion workflow for code, decisions, or plans. Three modes inspired by gstack `/codex`:
+
+- **review** (default): 3 parallel agents with distinct personas (pragmatist, purist, strategist) independently assess the target
+- **challenge**: single adversarial agent that tries to break the approach, find hidden assumptions, and propose alternatives
+- **consult**: interactive Q&A mode where the agent studies the target and answers your questions
+
+Decoupled from the phase/execution lifecycle — can be invoked on any piece of code or knowledge at any time. Findings persist to `lessons.jsonl`.
+</purpose>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Target resolution (auto-detected):**
+- File path → analyze that file's content
+- Wiki ID (`<type>-<slug>`) → fetch via `maestro wiki get`
+- `HEAD` or `staged` → analyze current git diff (`git diff HEAD` or `git diff --staged`)
+- Phase number (e.g., `3`) → analyze phase plan from `.workflow/phases/{NN}-*/plan.json`
+
+**Flags:**
+- `--mode review` — 3-persona parallel review (default)
+- `--mode challenge` — Adversarial single-agent analysis
+- `--mode consult` — Interactive Q&A session
+
+**Storage written:**
+- `.workflow/learning/opinion-{slug}-{YYYY-MM-DD}.md` — Opinion report
+- `.workflow/learning/lessons.jsonl` — New insights from analysis (source: "second-opinion")
+- `.workflow/learning/learning-index.json` — Updated index
+
+**Storage read:**
+- Target content (file, wiki entry, diff, or plan)
+- `.workflow/specs/` — Project conventions for context
+- `maestro wiki search` — Related knowledge entries
+- `.workflow/learning/lessons.jsonl` — Prior insights about the topic
+</context>
+
+<execution>
+
+### Stage 1: Resolve Target
+- File path: Read the file
+- Wiki ID: `maestro wiki get <id>`
+- `HEAD`: `git diff HEAD` (unstaged + staged changes)
+- `staged`: `git diff --staged`
+- Phase N: Read `.workflow/phases/{NN}-*/plan.json`
+- If unresolvable, AskUserQuestion for clarification
+
+### Stage 2: Load Context
+- Read relevant specs: `Skill({ skill: "spec-load" })` silently to get project conventions
+- Search wiki: `maestro wiki search "<target topic>"` for related entries (top 5)
+- Search lessons: grep `lessons.jsonl` for entries related to the target area
+- Build context brief: target content + conventions + related knowledge
+
+### Stage 3: Execute Mode
+
+#### Mode: review (default)
+Spawn 3 Agents in a single message with distinct personas:
+
+**Agent 1 — Pragmatist:**
+- Focus: simplicity, YAGNI, maintenance cost, readability
+- Question: "Is this the simplest thing that could work? What's the maintenance burden?"
+- Evaluates: complexity score, abstraction depth, dependency count
+
+**Agent 2 — Purist:**
+- Focus: correctness, type safety, edge cases, error handling
+- Question: "What assumptions can be violated? Where are the edge cases?"
+- Evaluates: error paths covered, type completeness, invariant preservation
+
+**Agent 3 — Strategist:**
+- Focus: scalability, extensibility, architecture alignment
+- Question: "Does this support future growth? Does it fit the overall architecture?"
+- Evaluates: coupling, cohesion, architecture constraint compliance
+
+Each agent returns:
+```json
+{
+  "persona": "pragmatist|purist|strategist",
+  "verdict": "approve|concern|reject",
+  "confidence": "high|medium|low",
+  "findings": [{ "severity": "high|medium|low", "description": "...", "location": "file:line", "suggestion": "..." }],
+  "summary": "one paragraph assessment"
+}
+```
+
+#### Mode: challenge
+Spawn 1 Agent as an adversarial reviewer:
+
+- Try to find the weakest assumption in the approach
+- Propose a concrete scenario that breaks the current implementation
+- Identify the single biggest risk
+- Suggest an alternative approach and argue why it might be better
+- Apply forcing questions:
+  - "What assumption would invalidate this entire approach?"
+  - "What's the simplest thing that breaks this?"
+  - "If you had to rewrite this in 6 months, what would you regret?"
+  - "What's the implicit contract that isn't enforced?"
+
+#### Mode: consult
+Interactive loop:
+1. Agent studies the target content thoroughly
+2. Display: "Target loaded. What would you like to know?"
+3. AskUserQuestion for the first question
+4. Agent answers with code references and evidence
+5. Loop: AskUserQuestion for follow-up or "done" to exit
+6. On exit, compile all Q&A into the report
+
+### Stage 4: Synthesize
+Across all perspectives (or from single agent in challenge/consult):
+- **Points of agreement**: findings all personas share
+- **Points of disagreement**: where personas diverge (with reasoning)
+- **Verdict**: combined assessment with confidence level
+- **Top 3 recommendations**: prioritized by impact
+
+### Stage 5: Persist & Report
+1. Write `.workflow/learning/opinion-{slug}-{date}.md`:
+   - Target summary
+   - Per-persona findings (review) / adversarial analysis (challenge) / Q&A transcript (consult)
+   - Synthesis: agreements, disagreements, verdict
+   - Recommendations
+2. Append non-trivial findings to `lessons.jsonl`:
+   - `source: "second-opinion"`, `category: "pattern"` or `"antipattern"` or `"decision"`
+   - Tags: `["second-opinion", "{mode}", "{target-slug}"]`
+3. Update `learning-index.json`
+4. Display summary with verdict and recommendations
+
+**Next-step routing:**
+- Create issue for a finding → `Skill({ skill: "manage-issue", args: "create <description>" })`
+- Decompose patterns found → `Skill({ skill: "learn-decompose", args: "<path>" })`
+- Follow-along on the code → `Skill({ skill: "learn-follow", args: "<path>" })`
+</execution>
+
+<error_codes>
+| Code | Severity | Condition | Recovery |
+|------|----------|-----------|----------|
+| E001 | error | Target not resolvable (file/wiki/diff/plan not found) | Verify target argument, provide correct path or ID |
+| E002 | error | Unknown --mode value | Use: review, challenge, or consult |
+| W001 | warning | One review agent failed — partial perspectives | Proceed with available agents, note incomplete coverage |
+| W002 | warning | No related wiki entries found for context | Proceed without wiki context |
+| W003 | warning | Git diff empty (no changes) for HEAD/staged target | Nothing to review; suggest using a file path instead |
+</error_codes>
+
+<success_criteria>
+- [ ] Target resolved and content loaded
+- [ ] Context gathered (specs, wiki, lessons)
+- [ ] Mode executed correctly:
+  - review: 3 agents spawned in parallel, all returned findings
+  - challenge: adversarial analysis completed with forcing questions
+  - consult: interactive Q&A loop completed
+- [ ] Synthesis produced with agreements, disagreements, verdict
+- [ ] Report written to `opinion-{slug}-{date}.md`
+- [ ] Non-trivial findings appended to `lessons.jsonl`
+- [ ] `learning-index.json` updated
+- [ ] No files modified outside `.workflow/learning/`
+- [ ] Summary displayed with verdict and next-step routing
+</success_criteria>

package/.claude/commands/maestro-analyze.md

@@ -1,99 +1,99 @@
----
-name: maestro-analyze
-description: Multi-dimensional analysis with CLI exploration, decision extraction, and intent tracking
-argument-hint: "<phase|topic> [-y] [-c] [-q]"
-allowed-tools:
-  - Read
-  - Write
-  - Edit
-  - Bash
-  - Glob
-  - Grep
-  - Agent
-  - AskUserQuestion
----
-<purpose>
-Perform multi-dimensional analysis of a technical proposal, decision, or architecture choice through iterative CLI-assisted exploration and interactive discussion. Produces a discussion timeline (discussion.md) with evolving understanding, multi-perspective findings, Decision Recording Protocol, Intent Coverage tracking, and a final conclusions package with Go/No-Go recommendation.
-
-Combines structured 6-dimension scoring with iterative deepening and decision extraction. Replaces both analysis and decision-capture workflows — produces analysis.md (scoring) AND context.md (Locked/Free/Deferred decisions for plan).
-
-Use `-q` for quick decision extraction only (skip exploration + scoring).
-</purpose>
-
-<required_reading>
-@~/.maestro/workflows/analyze.md
-</required_reading>
-
-<deferred_reading>
-- [scratch-index.json](~/.maestro/templates/scratch-index.json) — read when operating in scratch mode
-- [index.json](~/.maestro/templates/index.json) — read when operating in phase mode
-</deferred_reading>
-
-<context>
-$ARGUMENTS -- phase number for phase mode, topic text for scratch mode, with optional flags.
-
-**Flags:**
-- `-y` / `--yes`: Auto mode — skip interactive scoping, use recommended defaults, auto-deepen
-- `-c` / `--continue`: Resume from existing session (auto-detect session folder + discussion.md)
-- `-q` / `--quick`: Quick mode — skip exploration + scoring, go straight to decision extraction (context.md only)
-
-**Phase mode** (number): resolves phase directory from state.json + roadmap, updates index.json status to "exploring".
-**Scratch mode** (text): creates `.workflow/scratch/analyze-{slug}-{date}/` with index.json from scratch-index template (type="analyze").
-
-**Output artifacts:**
-| Artifact | Mode | Description |
-|----------|------|-------------|
-| `context.md` | both | Locked/Free/Deferred decisions for downstream plan |
-| `discussion.md` | full | Full discussion timeline with TOC, Current Understanding, rounds, decisions, intent coverage |
-| `analysis.md` | full | Executive summary with 6-dimension scores and risk matrix |
-| `conclusions.json` | full | Final synthesis with recommendations, decision trail, intent coverage |
-| `explorations.json` | full | Codebase exploration findings (single perspective) |
-| `perspectives.json` | full | Multi-perspective findings with synthesis (if multi-perspective) |
-</context>
-
-<execution>
-Follow '~/.maestro/workflows/analyze.md' completely.
-
-**Handoff:** context.md is consumed by maestro-plan (Step 4 loads Locked/Free/Deferred decisions).
-
-**Next-step routing on completion:**
-
-Phase mode:
-- Go recommendation, UI work needed → Skill({ skill: "maestro-ui-design", args: "{phase}" })
-- Go recommendation, ready to plan → Skill({ skill: "maestro-plan", args: "{phase}" })
-- No-Go recommendation → revisit requirements or Skill({ skill: "maestro-brainstorm", args: "{topic}" })
-
-Scratch mode:
-- Ready to plan → Skill({ skill: "maestro-plan", args: "--dir {scratch_dir}" })
-- Need more exploration → Skill({ skill: "maestro-analyze", args: "{topic} -c" })
-</execution>
-
-<error_codes>
-| Code | Severity | Condition | Recovery |
-|------|----------|-----------|----------|
-| E001 | error | Analysis subject required (no arguments provided) | Prompt user for phase number or topic text |
-| E002 | error | Phase directory not found | List available phases, prompt user to select |
-| W001 | warning | CLI exploration failed | Continue with available context, note limitation |
-| W002 | warning | CLI analysis timeout | Retry with shorter prompt, or skip perspective |
-| W003 | warning | Insufficient evidence for scoring dimensions | Note low-confidence dimensions, proceed with available evidence |
-| W004 | warning | Max rounds reached (5) | Force synthesis, offer continuation option |
-</error_codes>
-
-<success_criteria>
-Full mode:
-- [ ] CLI exploration completed with code anchors and call chains
-- [ ] discussion.md created with full timeline, TOC, Current Understanding
-- [ ] analysis.md written with all 6 dimensions scored with evidence
-- [ ] conclusions.json created with recommendations and decision trail
-- [ ] Intent Coverage tracked and verified (no unresolved ❌ items)
-
-Both modes (full + quick):
-- [ ] context.md written with all decisions classified as Locked/Free/Deferred
-- [ ] Gray areas identified through phase-specific analysis
-- [ ] Decision Recording Protocol applied to all decisions
-- [ ] Scope creep redirected to Deferred section
-- [ ] Deferred items auto-created as issues (if any)
-- [ ] project.md Key Decisions updated with Locked decisions (phase mode)
-- [ ] Next step routed (ui-design/plan for Go, brainstorm for No-Go)
-- [ ] index.json timestamps updated
-</success_criteria>
+---
+name: maestro-analyze
+description: Multi-dimensional analysis with CLI exploration, decision extraction, and intent tracking
+argument-hint: "<phase|topic> [-y] [-c] [-q]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+<purpose>
+Perform multi-dimensional analysis of a technical proposal, decision, or architecture choice through iterative CLI-assisted exploration and interactive discussion. Produces a discussion timeline (discussion.md) with evolving understanding, multi-perspective findings, Decision Recording Protocol, Intent Coverage tracking, and a final conclusions package with Go/No-Go recommendation.
+
+Combines structured 6-dimension scoring with iterative deepening and decision extraction. Replaces both analysis and decision-capture workflows — produces analysis.md (scoring) AND context.md (Locked/Free/Deferred decisions for plan).
+
+Use `-q` for quick decision extraction only (skip exploration + scoring).
+</purpose>
+
+<required_reading>
+@~/.maestro/workflows/analyze.md
+</required_reading>
+
+<deferred_reading>
+- [scratch-index.json](~/.maestro/templates/scratch-index.json) — read when operating in scratch mode
+- [index.json](~/.maestro/templates/index.json) — read when operating in phase mode
+</deferred_reading>
+
+<context>
+$ARGUMENTS -- phase number for phase mode, topic text for scratch mode, with optional flags.
+
+**Flags:**
+- `-y` / `--yes`: Auto mode — skip interactive scoping, use recommended defaults, auto-deepen
+- `-c` / `--continue`: Resume from existing session (auto-detect session folder + discussion.md)
+- `-q` / `--quick`: Quick mode — skip exploration + scoring, go straight to decision extraction (context.md only)
+
+**Phase mode** (number): resolves phase directory from state.json + roadmap, updates index.json status to "exploring".
+**Scratch mode** (text): creates `.workflow/scratch/analyze-{slug}-{date}/` with index.json from scratch-index template (type="analyze").
+
+**Output artifacts:**
+| Artifact | Mode | Description |
+|----------|------|-------------|
+| `context.md` | both | Locked/Free/Deferred decisions for downstream plan |
+| `discussion.md` | full | Full discussion timeline with TOC, Current Understanding, rounds, decisions, intent coverage |
+| `analysis.md` | full | Executive summary with 6-dimension scores and risk matrix |
+| `conclusions.json` | full | Final synthesis with recommendations, decision trail, intent coverage |
+| `explorations.json` | full | Codebase exploration findings (single perspective) |
+| `perspectives.json` | full | Multi-perspective findings with synthesis (if multi-perspective) |
+</context>
+
+<execution>
+Follow '~/.maestro/workflows/analyze.md' completely.
+
+**Handoff:** context.md is consumed by maestro-plan (Step 4 loads Locked/Free/Deferred decisions).
+
+**Next-step routing on completion:**
+
+Phase mode:
+- Go recommendation, UI work needed → Skill({ skill: "maestro-ui-design", args: "{phase}" })
+- Go recommendation, ready to plan → Skill({ skill: "maestro-plan", args: "{phase}" })
+- No-Go recommendation → revisit requirements or Skill({ skill: "maestro-brainstorm", args: "{topic}" })
+
+Scratch mode:
+- Ready to plan → Skill({ skill: "maestro-plan", args: "--dir {scratch_dir}" })
+- Need more exploration → Skill({ skill: "maestro-analyze", args: "{topic} -c" })
+</execution>
+
+<error_codes>
+| Code | Severity | Condition | Recovery |
+|------|----------|-----------|----------|
+| E001 | error | Analysis subject required (no arguments provided) | Prompt user for phase number or topic text |
+| E002 | error | Phase directory not found | List available phases, prompt user to select |
+| W001 | warning | CLI exploration failed | Continue with available context, note limitation |
+| W002 | warning | CLI analysis timeout | Retry with shorter prompt, or skip perspective |
+| W003 | warning | Insufficient evidence for scoring dimensions | Note low-confidence dimensions, proceed with available evidence |
+| W004 | warning | Max rounds reached (5) | Force synthesis, offer continuation option |
+</error_codes>
+
+<success_criteria>
+Full mode:
+- [ ] CLI exploration completed with code anchors and call chains
+- [ ] discussion.md created with full timeline, TOC, Current Understanding
+- [ ] analysis.md written with all 6 dimensions scored with evidence
+- [ ] conclusions.json created with recommendations and decision trail
+- [ ] Intent Coverage tracked and verified (no unresolved ❌ items)
+
+Both modes (full + quick):
+- [ ] context.md written with all decisions classified as Locked/Free/Deferred
+- [ ] Gray areas identified through phase-specific analysis
+- [ ] Decision Recording Protocol applied to all decisions
+- [ ] Scope creep redirected to Deferred section
+- [ ] Deferred items auto-created as issues (if any)
+- [ ] project.md Key Decisions updated with Locked decisions (phase mode)
+- [ ] Next step routed (ui-design/plan for Go, brainstorm for No-Go)
+- [ ] index.json timestamps updated
+</success_criteria>