@gobing-ai/spur 0.3.70 → 0.3.71

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     "plugins": [
         {
             "name": "sp",
-            "version": "0.3.70",
+            "version": "0.3.71",
             "source": "./plugins/sp"
         }
     ]

package/config/workflow-composition-baseline.json

@@ -117,7 +117,7 @@
                 },
                 "discovery:onEnter:0": {
                     "kind": "agent.run",
-                    "invocation": "Run sp:brainstorm for the idea: ${vars.idea}. The skill owns the approach-generation, design summary, and `needs_design` signal criteria; emit .spur/run/${vars.__runId}-idea-needs-design.json ({\"needs_design\": true|false}) and the design summary per the skill's `Design Approval Gate` and `The needs_design signal` sections. Also emit the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md per plugins/sp/skills/spur-dev/references/idea-evaluation.md (urgency/necessity 0–5, premises, pros/cons, alternatives, enhanced idea, recommendation). At the END of the report, append a provenance footer block of the exact form: `---\\nrun_id: ${vars.__runId}\\ngenerated_at: <RFC3339 timestamp>\\n---` (omit the footer only if run_id is empty)."
+                    "invocation": "Run sp:brainstorm for the idea: ${vars.idea}. The skill owns the approach-generation, design summary, and `needs_design` signal criteria; emit .spur/run/${vars.__runId}-idea-needs-design.json ({\"needs_design\": true|false}) and the design summary per the skill's `Design Approval Gate` and `The needs_design signal` sections. Also emit the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md per the `sp:spur-dev` skill's `idea-evaluation` reference (urgency/necessity 0–5, premises, pros/cons, alternatives, enhanced idea, recommendation). At the END of the report, append a provenance footer block of the exact form: `---\\nrun_id: ${vars.__runId}\\ngenerated_at: <RFC3339 timestamp>\\n---` (omit the footer only if run_id is empty)."
                 },
                 "idea-eval:onEnter:0": {
                     "kind": "hitl.confirm"
@@ -177,7 +177,7 @@
                 },
                 "decompose:onEnter:1": {
                     "kind": "agent.run",
-                    "invocation": "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against apps/cli/schemas/task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
+                    "invocation": "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
                 },
                 "decompose:onEnter:2": {
                     "kind": "shell",
@@ -230,11 +230,11 @@
                 },
                 "precheck:onEnter:3": {
                     "kind": "shell",
-                    "invocation": "SIZE_FILE=\".spur/run/$wbs-precheck-size.status\" && mkdir -p .spur/run && if [ -f plugins/sp/scripts/task-size-precheck.ts ]; then bun plugins/sp/scripts/task-size-precheck.ts \"$wbs\" --spur-bin \"$spurBin\" --max-reqs \"$maxImplementReqs\" --max-plan-items \"$maxImplementPlanItems\"; else\n  echo \"task-size-precheck failed closed — checker script\" >&2 &&\n  echo \"plugins/sp/scripts/task-size-precheck.ts absent.\" >&2 &&\n  echo \"FAIL\" > \"$SIZE_FILE\";\nfi && exit 0"
+                    "invocation": "SIZE_FILE=\".spur/run/$wbs-precheck-size.status\" && mkdir -p .spur/run && SIZE_SCRIPT=\"plugins/sp/scripts/task-size-precheck.ts\"; [ -f \"$SIZE_SCRIPT\" ] || SIZE_SCRIPT=\"$(superskill script path sp task-size-precheck.ts 2>/dev/null)\"; if [ -n \"$SIZE_SCRIPT\" ] && [ -f \"$SIZE_SCRIPT\" ]; then bun \"$SIZE_SCRIPT\" \"$wbs\" --spur-bin \"$spurBin\" --max-reqs \"$maxImplementReqs\" --max-plan-items \"$maxImplementPlanItems\"; else\n  echo \"task-size-precheck failed closed — checker not found in\" >&2 &&\n  echo \"plugins/sp/scripts/ nor staged; run 'superskill install sp'.\" >&2 &&\n  echo \"FAIL\" > \"$SIZE_FILE\";\nfi && exit 0"
                 },
                 "precheck:onEnter:4": {
                     "kind": "shell",
-                    "invocation": "EVID_FILE=\".spur/run/$wbs-precheck-evidence.status\" && mkdir -p .spur/run && if [ -f plugins/sp/scripts/task-evidence-precheck.ts ]; then bun plugins/sp/scripts/task-evidence-precheck.ts \"$wbs\" --spur-bin \"$spurBin\"; else\n  echo \"task-evidence-precheck failed closed —\" >&2 &&\n  echo \"plugins/sp/scripts/task-evidence-precheck.ts absent.\" >&2 &&\n  echo \"FAIL\" > \"$EVID_FILE\";\nfi && exit 0"
+                    "invocation": "EVID_FILE=\".spur/run/$wbs-precheck-evidence.status\" && mkdir -p .spur/run && EVID_SCRIPT=\"plugins/sp/scripts/task-evidence-precheck.ts\"; [ -f \"$EVID_SCRIPT\" ] || EVID_SCRIPT=\"$(superskill script path sp task-evidence-precheck.ts 2>/dev/null)\"; if [ -n \"$EVID_SCRIPT\" ] && [ -f \"$EVID_SCRIPT\" ]; then bun \"$EVID_SCRIPT\" \"$wbs\" --spur-bin \"$spurBin\"; else\n  echo \"task-evidence-precheck failed closed — checker not found\" >&2 &&\n  echo \"in plugins/sp/scripts/ nor staged; run 'superskill install sp'.\" >&2 &&\n  echo \"FAIL\" > \"$EVID_FILE\";\nfi && exit 0"
                 },
                 "implement:onEnter:0": {
                     "kind": "agent.run",
@@ -299,7 +299,7 @@
                 },
                 "verify:onEnter:2": {
                     "kind": "shell",
-                    "invocation": "bun plugins/sp/scripts/verify-answer-lint.ts \"$wbs\" --answer \".spur/run/$wbs-verify-answer.txt\" --spur-bin \"$spurBin\""
+                    "invocation": "LINT_SCRIPT=\"plugins/sp/scripts/verify-answer-lint.ts\"; [ -f \"$LINT_SCRIPT\" ] || LINT_SCRIPT=\"$(superskill script path sp verify-answer-lint.ts 2>/dev/null)\"; if [ -z \"$LINT_SCRIPT\" ] || [ ! -f \"$LINT_SCRIPT\" ]; then\n  echo \"verify-answer-lint: checker not found in plugins/sp/scripts/ nor staged — run 'superskill install sp'\" >&2;\n  exit 1;\nfi; bun \"$LINT_SCRIPT\" \"$wbs\" --answer \".spur/run/$wbs-verify-answer.txt\" --spur-bin \"$spurBin\""
                 },
                 "verify:onEnter:3": {
                     "kind": "shell",
@@ -318,7 +318,7 @@
                 },
                 "record:onEnter:2": {
                     "kind": "shell",
-                    "invocation": "FID=$($spurBin task show $wbs --json 2>/dev/null | jq -r \".feature_id // .frontmatter.feature_id // empty\" 2>/dev/null); if [ -n \"$FID\" ]; then\n  if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n    bun plugins/sp/scripts/feature-sync-bounded.ts \"$FID\" --spur-bin \"$spurBin\" --json;\n  else\n    $spurBin feature sync \"$FID\" --json;\n  fi;\nelse\n  echo \"Orphan task $wbs — no feature_id linked; proposal: consider linking to a parent feature.\" >> \".spur/run/$wbs-report.txt\";\nfi; exit 0"
+                    "invocation": "FID=$($spurBin task show $wbs --json 2>/dev/null | jq -r \".feature_id // .frontmatter.feature_id // empty\" 2>/dev/null); if [ -n \"$FID\" ]; then\n  if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n    bun plugins/sp/scripts/feature-sync-bounded.ts \"$FID\" --spur-bin \"$spurBin\" --json;\n  elif SYNC_MJS=\"$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)\" && [ -f \"$SYNC_MJS\" ]; then\n    node \"$SYNC_MJS\" \"$FID\" --spur-bin \"$spurBin\" --json;\n  else\n    $spurBin feature sync \"$FID\" --json;\n  fi;\nelse\n  echo \"Orphan task $wbs — no feature_id linked; proposal: consider linking to a parent feature.\" >> \".spur/run/$wbs-report.txt\";\nfi; exit 0"
                 },
                 "done:onEnter:0": {
                     "kind": "shell",
@@ -367,7 +367,7 @@
                 },
                 "feature-transition:onEnter:0": {
                     "kind": "shell",
-                    "invocation": "if [ -z \"$feature\" ]; then\n  echo \"feature-transition: vars.feature is empty — refusing no-op feature sync (mis-invocation, not a blocked sync)\" >&2;\n  exit 1;\nfi; SYNC_OUTPUT=$(if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n  bun plugins/sp/scripts/feature-sync-bounded.ts \"$feature\" --spur-bin \"$spurBin\" --json;\nelse\n  $spurBin feature sync \"$feature\" --json;\nfi); SYNC_RC=$?; printf '%s\\n' \"$SYNC_OUTPUT\"; APPLIED=$(printf '%s' \"$SYNC_OUTPUT\" | jq -r '.applied // false' 2>/dev/null || echo false); if [ \"$APPLIED\" = \"true\" ] || [ \"$SYNC_RC\" -ne 0 ]; then\n  echo \"feature-transition: sync applied or failed after a possible partial transition for $feature — running corpus-aware gate: $featureGateCmd\";\n  if sh -c \"$featureGateCmd\"; then\n    echo \"feature-transition: corpus-aware gate PASS for feature $feature\";\n  else\n    echo \"feature-transition: corpus-aware gate FAIL for feature $feature — inspect findings before reporting the transition complete\" >&2;\n  fi;\nelse\n  echo \"feature-transition: sync did not apply a transition (rc=$SYNC_RC, applied=$APPLIED) — corpus-aware gate skipped\";\nfi; exit 0"
+                    "invocation": "if [ -z \"$feature\" ]; then\n  echo \"feature-transition: vars.feature is empty — refusing no-op feature sync (mis-invocation, not a blocked sync)\" >&2;\n  exit 1;\nfi; SYNC_OUTPUT=$(if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then\n  bun plugins/sp/scripts/feature-sync-bounded.ts \"$feature\" --spur-bin \"$spurBin\" --json;\nelif SYNC_MJS=\"$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)\" && [ -f \"$SYNC_MJS\" ]; then\n  node \"$SYNC_MJS\" \"$feature\" --spur-bin \"$spurBin\" --json;\nelse\n  $spurBin feature sync \"$feature\" --json;\nfi); SYNC_RC=$?; printf '%s\\n' \"$SYNC_OUTPUT\"; APPLIED=$(printf '%s' \"$SYNC_OUTPUT\" | jq -r '.applied // false' 2>/dev/null || echo false); if [ \"$APPLIED\" = \"true\" ] || [ \"$SYNC_RC\" -ne 0 ]; then\n  echo \"feature-transition: sync applied or failed after a possible partial transition for $feature — running corpus-aware gate: $featureGateCmd\";\n  if sh -c \"$featureGateCmd\"; then\n    echo \"feature-transition: corpus-aware gate PASS for feature $feature\";\n  else\n    echo \"feature-transition: corpus-aware gate FAIL for feature $feature — inspect findings before reporting the transition complete\" >&2;\n  fi;\nelse\n  echo \"feature-transition: sync did not apply a transition (rc=$SYNC_RC, applied=$APPLIED) — corpus-aware gate skipped\";\nfi; exit 0"
                 },
                 "branch-cleanup:onEnter:0": {
                     "kind": "hitl.confirm"

package/config/workflows/idea-pipeline.yaml

@@ -99,13 +99,14 @@ states:
       boolean signal written to .spur/run/${vars.__runId}-idea-needs-design.json — this determines
       whether the system-design state runs. As its terminal artifact for the idea path,
       brainstorm also emits the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md
-      (template: plugins/sp/skills/spur-dev/references/idea-evaluation.md).
+      (template: the `sp:spur-dev` skill's `idea-evaluation` reference — named by skill, not by
+      repo path, because `spur init` never scaffolds `plugins/sp/` into a seeded project).
       expectFile fails a silent no-op discovery (no eval report).
     onEnter:
       - kind: agent.run
         options:
           agent: ${vars.planningAgent}
-          input: "Run sp:brainstorm for the idea: ${vars.idea}. The skill owns the approach-generation, design summary, and `needs_design` signal criteria; emit .spur/run/${vars.__runId}-idea-needs-design.json ({\"needs_design\": true|false}) and the design summary per the skill's `Design Approval Gate` and `The needs_design signal` sections. Also emit the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md per plugins/sp/skills/spur-dev/references/idea-evaluation.md (urgency/necessity 0–5, premises, pros/cons, alternatives, enhanced idea, recommendation). At the END of the report, append a provenance footer block of the exact form: `---\\nrun_id: ${vars.__runId}\\ngenerated_at: <RFC3339 timestamp>\\n---` (omit the footer only if run_id is empty)."
+          input: "Run sp:brainstorm for the idea: ${vars.idea}. The skill owns the approach-generation, design summary, and `needs_design` signal criteria; emit .spur/run/${vars.__runId}-idea-needs-design.json ({\"needs_design\": true|false}) and the design summary per the skill's `Design Approval Gate` and `The needs_design signal` sections. Also emit the idea-evaluation report to .spur/run/${vars.__runId}-idea-eval-report.md per the `sp:spur-dev` skill's `idea-evaluation` reference (urgency/necessity 0–5, premises, pros/cons, alternatives, enhanced idea, recommendation). At the END of the report, append a provenance footer block of the exact form: `---\\nrun_id: ${vars.__runId}\\ngenerated_at: <RFC3339 timestamp>\\n---` (omit the footer only if run_id is empty)."
           # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
           role: planner
           expectFile: .spur/run/${vars.__runId}-idea-eval-report.md
@@ -298,7 +299,7 @@ states:
       - kind: agent.run
         options:
           agent: ${vars.planningAgent}
-          input: "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against apps/cli/schemas/task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
+          input: "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
           # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
           role: planner
           expectFile: .spur/run/${vars.__runId}-idea-task-batch.json

package/config/workflows/task-pipeline.yaml

@@ -19,7 +19,7 @@
 #   agent / spurBin           — executor + spur binary (CLI overrides spurBin)
 #   stepTimeoutMs             — agent.run budget for review/verify/test-fix (ms)
 #   implementTimeoutMs        — implement agent.run budget (ms)
-#   qualityGateCmd            — project gate (default: bun run autofix && bun run spur-check)
+#   qualityGateCmd            — project gate (default: bun run spur-check)
 #   qualityGateMaxFixAttempts — max /sp:dev-fixall hops after a red gate (default: 2)
 #
 # Seeded by `spur init`. agent.run inputs are pure slash commands (ADR-043).
@@ -104,7 +104,12 @@ vars:
   # and the fixall slash input all use this same var so the command stays single-sourced.
   # TRUSTED CONFIG ONLY — this string is executed via `sh -c` (see test/test-recheck). Never
   # interpolate untrusted operator/LLM input into qualityGateCmd (task 0436 SECUA residual).
-  qualityGateCmd: "bun run format && bun run spur-check"
+  # NO `format` PREFIX: `implement` already ran `$formatCmd` on its way out, and `test`
+  # captures `proofDigest` (onEnter[3]) BEFORE this command runs (onEnter[4]) — a formatter
+  # inside the gate rewrites the very tree the digest just fingerprinted (ADR-071 proof
+  # window). It was a no-op only because the implement-stage format got there first; that is
+  # an accident, not an invariant. The gate observes, it does not mutate.
+  qualityGateCmd: "bun run spur-check"
   # Cheap red-detector run before the full gate on **recheck only**; empty ⇒ no probe
   # (full gate every recheck — the pre-0587 behavior). A project overriding qualityGateCmd
   # should override this too. TRUSTED CONFIG ONLY — executed via `sh -c` (same surface as
@@ -208,13 +213,16 @@ states:
           command: >-
             SIZE_FILE=".spur/run/$wbs-precheck-size.status" &&
             mkdir -p .spur/run &&
-            if [ -f plugins/sp/scripts/task-size-precheck.ts ]; then
-            bun plugins/sp/scripts/task-size-precheck.ts "$wbs"
+            SIZE_SCRIPT="plugins/sp/scripts/task-size-precheck.ts";
+            [ -f "$SIZE_SCRIPT" ] ||
+            SIZE_SCRIPT="$(superskill script path sp task-size-precheck.ts 2>/dev/null)";
+            if [ -n "$SIZE_SCRIPT" ] && [ -f "$SIZE_SCRIPT" ]; then
+            bun "$SIZE_SCRIPT" "$wbs"
             --spur-bin "$spurBin" --max-reqs "$maxImplementReqs"
             --max-plan-items "$maxImplementPlanItems";
             else
-              echo "task-size-precheck failed closed — checker script" >&2 &&
-              echo "plugins/sp/scripts/task-size-precheck.ts absent." >&2 &&
+              echo "task-size-precheck failed closed — checker not found in" >&2 &&
+              echo "plugins/sp/scripts/ nor staged; run 'superskill install sp'." >&2 &&
               echo "FAIL" > "$SIZE_FILE";
             fi &&
             exit 0
@@ -228,12 +236,15 @@ states:
           command: >-
             EVID_FILE=".spur/run/$wbs-precheck-evidence.status" &&
             mkdir -p .spur/run &&
-            if [ -f plugins/sp/scripts/task-evidence-precheck.ts ]; then
-            bun plugins/sp/scripts/task-evidence-precheck.ts "$wbs"
+            EVID_SCRIPT="plugins/sp/scripts/task-evidence-precheck.ts";
+            [ -f "$EVID_SCRIPT" ] ||
+            EVID_SCRIPT="$(superskill script path sp task-evidence-precheck.ts 2>/dev/null)";
+            if [ -n "$EVID_SCRIPT" ] && [ -f "$EVID_SCRIPT" ]; then
+            bun "$EVID_SCRIPT" "$wbs"
             --spur-bin "$spurBin";
             else
-              echo "task-evidence-precheck failed closed —" >&2 &&
-              echo "plugins/sp/scripts/task-evidence-precheck.ts absent." >&2 &&
+              echo "task-evidence-precheck failed closed — checker not found" >&2 &&
+              echo "in plugins/sp/scripts/ nor staged; run 'superskill install sp'." >&2 &&
               echo "FAIL" > "$EVID_FILE";
             fi &&
             exit 0
@@ -563,7 +574,14 @@ states:
       - kind: shell
         options:
           command: >-
-            bun plugins/sp/scripts/verify-answer-lint.ts "$wbs"
+            LINT_SCRIPT="plugins/sp/scripts/verify-answer-lint.ts";
+            [ -f "$LINT_SCRIPT" ] ||
+            LINT_SCRIPT="$(superskill script path sp verify-answer-lint.ts 2>/dev/null)";
+            if [ -z "$LINT_SCRIPT" ] || [ ! -f "$LINT_SCRIPT" ]; then
+              echo "verify-answer-lint: checker not found in plugins/sp/scripts/ nor staged — run 'superskill install sp'" >&2;
+              exit 1;
+            fi;
+            bun "$LINT_SCRIPT" "$wbs"
             --answer ".spur/run/$wbs-verify-answer.txt"
             --spur-bin "$spurBin"
       - kind: shell
@@ -643,6 +661,8 @@ states:
             if [ -n "$FID" ]; then
               if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then
                 bun plugins/sp/scripts/feature-sync-bounded.ts "$FID" --spur-bin "$spurBin" --json;
+              elif SYNC_MJS="$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)" && [ -f "$SYNC_MJS" ]; then
+                node "$SYNC_MJS" "$FID" --spur-bin "$spurBin" --json;
               else
                 $spurBin feature sync "$FID" --json;
               fi;

package/config/workflows/wrapup-pipeline.yaml

@@ -54,12 +54,16 @@ vars:
   # Corpus-aware quality gate for the feature-transition hop (R1, task 0625).
   # The per-task gate (`spur-check`) deliberately excludes corpus-check — the only
   # sweep that observes feature-level findings — so a transition that arms one
-  # would go green. A feature transition happens once per feature, so the ~41 s
-  # corpus sweep is paid once here. Soft by design: the gate reports PASS/FAIL
-  # and lets the operator decide; it never hard-fails the wrap-up shell.
+  # would go green. This gate is therefore the CORPUS SWEEP ALONE (~29 s), not
+  # `spur-check-new`: every task in the feature already paid a full `spur-check`
+  # in its own pipeline, and the states that run before this hop (`doc-sync`,
+  # `metrics-record`) write only markdown and task sections, which Biome skips
+  # (`ignoreUnknown: true`). Re-running the ~105 s per-task gate here re-verifies
+  # unchanged code and measures nothing new. Soft by design: the gate reports
+  # PASS/FAIL and lets the operator decide; it never hard-fails the wrap-up shell.
   # TRUSTED CONFIG ONLY — this string is executed via `sh -c` (same surface as
   # task-pipeline's qualityGateCmd). Never interpolate untrusted input into it.
-  featureGateCmd: "bun run spur-check-new"
+  featureGateCmd: "bun run corpus-check"
   __hitlAnswer: ""
 
 states:
@@ -178,6 +182,8 @@ states:
             fi;
             SYNC_OUTPUT=$(if [ -f plugins/sp/scripts/feature-sync-bounded.ts ]; then
               bun plugins/sp/scripts/feature-sync-bounded.ts "$feature" --spur-bin "$spurBin" --json;
+            elif SYNC_MJS="$(superskill script path sp feature-sync-bounded.mjs 2>/dev/null)" && [ -f "$SYNC_MJS" ]; then
+              node "$SYNC_MJS" "$feature" --spur-bin "$spurBin" --json;
             else
               $spurBin feature sync "$feature" --json;
             fi);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.70",
+    "version": "0.3.71",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",
@@ -53,14 +53,14 @@
     },
     "devDependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@gobing-ai/ts-db": "^0.4.49",
