bms-speckit-plugin 6.8.0 → 6.10.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bms-speckit",
-  "version": "6.8.0",
+  "version": "6.10.0",
   "description": "Chain-orchestrated development pipeline with 12-step autonomous workflow (brainstorm → research → constitution → specify → plan → tasks → analyze → implement with rolling QC → final quality gate → merge) and 9-dimension QC agent (code errors, security incl. SQL parameterization, deps, UX/UI, accessibility, deployment artifacts, cross-DB compatibility, real-DB integration testing, HOSxP business logic validation, brand/layout polish). Runs autonomously — never prompts for clarification.",
   "author": {
     "name": "manoirx"

package/blueprints/bms-speckit-pipeline.yaml

@@ -250,17 +250,7 @@ chain_sequence:
 
   # ── Phase 2: Implementation (main context) ────────────────────────────────
 
-  - step_id: step_9_compact
-    skill_id: internal.compact
-    action: execute
-    phase: 2
-    description: Free context window before implementation
-    timeout_seconds: 30
-    error_handling:
-      on_failure: continue
-      max_retries: 0
-
-  - step_id: step_10_implement_with_rolling_qc
+  - step_id: step_9_implement_with_rolling_qc
     skill_id: speckit.implement
     action: execute_loop
     phase: 2
@@ -320,7 +310,7 @@ chain_sequence:
         validation pass. Apply improvements, re-run all tests, confirm zero
         regression. Only output FINISHED after everything is validated.
 
-  - step_id: step_11_final_quality_gate
+  - step_id: step_10_final_quality_gate
     agent_id: bms-speckit:quality-control
     action: dispatch_agent
     phase: 2
@@ -355,7 +345,7 @@ chain_sequence:
         Proceed to merge unless unfixed build errors, test failures, or
         critical security vulnerabilities remain.
 
-  - step_id: step_12_merge
+  - step_id: step_11_merge
     skill_id: internal.git_merge_to_main
     action: execute
     phase: 2
@@ -396,6 +386,6 @@ metadata:
       reason: Preserve main context window for implementation
     phase_2:
       name: Implementation & Verification & Merge
-      steps: [step_9 through step_12]
+      steps: [step_9 through step_11]
       execution: main_context
       reason: Implementation needs full tool access and ralph-loop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bms-speckit-plugin",
-  "version": "6.8.0",
+  "version": "6.10.0",
   "description": "Chain-orchestrated development pipeline: /bms-speckit takes requirements and runs brainstorm → constitution → specify → plan → tasks → analyze → implement → verify with per-step error handling",
   "files": [
     ".claude-plugin/",

package/skills/bms-speckit-auto/SKILL.md

@@ -48,10 +48,9 @@ TaskCreate: "Step 5: Specify — feature specification"
 TaskCreate: "Step 6: Plan — implementation plan"
 TaskCreate: "Step 7: Tasks — task list"
 TaskCreate: "Step 8: Analyze — consistency check"
-TaskCreate: "Step 9: Compact context"
-TaskCreate: "Step 10: Implement with rolling QC"
-TaskCreate: "Step 11: Final quality gate"
-TaskCreate: "Step 12: Merge to main"
+TaskCreate: "Step 9: Implement with rolling QC"
+TaskCreate: "Step 10: Final quality gate"
+TaskCreate: "Step 11: Merge to main"
 ```
 
 Then output a message to the user:
@@ -74,14 +73,14 @@ You are running the BMS Speckit specification and planning chain. Execute each s
 
 **IMPORTANT — Progress reporting:** Before starting each step, output a progress message to the user in this format:
 
-`[Step N/12] step_name — description...`
+`[Step N/11] step_name — description...`
 
 After completing each step, output:
 
-`[Step N/12] DONE — brief result summary`
+`[Step N/11] DONE — brief result summary`
 
 ### Step 1 — Brainstorm `[on_failure: STOP]`
-- **Progress:** Output `[Step 1/12] Brainstorm — exploring requirements and design...`
+- **Progress:** Output `[Step 1/11] Brainstorm — exploring requirements and design...`
 - **Skill:** `superpowers.brainstorm`
 - **Input:** "$ARGUMENTS"
 - **Purpose:** Explore intent, requirements, design alternatives, and edge cases
@@ -89,10 +88,10 @@ After completing each step, output:
 - **Output:** Detailed specification document
 - **Timeout:** 300s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): brainstorm — explore requirements and design`
-- **Done:** Output `[Step 1/12] DONE — brainstorm complete`
+- **Done:** Output `[Step 1/11] DONE — brainstorm complete`
 
 ### Step 2 — Research `[on_failure: CONTINUE]`
-- **Progress:** Output `[Step 2/12] Research — surveying best practices and technologies...`
+- **Progress:** Output `[Step 2/11] Research — surveying best practices and technologies...`
 - **Purpose:** Research external best practices, proven patterns, recommended libraries/frameworks, and informative reference material relevant to the user's requirement. This grounds the pipeline in current industry knowledge before specification begins.
 - **Tools:** Use `WebSearch` and `mcp__plugin_context7_context7__resolve-library-id` + `mcp__plugin_context7_context7__query-docs` for library documentation
 - **Timeout:** 300s
@@ -111,25 +110,25 @@ After completing each step, output:
   - **Security/compliance notes** — standards to adhere to (if applicable)
   - **Prior art** — reference implementations or architectures found
 - **Post-action:** Commit all files and push. Message: `feat(speckit): research — best practices and technology survey`
-- **Done:** Output `[Step 2/12] DONE — research brief created (N topics researched)`
+- **Done:** Output `[Step 2/11] DONE — research brief created (N topics researched)`
 
 ### Step 3 — Constitution `[on_failure: STOP]`
-- **Progress:** Output `[Step 3/12] Constitution — establishing engineering principles...`
+- **Progress:** Output `[Step 3/11] Constitution — establishing engineering principles...`
 - **Skill:** `speckit.constitution`
 - **Input:** "Establish and enforce a comprehensive set of engineering principles that prioritize high code quality, strict adherence to Test-Driven Development (TDD) practices, and well-defined testing standards across unit, component, integration, and API levels to ensure system reliability and maintainability, maintain a consistent, user-friendly, and professional user interface aligned with strong user experience (UX) guidelines, optimize application performance through efficient architecture and resource management; enforce disciplined version control practices with frequent, atomic commits to minimize risk and improve traceability, promote the development and reuse of modular components and functions while centralizing business logic to avoid duplication and ensure consistency, provide clear, informative user feedback and progress reporting throughout system interactions, and leverage all available tools, frameworks, and domain-specific expertise to support developers in delivering robust, scalable, and high-quality applications."
 - **Output:** `specs/constitution.md`
 - **Timeout:** 300s
-- **Done:** Output `[Step 3/12] DONE — constitution created`
+- **Done:** Output `[Step 3/11] DONE — constitution created`
 
 ### Step 4 — CLAUDE.md Sync `[on_failure: CONTINUE]`
-- **Progress:** Output `[Step 4/12] CLAUDE.md Sync — verifying compliance...`
+- **Progress:** Output `[Step 4/11] CLAUDE.md Sync — verifying compliance...`
 - **Action:** Read CLAUDE.md and verify it complies with the constitution in `specs/constitution.md`. Update CLAUDE.md if it conflicts with or is missing constitution rules.
 - **Timeout:** 120s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add constitution and sync CLAUDE.md`
-- **Done:** Output `[Step 4/12] DONE — CLAUDE.md synced`
+- **Done:** Output `[Step 4/11] DONE — CLAUDE.md synced`
 
 ### Step 5 — Specify `[on_failure: STOP]`
-- **Progress:** Output `[Step 5/12] Specify — creating feature specification...`
+- **Progress:** Output `[Step 5/11] Specify — creating feature specification...`
 - **Skill:** `speckit.specify`
 - **Input:** Use the detailed specification output from Step 1 (brainstorm) **enriched with the research findings from Step 2**. Include recommended libraries, best practices, and compliance requirements from the research brief in the specification input.
 - **Knowledge lookup:** Use `mcp__bms-knowledge-mcp__search_knowledge` to search the `hosxp` collection for exact table names, field names, data types, and relationships needed by this feature. Reference actual HOSxP data structures in the spec.
@@ -139,42 +138,126 @@ After completing each step, output:
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add feature specification`
-- **Done:** Output `[Step 5/12] DONE — specification created`
+- **Done:** Output `[Step 5/11] DONE — specification created`
 
 ### Step 6 — Plan `[on_failure: STOP]`
-- **Progress:** Output `[Step 6/12] Plan — generating implementation plan...`
+- **Progress:** Output `[Step 6/11] Plan — generating implementation plan...`
 - **Skill:** `speckit.plan`
 - **Input:** reads from step 5 artifacts
 - **Output:** `specs/*/plan.md`
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add implementation plan`
-- **Done:** Output `[Step 6/12] DONE — plan created`
+- **Done:** Output `[Step 6/11] DONE — plan created`
 
 ### Step 7 — Tasks `[on_failure: STOP]`
-- **Progress:** Output `[Step 7/12] Tasks — generating task list...`
+- **Progress:** Output `[Step 7/11] Tasks — generating task list...`
 - **Skill:** `speckit.tasks`
 - **Input:** reads from step 6 artifacts
 - **Output:** `specs/*/tasks.md`
 - **Timeout:** 300s
 - **Retry:** up to 2 attempts
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add task list`
-- **Done:** Output `[Step 7/12] DONE — N tasks created`
+- **Done:** Output `[Step 7/11] DONE — N tasks created`
 
 ### Step 8 — Analyze `[on_failure: CONTINUE]`
-- **Progress:** Output `[Step 8/12] Analyze — cross-artifact consistency check...`
+- **Progress:** Output `[Step 8/11] Analyze — cross-artifact consistency check...`
 - **Skill:** `speckit.analyze`
 - **Purpose:** Cross-artifact consistency check (spec ↔ plan ↔ tasks ↔ research). Non-destructive — report only.
 - **Timeout:** 300s
 - **Post-action:** Commit all files and push. Message: `feat(speckit): add cross-artifact analysis report`
-- **Done:** Output `[Step 8/12] DONE — analysis complete`
+- **Done:** Output `[Step 8/11] DONE — analysis complete`
+
+### Completion Contract — DO NOT RETURN UNTIL THIS IS SATISFIED
+
+Before returning to the main agent, perform these verification checks yourself using Bash/Read. Do NOT return a success message if any file is missing — exploration-only returns are a bug, not an acceptable outcome.
+
+1. **Identify the feature directory.** Run `ls -dt specs/*/ | head -1` — this is your feature path (e.g. `specs/003-my-feature/`). Capture the feature slug (basename without trailing slash).
+2. **Verify each required artifact exists and is non-empty** using `test -s <file>`:
+   - `specs/constitution.md`
+   - `specs/<slug>/research.md`
+   - `specs/<slug>/spec.md`
+   - `specs/<slug>/plan.md`
+   - `specs/<slug>/tasks.md`
+3. **Verify commits were made:** `git log --oneline -n 12` should show at least 5 speckit commits (brainstorm, research, constitution, specify, plan, tasks, analyze).
+4. **If any artifact is missing or empty, do NOT return failure — write it directly.** The `Skill` tool sometimes fails inside subagents (tool-access restrictions, one-shot mode). Your job is to ensure the artifact exists on disk regardless of how it got there:
+   - Read the relevant template from `.specify/templates/` (spec-template.md, plan-template.md, tasks-template.md)
+   - Fill it in using the in-memory content you already produced from brainstorm/research/specify
+   - `Write` the file, `git add`, `git commit`, `git push`
+   - Re-run the verification check
+5. **Return format — the LAST LINE of your response must be exactly this structured marker** (the main agent parses it; no prose after it):
+
+   `FEATURE=<slug>|SPEC=<path>|PLAN=<path>|TASKS=<path>|STATUS=OK`
+
+   If after the fallback write in step 4 some artifact is still missing, return:
+
+   `FEATURE=<slug-or-unknown>|MISSING=<comma-separated-list>|STATUS=INCOMPLETE`
+"""
+
+### Phase 1 → Phase 2 Handoff — Verification Gate (MANDATORY)
+
+The subagent is one-shot — the Task tool dispatches it, waits, and returns a single text response. There is no SendMessage chaining. So the main agent **must verify artifacts exist on disk before proceeding**. A subagent that did only read-only exploration will return success-looking prose but leave `specs/*/` empty — do not trust the prose.
+
+**Step A — Parse the subagent marker.**
+Find the line beginning with `FEATURE=` in the subagent's output. Extract `<slug>`, `<spec>`, `<plan>`, `<tasks>`, `<status>`. If no marker is present, treat as `STATUS=INCOMPLETE`.
+
+**Step B — Verify artifacts on disk from the main context** (the subagent lies sometimes):
+
+```
+Bash: test -s specs/constitution.md \
+  && test -s specs/<slug>/spec.md \
+  && test -s specs/<slug>/plan.md \
+  && test -s specs/<slug>/tasks.md \
+  && echo "GATE=OK" || echo "GATE=MISSING"
+```
+
+**Step C — Branch:**
+- `GATE=OK` and marker `STATUS=OK` → verification passed. Proceed to Step 9.
+- Otherwise → run **Recovery Protocol**.
+
+#### Recovery Protocol
+
+**Attempt 1 — Retry subagent with a stricter recovery prompt.**
+
+Re-dispatch via Task tool:
 
-After all steps complete, return: the feature name, number of tasks created, and the path to tasks.md.
 """
+RECOVERY RUN. A previous Phase 1 execution returned without producing artifacts on disk at `specs/<slug>/`. The existing files may be partial. Your job now is to produce the missing artifacts — not to re-explore, not to re-research, not to ask questions.
+
+Required outputs (all must exist and be non-empty before you return):
+- specs/constitution.md
+- specs/<slug>/research.md
+- specs/<slug>/spec.md
+- specs/<slug>/plan.md
+- specs/<slug>/tasks.md
+
+Rules:
+1. Read `$ARGUMENTS` and every existing file under `specs/` to pick up where the prior run left off.
+2. If the `Skill` tool fails or is unavailable, do NOT retry it — `Write` the artifact directly using `.specify/templates/*.md` as the structure and content you know from the user requirement as the body.
+3. Resolve every ambiguity with a documented default in an `## Assumptions` section. Never emit `[NEEDS CLARIFICATION]` markers.
+4. After each file you write, `git add && git commit && git push` with message `feat(speckit): <step>`.
+5. Before returning, `test -s` each required file and `git log --oneline -n 12` to confirm.
+6. Return with the structured marker `FEATURE=<slug>|SPEC=<path>|PLAN=<path>|TASKS=<path>|STATUS=OK` as your final line, no prose after.
+"""
+
+After the retry returns, re-run Step B. If `GATE=OK`, proceed to Step 9.
+
+**Attempt 2 — Main-context inline fallback** (runs only if the retry also fails).
 
-After the subagent completes, update tasks 1-8 as completed using TaskUpdate, then output:
+Execute steps 5–8 directly in the main agent using Write/Edit/Bash, NOT via Task subagent and NOT via Skill tool:
 
-> Phase 1 complete. N tasks created at specs/feature-name/tasks.md
+1. Read `.specify/templates/spec-template.md`, `.specify/templates/plan-template.md`, `.specify/templates/tasks-template.md`.
+2. Read `$ARGUMENTS` and any partial artifacts already on disk under `specs/`.
+3. If the feature branch does not exist yet: `.specify/scripts/bash/create-new-feature.sh "$ARGUMENTS" --json --short-name <derived-slug> "$ARGUMENTS"` to create branch + spec directory.
+4. `Write` `specs/<slug>/spec.md` filling in each template section from the requirement. Use `## Assumptions` for defaults. Zero `[NEEDS CLARIFICATION]` markers allowed.
+5. `Write` `specs/<slug>/plan.md` with ordered steps, file paths, component boundaries, test strategy, rollback considerations.
+6. `Write` `specs/<slug>/tasks.md` with atomic, dependency-ordered tasks, each with acceptance criteria.
+7. Commit each as written: `git add <file> && git commit -m "feat(speckit): <step> (main-context fallback)" && git push`.
+8. Re-run Step B verification. If still `GATE=MISSING`, halt the pipeline with a clear error listing the missing files — do NOT proceed to Phase 2 with a broken spec tree.
+
+Only after the Verification Gate passes (`GATE=OK`), update tasks 1–8 as completed using TaskUpdate, then output:
+
+> Phase 1 complete. N tasks at specs/<slug>/tasks.md
 > Starting Phase 2 (implementation)...
 
 ---
@@ -183,13 +266,8 @@ After the subagent completes, update tasks 1-8 as completed using TaskUpdate, th
 
 > **Execution context:** Runs in main context after subagent completes.
 
-### Step 9 — Compact `[on_failure: CONTINUE]`
-- **Progress:** Output `[Step 9/12] Compact — freeing context window...`
-- **Action:** Run `/compact` to free context window before implementation.
-- **Done:** Update task 9 as completed.
-
-### Step 10 — Implement with Rolling QC `[on_failure: CONTINUE | max_retries: 3]`
-- **Progress:** Output `[Step 10/12] Implement — starting rolling QC loop (N tasks)...`
+### Step 9 — Implement with Rolling QC `[on_failure: CONTINUE | max_retries: 3]`
+- **Progress:** Output `[Step 9/11] Implement — starting rolling QC loop (N tasks)...`
 - **Engine:** ralph-loop
 - **Input:** Use the **tasks.md path returned by the Phase 1 subagent** (e.g. `specs/my-feature/tasks.md`). Replace `{TASKS_PATH}` below with the actual path.
 - **Completion promise:** `FINISHED`
@@ -220,10 +298,10 @@ After the subagent completes, update tasks 1-8 as completed using TaskUpdate, th
 
 `/ralph-loop:ralph-loop "systematically execute speckit.implement via the Skill tool to complete every task defined in {TASKS_PATH} with strict adherence to specification requirements. IMPORTANT: apply rolling QC after EACH task — after implementing a task run build and fix build errors, run linter and fix lint errors, run ALL tests (not just new ones) and fix failures, check for hardcoded secrets and injection vulnerabilities in code you just wrote, verify UI code has actionable error messages and loading states. RUNTIME SAFETY: always add explicit return type annotations on data transformation functions, never spread or iterate a function return value without verifying it returns the expected collection type, use strict equality and null guards for external data, write tests that execute data transformers and verify output type and shape. SQL VALIDATION: before writing any SQL statement verify exact table and column names exist via bms-session-mcp-server list_tables/describe_table or bms-knowledge-mcp search_knowledge with hosxp collection, never guess column names, after writing test each query with EXPLAIN or LIMIT 0 via the query tool to confirm it executes without error. INTEGRATION TESTING: for every task that touches database or data-dependent logic run an integration test using the real bms-session-mcp-server query tool to execute the feature's SQL against the real HOSxP database (not mocks), flow the result through the actual code path, assert on concrete properties (row count, columns populated, types match, masked fields handled), use small LIMIT to avoid large result sets. If integration test fails investigate the real cause and fix it — do not relax the assertion. BUSINESS LOGIC: before writing any SQL state the business question it answers then consult bms-knowledge-mcp search_knowledge on hosxp collection to verify canonical table selection, soft-delete filters, correct date columns, join keys (hn/vn/an); use graph_search for multi-table relationships; for reporting queries also check moph or nhso collections for regulatory rules; cite the HOSxP convention in a code comment next to the query. Only commit when build plus lint plus tests all pass with zero errors then proceed to next task. Report progress to the user after each task: output [Task N/total] DONE — task_name. Do NOT batch QC at the end. Maintain atomic commits after each successful task with clear traceability, avoid requesting confirmation and proceed autonomously, once all tasks are implemented invoke speckit.analyze via the Skill tool to perform a full validation pass, automatically apply all recommended improvements or corrections, re-run all tests to confirm stability and zero regression, and only output <promise>FINISHED</promise> after every task is fully completed, validated, and aligned with production-grade quality standards" --completion-promise "FINISHED" --max-iterations 10`
 
-- **Done:** Update task 10 as completed. Output `[Step 10/12] DONE — all tasks implemented and verified`
+- **Done:** Update task 9 as completed. Output `[Step 9/11] DONE — all tasks implemented and verified`
 
-### Step 11 — Final Quality Gate `[on_failure: STOP | max_retries: 3]`
-- **Progress:** Output `[Step 11/12] Final QC — running comprehensive quality audit...`
+### Step 10 — Final Quality Gate `[on_failure: STOP | max_retries: 3]`
+- **Progress:** Output `[Step 10/11] Final QC — running comprehensive quality audit...`
 - **Agent:** Dispatch `bms-speckit:quality-control` agent
 - **Purpose:** Final comprehensive sweep. Since inline QC already caught per-task issues, this focuses on **cross-cutting concerns** that can only be detected across the full codebase.
 - **Timeout:** 900s
@@ -240,15 +318,15 @@ After the subagent completes, update tasks 1-8 as completed using TaskUpdate, th
   - **H. Integration testing (real database, end-to-end)** — run actual integration tests against the real HOSxP database via `bms-session-mcp-server`. For every DB-touching feature verify there's an integration test that: executes the feature's real SQL via the `query` tool, flows real data through the actual code path (transformers, filters, UI components), asserts on concrete properties (row count range, column presence, type correctness, masked field handling, Thai encoding). Create missing integration tests. Never fix failures by mocking responses, skipping tests, or loosening assertions. Flag slow queries for user review. (skipped if bms-session-mcp-server is not available)
   - **I. Business logic semantic validation** — verify every SQL statement actually retrieves the correct data per the user's intent and HOSxP conventions, not just that it runs without error. For each SQL: state the business question it should answer, cross-reference `mcp__bms-knowledge-mcp__search_knowledge` on `hosxp` collection for canonical table selection, soft-delete/status filters, correct date columns, join keys (hn/vn/an), code system usage (ICD-10/LOINC/TMT). Use `graph_search` for multi-table relationship questions. Check regulatory compliance via `moph` and `nhso` collections (43 files reporting, reimbursement rules). Verify Thai conventions (Buddhist calendar, CID validation, pre-masked fields). Fix semantic mismatches with code comments citing the HOSxP convention. Flag ambiguous intent for user review. (skipped if bms-knowledge-mcp is not available)
 - The agent fixes everything it can. Major dependency updates are flagged for user review.
-- **Completion rule:** When the QC agent returns its report, proceed to Step 12 **unless** the report contains unfixed build errors, unfixed test failures, or unfixed critical security vulnerabilities. Informational findings, flagged-for-review items, and already-fixed issues do NOT block progression. If uncertain, proceed — the QC agent already fixed what it could.
+- **Completion rule:** When the QC agent returns its report, proceed to Step 11 **unless** the report contains unfixed build errors, unfixed test failures, or unfixed critical security vulnerabilities. Informational findings, flagged-for-review items, and already-fixed issues do NOT block progression. If uncertain, proceed — the QC agent already fixed what it could.
 - **Post-action:** Commit all fixes and push. Message: `fix(speckit): final QC — security, deps, UX consistency, accessibility`
-- **Done:** Update task 11 as completed. Output `[Step 11/12] DONE — quality gate passed`
+- **Done:** Update task 10 as completed. Output `[Step 10/11] DONE — quality gate passed`
 
-### Step 12 — Merge to Main `[on_failure: STOP]`
-- **Progress:** Output `[Step 12/12] Merge — merging to main branch...`
+### Step 11 — Merge to Main `[on_failure: STOP]`
+- **Progress:** Output `[Step 11/11] Merge — merging to main branch...`
 - **Action:** Switch to main branch, merge the feature branch (fast-forward if possible), push main to remote, then clean up the feature branch.
 - **Timeout:** 120s
-- **Done:** Update task 12 as completed. Output:
+- **Done:** Update task 11 as completed. Output:
 
 > Pipeline complete! Feature merged to main.
 
@@ -259,15 +337,15 @@ After the subagent completes, update tasks 1-8 as completed using TaskUpdate, th
 ```
 Phase 1 (subagent)                          Phase 2 (main context)
 ──────────────────────────────              ──────────────────────────────
-Step 1: brainstorm ──STOP── commit          Step 9:  compact
-        + knowledge search (hosxp)          Step 10: implement + rolling QC
-Step 2: research ────────── commit                   ┌─ implement task ─┐
-        + WebSearch + context7                       │  inline QC       │
-Step 3: constitution ─STOP─┐                         │  fix → commit    │
-Step 4: CLAUDE.md sync ───┘ commit                   └─ next task ──────┘
-Step 5: specify ──────STOP── commit         Step 11: final QC agent ── commit
-        + knowledge search (hosxp)                   (security/deps/UX/a11y/deploy)
-Step 6: plan ─────────STOP── commit         Step 12: merge to main + push
+Step 1: brainstorm ──STOP── commit          Step 9:  implement + rolling QC
+        + knowledge search (hosxp)                   ┌─ implement task ─┐
+Step 2: research ────────── commit                   │  inline QC       │
+        + WebSearch + context7                       │  fix → commit    │
+Step 3: constitution ─STOP─┐                         └─ next task ──────┘
+Step 4: CLAUDE.md sync ───┘ commit          Step 10: final QC agent ── commit
+Step 5: specify ──────STOP── commit                  (security/deps/UX/a11y/deploy)
+        + knowledge search (hosxp)          Step 11: merge to main + push
+Step 6: plan ─────────STOP── commit
 Step 7: tasks ────────STOP── commit
 Step 8: analyze ──────────── commit
 ```