@gobing-ai/spur 0.3.70 → 0.3.72

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     "plugins": [
         {
             "name": "sp",
-            "version": "0.3.70",
+            "version": "0.3.72",
             "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.72",
     "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.54",
+        "@gobing-ai/ts-ai-runner": "^0.4.54",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.54",
+        "@gobing-ai/ts-infra": "^0.4.54",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.54",
+        "@gobing-ai/ts-rule-engine": "^0.4.54",
+        "@gobing-ai/ts-runtime": "^0.4.54",
+        "@gobing-ai/ts-utils": "^0.4.54",
         "@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.72",
     "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/daily-summary/daily-summary.mjs

@@ -149,6 +149,78 @@ async function getCcusageData(date) {
     return null;
   }
 }
+async function getSpurHistoryHealth(date, dbPath = ".spur/spur.db") {
+  try {
+    const resolvedPath = resolve(process.cwd(), dbPath);
+    if (!existsSync(resolvedPath)) {
+      return null;
+    }
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(resolvedPath, { readonly: true });
+    try {
+      const loopTable = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get("history_board_loop_findings");
+      let loops = [];
+      if (loopTable) {
+        const rows = db.query(`SELECT tool_name, args_digest, repeats, session_id, first_seq, last_seq, started_at
+                         FROM history_board_loop_findings
+                         WHERE started_at IS NULL OR started_at LIKE ?
+                         ORDER BY repeats DESC
+                         LIMIT 20`).all(`${date}%`);
+        loops = rows.map((r) => ({
+          toolName: r.tool_name,
+          argsDigest: r.args_digest || "repeated execution",
+          repeats: r.repeats,
+          sessionId: r.session_id,
+          fromSeq: r.first_seq,
+          toSeq: r.last_seq,
+          wastedTokens: r.repeats * 250
+        }));
+      }
+      let toolCalls = 0;
+      let toolErrors = 0;
+      const toolTable = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get("history_board_tool_5m");
+      if (toolTable) {
+        const stats = db.query(`SELECT SUM(calls) AS calls, SUM(errors) AS errors
+                         FROM history_board_tool_5m
+                         WHERE bucket_start LIKE ?`).get(`${date}%`);
+        toolCalls = stats?.calls ?? 0;
+        toolErrors = stats?.errors ?? 0;
+      }
+      const redundantCalls = loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0);
+      const wastedTokens = loops.reduce((acc, l) => acc + l.wastedTokens, 0);
+      const errorRatePct = toolCalls > 0 ? toolErrors / toolCalls * 100 : 0;
+      const remediationProposals = [];
+      for (const lp of loops.slice(0, 5)) {
+        const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+        const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
+        const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
+        const body = `Finding: ${key}\\nObserved ${lp.repeats} redundant invocations in session ${lp.sessionId} (steps #${lp.fromSeq ?? 1}\u2192#${lp.toSeq ?? lp.repeats}). Wasted tokens: ~${lp.wastedTokens}.`;
+        const command = `spur task create --section "Fix ${cleanTool} repetition loop" --body "${body}"`;
+        remediationProposals.push({ key, title, command });
+      }
+      if (toolCalls > 0 && errorRatePct > 10) {
+        const key = "reliability:tooling:high-error-rate";
+        const title = `Investigate high tool error rate (${errorRatePct.toFixed(1)}%)`;
+        const body = `Finding: ${key}\\nObserved ${toolErrors} errors across ${toolCalls} tool calls (${errorRatePct.toFixed(1)}% error rate) on ${date}.`;
+        const command = `spur task create --section "Investigate tool error rate spikes" --body "${body}"`;
+        remediationProposals.push({ key, title, command });
+      }
+      return {
+        toolCalls,
+        toolErrors,
+        errorRatePct,
+        loops,
+        redundantCalls,
+        wastedTokens,
+        remediationProposals
+      };
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
 async function getGitCommits(date) {
   try {
     const { start, end } = getDateRange(date);
@@ -333,6 +405,49 @@ function generateMarkdown(summary) {
     lines.push(pending);
     lines.push("");
   }
+  if (summary.historyHealth) {
+    const hh = summary.historyHealth;
+    lines.push("## Execution Loops & Health Findings");
+    lines.push("");
+    if (hh.loops.length === 0 && hh.toolCalls === 0) {
+      lines.push("- **Status:** \u2705 Clean \u2014 No execution loops or tool calls recorded for this date.");
+      lines.push("");
+    } else {
+      lines.push("| Metric | Value |");
+      lines.push("|--------|-------|");
+      lines.push(`| Tool Invocations | ${hh.toolCalls.toLocaleString()} |`);
+      lines.push(`| Tool Errors | ${hh.toolErrors.toLocaleString()} (${hh.errorRatePct.toFixed(1)}%) |`);
+      lines.push(`| Detected Loops (Repeats \u2265 3) | ${hh.loops.length} |`);
+      lines.push(`| Redundant Invocations | ${hh.redundantCalls.toLocaleString()} |`);
+      lines.push(`| Estimated Wasted Tokens | ${hh.wastedTokens.toLocaleString()} |`);
+      lines.push("");
+      if (hh.loops.length > 0) {
+        lines.push("### Detected Execution Loops");
+        lines.push("");
+        for (const lp of hh.loops.slice(0, 10)) {
+          const seqInfo = lp.fromSeq && lp.toSeq ? ` (steps #${lp.fromSeq} \u2192 #${lp.toSeq})` : "";
+          const argsHint = lp.argsDigest === "74234e98afe7498fb5daf1f36ac2d78acc339464f950703b8c019892f982b90b" ? "empty/unrecorded arguments" : lp.argsDigest.length > 28 ? `${lp.argsDigest.slice(0, 24)}...` : lp.argsDigest;
+          lines.push(`- \`${lp.toolName || "unknown"}\` \xD7 **${lp.repeats} repeats** in session \`${lp.sessionId}\`${seqInfo}`);
+          lines.push(`  - *Args hint:* \`${argsHint}\` (~${lp.wastedTokens.toLocaleString()} wasted tokens)`);
+        }
+        lines.push("");
+      }
+      if (hh.remediationProposals.length > 0) {
+        lines.push("### Auto-Healing Remediation Proposals");
+        lines.push("");
+        lines.push("To remediate root causes and prevent recurring token waste, execute:");
+        lines.push("");
+        lines.push("```bash");
+        for (const prop of hh.remediationProposals) {
+          lines.push(`# ${prop.title} [${prop.key}]`);
+          lines.push(prop.command);
+          lines.push("");
+        }
+        lines.push("```");
+        lines.push("");
+      }
+    }
+  }
   if (summary.historyReportPath) {
     lines.push("## History Report");
     lines.push("");
@@ -417,6 +532,11 @@ async function buildDailySummary(options) {
   if (gitActivity !== undefined) {
     result.gitActivity = gitActivity;
   }
+  const historyHealth = await getSpurHistoryHealth(options.date);
+  if (historyHealth && (historyHealth.loops.length > 0 || historyHealth.toolCalls > 0)) {
+    result.historyHealth = historyHealth;
+    platforms.push("Spur History");
+  }
   return result;
 }
 async function main() {
@@ -469,6 +589,7 @@ export {
   printUsage,
   parseArgs,
   main,
+  getSpurHistoryHealth,
   getGitCommits,
   getDateRange,
   getCcusageData,