-        "@gobing-ai/ts-ai-runner": "^0.4.49",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.4.49",
-        "@gobing-ai/ts-infra": "^0.4.49",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.49",
-        "@gobing-ai/ts-rule-engine": "^0.4.49",
-        "@gobing-ai/ts-runtime": "^0.4.49",
-        "@gobing-ai/ts-utils": "^0.4.49",
+        "@gobing-ai/ts-db": "^0.4.50",
+        "@gobing-ai/ts-ai-runner": "^0.4.50",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.50",
+        "@gobing-ai/ts-infra": "^0.4.50",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.50",
+        "@gobing-ai/ts-rule-engine": "^0.4.50",
+        "@gobing-ai/ts-runtime": "^0.4.50",
+        "@gobing-ai/ts-utils": "^0.4.50",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/plugins/sp/commands/dev-fixall.md

@@ -28,7 +28,8 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 ## Implementation
 
 Under the pipeline, the `test-recheck` state runs the full gate immediately after this hop — that is
-the deciding run. Fixall bounds itself to **one confirming gate run** (R4, task 0483); use targeted
-probes (`bun test <file> --test-name-pattern <test>`) during fix loops, never re-run the full gate
-per fix. `qualityGateCmd` itself is unchanged so `test-recheck` still runs the full gate.
+the deciding run. When `--gate-log` is set (the pipeline signal), fixall runs **no full gate at
+all**: targeted probes (`bun test <file> --test-name-pattern <test>`) during fix loops, then one
+`bun run lint` before returning. Invoked standalone, it keeps the single confirming run (R4, task
+0483). `qualityGateCmd` itself is unchanged so `test-recheck` still runs the full gate.
 

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.70",
+    "version": "0.3.71",
     "description": "Spur — a local-first harness engineering toolkit that wraps mainstream coding agents with constraint checking, workflow orchestration, and history analytics.",
     "extensions": {
         "pi": ["./hooks/pi/guard-extension.ts"]

package/plugins/sp/scripts/verify-answer-lint.ts

@@ -245,15 +245,24 @@ function sectionBetween(text: string, heading: string): string {
 function extractRequirementIds(taskContent: string): string[] {
     const section = sectionBetween(taskContent, 'Requirements');
     const ids = new Set<string>();
-    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\s*\./g)) ids.add(m[1] ?? '');
-    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\*\*/g)) ids.add(m[1] ?? '');
+    // Corpus forms: bold-wrapped (`**R1. Title.**`, bare `**R1**`); right after a list
+    // marker with optional checkbox (`- [ ] R1.` — the dominant corpus form, `- R1. Title.`,
+    // `- R1:`) or a bare checkbox with the marker omitted (`[x] R1.`); line-start (`R1:`).
+    // The marker and the checkbox are never both optional — that would match bare prose
+    // (`R1 is …`) and fabricate declarations. Sub-IDs (`R1.1`) match in every form.
+    for (const m of section.matchAll(/\*\*(R\d+(?:\.\d+)*)\b/g)) ids.add(m[1] ?? '');
+    for (const m of section.matchAll(/^(?:[-*]\s+(?:\[[ xX]\]\s+)?|\[[ xX]\]\s+)(R\d+(?:\.\d+)*)/gm))
+        ids.add(m[1] ?? '');
+    for (const m of section.matchAll(/^(R\d+(?:\.\d+)*)\s*[.:]/gm)) ids.add(m[1] ?? '');
     return [...ids];
 }
 
 function extractAcIdentities(taskContent: string, featureContent: string | null): string[] {
     const identities = new Set<string>();
     const section = sectionBetween(taskContent, 'Acceptance Criteria');
-    for (const m of section.matchAll(/^[-*]\s+\[[ x]\]\s+(.+?)\s*(?::|$)/gm)) {
+    // Checkbox labels (`- [x] AC1 (R1): …`, 0726) and plain bullets (`- AC1: Given …`,
+    // 0713/0727) both yield the label text up to `:` plus its leading token.
+    for (const m of section.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?(.+?)\s*(?::|$)/gm)) {
         const label = (m[1] ?? '').trim();
         if (!label) continue;
         identities.add(label);

package/plugins/sp/skills/code-implementation/SKILL.md

@@ -81,7 +81,7 @@ surfaces is what keeps that gate quiet.
 ## Implement scope: do not run the project quality gate
 
 During implement, the pipeline's `test` hop runs `${vars.qualityGateCmd}` (the full project gate:
-`bun run format && bun run spur-check`) immediately after this step and is the gate that actually
+`bun run spur-check`) immediately after this step and is the gate that actually
 decides pass/fail. Running it inside implement is pure redundancy — it cannot change the outcome and
 only burns wall clock and context budget.
 

package/plugins/sp/skills/spec-decomposition/SKILL.md

@@ -57,7 +57,7 @@ granularity knobs (min/target/force-split hours), and parent/umbrella-task conve
 spur task batch-create --file decomposition.json   # bare JSON array; atomic, all-or-nothing
 ```
 
-Validate locally against `apps/cli/schemas/task-batch.schema.json` (runtime SSOT: the Zod
+Validate locally against `task-batch.schema.json` (runtime SSOT: the Zod
 `taskBatchSchema`) before invoking the CLI — a single violation rejects the entire batch. The gate is
 the only proof the decomposition is well-formed; never hand-write task files to bypass it.
 

package/plugins/sp/skills/spur-cli/references/history.md

@@ -29,9 +29,9 @@ Every JSON-capable verb also advertises `--json-envelope`; use the facade's mach
 ## `import` - isolated fan-out
 
 ```bash
-bun run apps/cli/src/index.ts history import --source all --dry-run --json
-bun run apps/cli/src/index.ts history import --source codex --mode incremental --json
-bun run apps/cli/src/index.ts history import --source codex --file session.jsonl --mode force-file --json
+spur history import --source all --dry-run --json
+spur history import --source codex --mode incremental --json
+spur history import --source codex --file session.jsonl --mode force-file --json
 ```
 
 - `--source all` and a single source use the same per-source fan-out path. A failed/timed-out source
@@ -39,9 +39,10 @@ bun run apps/cli/src/index.ts history import --source codex --file session.jsonl
 - Modes are `incremental`, `full`, and `force-file`. `--file` with the default `all` source is a
   usage error. `--file --mode full` requires `--dry-run`; use `force-file` for a real single-file
   write.
-- JSON contains `entries`, `warnings`, `exitCode`, and CLI/importer `provenance`. For real-data
-  validation, invoke the source-local CLI and record that provenance; never trust a bare global
-  `spur` that may be stale.
+- JSON contains `entries`, `warnings`, `exitCode`, and CLI/importer `provenance`. Record that
+  provenance for any real-data validation. **When developing Spur itself**, invoke the source-local
+  CLI (`bun run apps/cli/src/index.ts history import …`) instead of a global `spur` that may be a
+  stale published bundle; in every other project the installed `spur` is the CLI.
 - Exit `0` when every source is clean/empty, `2` for a mixed failure or any degraded source, and `1`
   when all sources fail. CLI usage guards also exit `1` on this noun.
 

package/plugins/sp/skills/spur-dev/references/dev-operations.md

@@ -463,8 +463,8 @@ is the procedure. The backing is a combination of git CLI, `spur` CLI, and agent
   6. Run `bun run test`. Collect all failures.
   7. If tests are green, done.
   8. **Test fix loop:** for each failure, diagnose (test bug vs implementation bug), apply the fix, re-run the **failing test only** (`bun test <file> --test-name-pattern "<test>"`). Do NOT re-run the full suite per fix — it is the dominant loop cost (task 0436 R2).
-  9. **Confirming run (at most once).** After all fixes, run `bun run format && bun run lint && bun run test` **at most once** to confirm. If it passes, the hop is done.
-  10. **Pipeline-awareness (R4, task 0483).** When `/sp:dev-fixall` is invoked from the pipeline's `test-fix` hop, `test-recheck` runs the full `${vars.qualityGateCmd}` gate immediately after this hop returns — that is the **deciding** run that writes PASS to `.spur/run/<wbs>-test-gate.status`. Do NOT re-run the full gate beyond the single confirming run in step 9; the deciding run belongs to `test-recheck`. If your confirming run already passed, return immediately — a second or third gate run inside this hop is pure redundancy (0482 ran the gate 3× plus a standalone `bun run test`; all four were followed by `test-recheck` running it a 5th time). If your confirming run failed and you fixed more, re-run the full gate once more within `--max-retry` budget, then return — let `test-recheck` judge.
+  9. **Confirming run — standalone invocation only (at most once).** After all fixes, run `bun run format && bun run lint && bun run test` **at most once** to confirm. If it passes, the hop is done. **Skip this step entirely when `--gate-log` is set** (see step 10) — under the pipeline nothing consumes its verdict.
+  10. **Pipeline-awareness (R4, task 0483; confirming run dropped 2026-08-31).** `--gate-log` is set only by the pipeline's `test-fix` hop, so treat it as the pipeline signal. There, `test-recheck` runs the full `${vars.qualityGateCmd}` gate immediately after this hop returns — that is the **deciding** run, the only one that writes PASS to `.spur/run/<wbs>-test-gate.status`. A confirming run inside this hop decides nothing and costs a second full gate (~105 s here) to answer a question `test-recheck` is about to answer anyway. So under `--gate-log`: **run no full gate at all.** Your self-check is what step 8 already gives you — the failing tests you re-ran individually — plus **one `bun run lint`** (~7 s: Biome + typecheck) to catch type or lint breakage your fixes introduced. Then return and let `test-recheck` judge. `test-recheck` opens with the same cheap `${vars.gateProbeCmd}` probe, so a still-red tree is caught in seconds rather than by a full suite. Historical anti-pattern this replaces: 0482 ran the gate 3× plus a standalone `bun run test`, and `test-recheck` then ran it a 5th time.
   11. Report: list what was fixed (file + one-line summary per fix). If any error could not be resolved, report it explicitly — do not suppress.
 - **Invariants:** Never bypass with `--no-verify`, `--force`, or new `biome-ignore`/`eslint-disable` suppressions. Never skip or `.skip` a test to make the suite green. Fix the root cause, not the symptom. Never claim green on `bun run lint` alone — a formatter-only diff passes `lint` but fails the formatter; run `bun run format` (or assert it produces no diff) before declaring the gate clean. **Never re-run the full gate more than once per confirming pass** (R4) — use targeted probes during the fix loops and let the pipeline's `test-recheck` state be the deciding run.
 - **MANDATORY Exit Condition.** The ONLY way to complete successfully:

package/plugins/sp/skills/spur-dev/references/execution-workflow.md

@@ -46,7 +46,7 @@ one thing and yields, so the **pipeline (not the agent) owns the loop**.
 | Stage | Operation | Defined in |
 | ------- | ----------- | ------------ |
 | `implement` | `/sp:dev-run --mode implement <wbs>` — write the code that satisfies the task; author `## Solution`. | [dev-operations.md §4 run](dev-operations.md) → `sp:code-implementation` |
-| `test` → (`test-fix` ↔ `test-recheck`) → `review` \| `failed` | **Project quality gate** (not `/sp:dev-unit`). Soft shell probe of `${vars.qualityGateCmd}` (default `bun run autofix && bun run spur-check`) — green path pays **one** full gate run. On FAIL: bounded `/sp:dev-fixall` loop (`qualityGateMaxFixAttempts`, default 2) with soft recheck; exhausted attempts route to pipeline `failed`. `/sp:dev-unit` remains **coverage gap-fill** (router C3/C5 / standalone). | [dev-operations.md §10 fixall](dev-operations.md); unit op still §1 |
+| `test` → (`test-fix` ↔ `test-recheck`) → `review` \| `failed` | **Project quality gate** (not `/sp:dev-unit`). Soft shell probe of `${vars.qualityGateCmd}` (default `bun run spur-check`) — green path pays **one** full gate run. On FAIL: bounded `/sp:dev-fixall` loop (`qualityGateMaxFixAttempts`, default 2) with soft recheck; exhausted attempts route to pipeline `failed`. `/sp:dev-unit` remains **coverage gap-fill** (router C3/C5 / standalone). | [dev-operations.md §10 fixall](dev-operations.md); unit op still §1 |
 | `review` | `/sp:dev-review <wbs>` — SECUA-framework review of the diff. | [dev-operations.md §2 review](dev-operations.md) |
 | `verify` | `sp:code-verification` — requirements traceability + verdict. | [dev-operations.md §3 verify](dev-operations.md) |
 
@@ -97,6 +97,7 @@ cache-conservation discipline (`plugins/sp/skills/dogfood-testing/references/mon
 ## Step 2: Pipeline run
 
 > **Pre-launch size-gate pre-check (R1 / 0478).** Before launching `spur workflow run task-pipeline.yaml`, probe the task's `## Plan` checklist item count (`spur task show <wbs> --json`). The default cap is 8 items (`maxImplementPlanItems: 8`). If the plan item count exceeds 8:
+>
 > - Without `--auto`: warn the operator before calling `spur workflow run` and prompt for confirmation or a plan-item override via `--vars '{"maxImplementPlanItems":"<count>"}'`.
 > - With `--auto`: automatically append `"maxImplementPlanItems": "<count>"` to `--vars` and log a single-line notice (e.g. `Notice: task <wbs> has N plan items (>8 default cap); injecting maxImplementPlanItems override`).
 
@@ -313,6 +314,12 @@ the partial work still in the working tree. The failure output names the partial
    [`done-housekeeping.md`](done-housekeeping.md) F6 — it carries the provenance obligations
    (honest `done_reason`, verdict regeneration).
 
+   **Inline path (task 0727).** There is no `<runId>-implement-partial.md` artifact on the inline
+   driver path — it is written only by the subprocess `agent.run` action. The inline equivalent is
+   the dispatch-timeout contract in [`inline-pipeline-driver.md`](inline-pipeline-driver.md):
+   resume from the partial tree, never restart the stage inline; the partial working tree is the
+   recovery input.
+
 **3. Match the executor to the size (task 0487 R3).** Size and executor capability are one
 decision, not two. **≥ 6 requirements or ≥ 9 Plan items → a `reviewer`-role executor (the
 `reviewer` row of [`roles.md`](../../../references/roles.md) declares the floor), or split the

package/plugins/sp/skills/spur-dev/references/gate-checklists.md

@@ -52,7 +52,7 @@ Entered before `spur task batch-create --file <json>` (idea-pipeline `batch-crea
 decomposition gate `/sp:dev-plan` also routes through since D5-K).
 
 - [ ] The batch JSON is a bare array (not an object with a `tasks` key).
-- [ ] Each entry validates locally against `apps/cli/schemas/task-batch.schema.json` (`additionalProperties: false` — no unknown keys).
+- [ ] Each entry validates locally against `task-batch.schema.json` (`additionalProperties: false` — no unknown keys).
 - [ ] Each entry has a non-empty `name` (required).
 - [ ] `feature_id` matches an existing feature (or is intentionally deferred with operator awareness).
 - [ ] `parent_wbs` is set when the task is a child of a decomposition parent.

package/plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md

@@ -41,6 +41,12 @@ command, skill, script, or second workflow.
      the YAML parsed in step 1, shown only for the active state.
    - **Refresh cadence** = stage boundaries only (when the current state changes after a transition),
      never per action.
+   - **Transition reconciliation (task 0727)** = at every stage boundary the host must
+     **mark the finished stage completed and the next stage in_progress** in the host todo list.
+     This reconciliation is **host-owned and execution-surface-independent**: it fires identically
+     whether the stage ran via native subagent, host-inline execution, or the post-dispatch host
+     fallback, so a run can never terminate with earlier stages stuck `in_progress` (task 0726
+     ended 0/11 with precheck and implement still open).
    - **Source of truth** = the CLI projection for layer 1; the YAML parsed in step 1 for layer 2.
      Never hand-copy or hand-derive the state list into the driver, a command, a skill, or a script.
 5. For task execution only, record lifecycle provenance before entering the FSM:
@@ -119,6 +125,19 @@ before the subagent starts, log the reason and use host fallback. If a started s
 leaves invalid artifacts, do **not** replay the stage in the host — follow the YAML error policy so
 partial mutations are not duplicated.
 
+**Timeout boundary (task 0727):** a dispatched subagent is governed by
+**the host platform's subagent limit, not the YAML timeoutMs** — `timeoutMs` stays not-applicable
+for host execution only — and before dispatch the driver must
+**record the governing timeout boundary and its source before dispatch** in the run log
+(e.g. `host timeout <ms> (<platform subagent limit|yaml timeoutMs>)`). If the dispatch reaches that
+boundary, **a dispatch timeout is a started-subagent failure**: the no-replay rule above and the
+stage's declared YAML error policy govern (implement's default `fail` policy routes the run to
+`failed`); it is never a host re-execution. Recovery follows the
+[timed-out implement runbook](execution-workflow.md)'s inline-path equivalent:
+**resume from the partial tree, never restart the stage inline** — no
+`<runId>-implement-partial.md` artifact is written on this path, so the partial working tree
+itself is the recovery input.
+
 **Host-owned interaction:** the host alone executes operator-confirmation actions, owns
 `pause: true`, and surfaces approve/taste/ask decisions. A subagent that discovers missing authority
 or an operator decision returns a blocker; the host pauses at the current state and presents it. The
@@ -129,6 +148,12 @@ subagent form above) to `.spur/run/<run-id>.log`, where `<id>` is the current YA
 log start/failure and the ignored timeout value so an inline run remains auditable without
 fabricating an `AgentRunTracedResult`.
 
+Run-log stamps (task 0727): every appended line is prefixed with an **ISO-8601 UTC** timestamp
+(`YYYY-MM-DDTHH:MM:SSZ`, e.g. `2026-08-31T17:51:11Z`); the exact-template provenance lines above
+keep their exact content after the stamp prefix. This normalization is contractual:
+**bare local-clock stamps are prohibited** — a hand-appended `[stage 12:31]` form mixes timezones
+in one file and makes the run unauditable (task 0726 mixed both forms).
+
 Transition guards are not advisory. Execute the declared guard exactly, in order, with the same
 resolved variables and artifacts. `--no-lifecycle` remains bookkeeping only; the YAML's task checks,
 verdict gate, record step, and done guard all remain authoritative.