@gobing-ai/spur 0.3.71 → 0.3.73

package/config/workflows/task-pipeline.yaml

@@ -49,6 +49,9 @@ failureStates:
 vars:
   wbs: "0000"
   profile: "standard"
+  mode: ""
+  __runId: ""
+  __definitionDigest: ""
   # PATH-independent spur invocation for shell guards/actions. The CLI overrides this
   # at run start (resolveSpurBin); the literal default is a safe fallback so direct/dry
   # runs and `workflow validate` resolve the template. (See AGENTS.md / ADR-026.)
@@ -248,6 +251,34 @@ states:
               echo "FAIL" > "$EVID_FILE";
             fi &&
             exit 0
+      # Proportional route table evaluation (0759 R1/R4). The reason artifact is RUN-scoped, not
+      # wbs-scoped: ADR-107 names `.spur/run/<runId>-route-reason.txt`, and a wbs-scoped path lets
+      # a re-run of the same task overwrite the earlier run's route claim, so the artifact could
+      # not attribute a route to the run that took it (0759 R5). `__runId` is injected by
+      # WorkflowAppService.run(); the wbs fallback keeps a driver-less invocation from writing to
+      # a bare "-route-reason.txt". The log line carries the run id for the same reason — an
+      # unattributed append is log scraping, which R5 explicitly rejects as evidence.
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run .spur/memory &&
+            RUN_ID="$__runId" &&
+            if [ -z "$RUN_ID" ]; then RUN_ID="pipeline-$wbs"; fi &&
+            REASON_FILE=".spur/run/$RUN_ID-route-reason.txt" &&
+            if [ "$mode" = "fast" ]; then
+              echo "fast:evidence complete+consistent" > "$REASON_FILE";
+            elif [ -z "$mode" ]; then
+              echo "safety:standard verification" > "$REASON_FILE";
+            elif [ "$mode" = "unknown" ]; then
+              echo "safety:unknown evidence quality" > "$REASON_FILE";
+            elif [ "$mode" = "conflict" ]; then
+              echo "safety:conflicting evidence" > "$REASON_FILE";
+            else
+              echo "safety:unrecognized evidence (mode=$mode)" > "$REASON_FILE";
+            fi &&
+            printf '%s %s %s\n' "$RUN_ID" "$wbs" "$(cat "$REASON_FILE")"
+            >> .spur/memory/task-pipeline-routes.log &&
+            exit 0
 
   - id: implement
     description: >
@@ -341,8 +372,11 @@ states:
         options:
           # 0710 R4: resolve the spec path, then extract `priority:` from the TASK FILE itself (not the
           # path listing); normalize to upper so requiresDistinctExecutor's exact 'P0'/'P1' match hits.
-          # Missing spec/line -> empty var -> back-compat (no distinctness requirement).
-          command: '$spurBin task path $wbs --json 2>/dev/null | jq -r ".path // .filePath // empty" > ".spur/run/$wbs-taskpath.txt" || true; sed -n "s/^priority:[[:space:]]*//p" "$(cat ".spur/run/$wbs-taskpath.txt" 2>/dev/null)" 2>/dev/null | head -1 | tr -d "[:space:]" | tr "[:lower:]" "[:upper:]" > ".spur/run/$wbs-priority.txt"; exit 0'
+          # 0751 R2: the task path is NOT optional - an unresolved lookup fails
+          # the step (no `|| true`, no forced `exit 0`, no stderr suppression)
+          # instead of degrading the proof to whole-tree-only. The priority read
+          # stays tolerant: a missing line is genuinely optional.
+          command: 'mkdir -p .spur/run; $spurBin task path $wbs --json | jq -r ".path // .filePath // empty" > ".spur/run/$wbs-taskpath.txt"; task_path="$(cat ".spur/run/$wbs-taskpath.txt")"; if [ -z "$task_path" ]; then echo "fail-closed proof chain (0751 R2): task path for $wbs did not resolve - the task spec cannot be folded into the proof digest" >&2; exit 1; fi; sed -n "s/^priority:[[:space:]]*//p" "$task_path" | head -1 | tr -d "[:space:]" | tr "[:lower:]" "[:upper:]" > ".spur/run/$wbs-priority.txt"'
       - kind: file.read.into-var
         options:
           path: .spur/run/${vars.wbs}-taskpath.txt
@@ -588,8 +622,15 @@ states:
         options:
           command: "$spurBin task verdict $wbs --from-answer .spur/run/$wbs-verify-answer.txt"
       # R3 (0703): write the required proof block into the verdict artifact — the digest, the
-      # capture point, and the named per-stage results, each stage carrying the SAME digest
-      # value (prose asserting proof validity is insufficient). Also keeps the flat
+      # certifying run id, the capture point, and the named per-stage results, each stage carrying
+      # the SAME digest value (prose asserting proof validity is insufficient). `runId` closes
+      # 0730 §B.2 (task 0757 R4): without it the verified-outcome fold has to accept ANY linked
+      # run as certifying, so a dry-run probe linked to the same wbs reads as proof of completion.
+      # `definitionDigest` closes 0759 R5: the record binds to the certifying run AND the exact
+      # workflow definition it executed — a stale-definition resume or a definition edited
+      # between run and record cannot certify silently. `__definitionDigest` is injected at run
+      # start (workflow-service.ts) and equals the digest stamped on the run row (task 0603).
+      # Also keeps the flat
       # `proof-input-digest` check row for consumers that read `checks[]`. Soft action + hard
       # guard: a missing/malformed stamp fails the `verify → record` guard below, not this step.
       - kind: shell
@@ -597,8 +638,8 @@ states:
           command: >-
             V=".spur/run/$wbs-verdict.json";
             if [ -f "$V" ] && [ -n "$proofDigest" ]; then
-              jq --arg d "$proofDigest" --arg g "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null || echo UNKNOWN)"
-              '. + {proof: {digest: $d, capturePoint: "quality-gate-entry", stages: {
+              jq --arg d "$proofDigest" --arg r "$__runId" --arg dd "$__definitionDigest" --arg g "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null || echo UNKNOWN)"
+              '. + {proof: {digest: $d, runId: $r, definitionDigest: $dd, capturePoint: "quality-gate-entry", stages: {
                 qualityGate: {status: $g, digest: $d},
                 review: {status: "completed", digest: $d},
                 verification: {status: .verdict, digest: $d}}}}
@@ -701,6 +742,10 @@ states:
         options:
           path: .spur/run/${vars.wbs}-verdict.json
           artifactKind: verify-verdict
+          # 0751 R4: bind the verdict to the run's captured proof digest. `record`
+          # re-captures `proofDigestNow` with expect=proofDigest, so the binding
+          # holds by construction here — making the option non-decorative.
+          proofBinding: current
       - kind: note
         options:
           message: "Pipeline complete for task ${vars.wbs} (done gate cleared)."
@@ -746,13 +791,20 @@ transitions:
     guard:
       kind: always
   # Soft probe branching (declaration order: PASS first, then FAIL, then defense).
+  - from: test
+    to: verify
+    description: Quality gate already green and mode is fast — proportional fast path bypasses review.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS && test "$mode" = fast'
   - from: test
     to: review
-    description: Quality gate already green — one gate run only; skip fixall/recheck.
+    description: Quality gate already green and safety mode — proceed to review.
     guard:
       kind: shell
       options:
-        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS'
+        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS && test "$mode" != fast'
   - from: test
     to: test-fix
     description: Quality gate red — start bounded fixall loop.
@@ -772,13 +824,20 @@ transitions:
     guard:
       kind: always
   # Recheck branching (PASS first; under-max FAIL → fixall again; exhausted → failed).
+  - from: test-recheck
+    to: verify
+    description: Quality gate green after fixall and mode is fast — proportional fast path bypasses review.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS && test "$mode" = fast'
   - from: test-recheck
     to: review
-    description: Quality gate green after fixall — proceed to review.
+    description: Quality gate green after fixall and safety mode — proceed to review.
     guard:
       kind: shell
       options:
-        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS'
+        command: 'test "$(cat .spur/run/$wbs-test-gate.status 2>/dev/null)" = PASS && test "$mode" != fast'
   - from: test-recheck
     to: test-fix
     description: Still red and under qualityGateMaxFixAttempts — another fixall hop.
@@ -863,7 +922,9 @@ transitions:
           test "$(jq -r '.proof.digest // ""' "$V" 2>/dev/null)" = "$proofDigest" &&
           test "$(jq -r '.proof.stages.qualityGate.digest // ""' "$V" 2>/dev/null)" = "$proofDigest" &&
           test "$(jq -r '.proof.stages.review.digest // ""' "$V" 2>/dev/null)" = "$proofDigest" &&
-          test "$(jq -r '.proof.stages.verification.digest // ""' "$V" 2>/dev/null)" = "$proofDigest"
+          test "$(jq -r '.proof.stages.verification.digest // ""' "$V" 2>/dev/null)" = "$proofDigest" &&
+          test "$(jq -r '.proof.runId // ""' "$V" 2>/dev/null)" = "$__runId" &&
+          test "$(jq -r '.proof.definitionDigest // ""' "$V" 2>/dev/null)" = "$__definitionDigest"
   - from: verify
     to: test-fix
     description: >-

package/config/workflows/wrapup-pipeline.yaml

@@ -1,10 +1,16 @@
-# Wrap-up pipeline — post-execution wrap-up for one task or a batch (design §wrapup-pipeline).
+# Wrap-up pipeline — post-execution wrap-up for one task or a batch (design
+# §wrapup-pipeline).
 #
-# Orchestration is configuration (ADR-022 / §3.2): this is YAML over the existing
-# dual-workflow engine — zero new engine code. The pipeline NEVER mutates task status —
-# wrap-up consumes completed tasks and produces learning/metrics/doc artifacts only.
-# Feature transitions go through `spur feature update` so the feature-lifecycle guards
-# apply identically. Branch cleanup is an irreversible HITL gate — it always pauses,
+# Orchestration is configuration (ADR-022 / §3.2): this is YAML over the
+# existing
+# dual-workflow engine — zero new engine code. The pipeline NEVER mutates task
+# status —
+# wrap-up consumes completed tasks and produces learning/metrics/doc artifacts
+# only.
+# Feature transitions go through `spur feature update` so the feature-lifecycle
+# guards
+# apply identically. Branch cleanup is an irreversible HITL gate — it always
+# pauses,
 # even under --auto (Iron Law #6: irreversible action -> surface to human).
 #
 # Shape: start -> task-resolve -> doc-sync -> metrics-record
@@ -14,24 +20,29 @@
 #        (task-resolve with empty list short-circuits to `skipped`).
 #
 # Vars (passed as a JSON object via `--vars`):
-#   tasks    — JSON array of WBS strings, passed as a JSON-encoded STRING value (the CLI
-#              rejects non-string --vars values), e.g. --vars '{"tasks":"[\"0167\"]"}'
+# tasks    — JSON array of WBS strings, passed as a JSON-encoded STRING value
+# (the CLI
+# rejects non-string --vars values), e.g. --vars '{"tasks":"[\"0167\"]"}'
 #   feature  — feature id to advance through legal lifecycle edges (optional)
 #   profile  — set --vars '{"profile":"auto"}' to skip objective confirmations
-#   merge    — set --vars '{"merge":"true"}' to run branch cleanup (irreversible HITL)
+# merge    — set --vars '{"merge":"true"}' to run branch cleanup (irreversible
+# HITL)
 #   spurBin  — PATH-independent spur invocation (overridden by CLI at run start)
 #   agent    — agent for agent.run steps (default: omp)
 #
 # Reliability (aligned with task-pipeline / ADR-043):
-#   - Prefer pure slash commands when a command exists; free-form inputs remain only
+# - Prefer pure slash commands when a command exists; free-form inputs remain
+# only
 #     where capture artifacts (answerFile) have no dedicated slash surface yet.
 #   - doc-sync / metrics-record use expectFile + soft append (empty capture
-#     does not abort wrap-up after prior steps already landed). The doc-sync hop is a
-#     single model query that both repairs doc drift (sp:doc-evolve) and captures
+# does not abort wrap-up after prior steps already landed). The doc-sync hop is
+# a
+# single model query that both repairs doc drift (sp:doc-evolve) and captures
 #     working learnings (task 0607 R2 — one query answers both; count 2 -> 1).
-#   - feature-transition is a soft shell (always exit 0) so a blocked feature sync
+# - feature-transition is a soft shell (always exit 0) so a blocked feature sync
 #     does not abort wrap-up after learnings/metrics already landed.
-#   - branch-cleanup HITL is exhaustive (yes/no/cancel → done; missing answer defense).
+# - branch-cleanup HITL is exhaustive (yes/no/cancel → done; missing answer
+# defense).
 #   - Wrap-up never mutates task status (consumes completed work only).
 
 "$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
@@ -50,17 +61,22 @@ vars:
   merge: "false"
   spurBin: "spur"
   agent: "auto"
+  __runId: ""
+  mode: ""
   stepTimeoutMs: "1800000"
   # Corpus-aware quality gate for the feature-transition hop (R1, task 0625).
-  # The per-task gate (`spur-check`) deliberately excludes corpus-check — the only
+  # 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. 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
+  # (`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.
+  # 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 corpus-check"
@@ -78,13 +94,42 @@ states:
 
   - id: task-resolve
     description: >
-      Validate the task list passed by the wrapper is non-empty. The command wrapper
-      (dev-wrap/dev-wrapall) resolves the task list and passes it as vars.tasks;
-      this state validates it before proceeding. Empty list routes to `skipped`.
+      Validate the task list and evaluate closed proportional routing (0758 R1-R4).
+      Empty list -> skipped; tasks > 0 && mode == fast -> fast-path (metrics-record,
+      bypassing doc-sync); missing/unknown/conflict -> doc-sync (safety-path).
+      Writes bounded machine-readable reason to reasonFile.
     onEnter:
       - kind: note
         options:
-          message: "Resolving task list: ${vars.tasks}"
+          message: "Resolving task list: ${vars.tasks} (proportional mode: ${vars.mode})"
+      # Run-id confinement (0758 R3). The run-scoped reason file is the only route artifact: a
+      # second copy at the fixed path `.spur/run/wrapup-route-reason.txt` had no reader and was
+      # overwritten by whichever run finished last, so a route claim read from it belonged to no
+      # particular run. The log append carries the run id for the same reason — an unattributed
+      # line is log scraping, which R5 rejects as evidence.
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run .spur/memory &&
+            RUN_ID="$__runId" &&
+            if [ -z "$RUN_ID" ]; then RUN_ID="wrapup"; fi &&
+            REASON_FILE=".spur/run/$RUN_ID-route-reason.txt" &&
+            if [ "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -eq 0 ]; then
+              echo "skipped:empty task list" > "$REASON_FILE";
+            elif [ "$mode" = "fast" ]; then
+              echo "fast:evidence complete+consistent" > "$REASON_FILE";
+            elif [ -z "$mode" ]; then
+              echo "safety:missing evidence (mode empty)" > "$REASON_FILE";
+            elif [ "$mode" = "unknown" ]; then
+              echo "safety:unknown evidence quality" > "$REASON_FILE";
+            elif [ "$mode" = "conflict" ]; then
+              echo "safety:conflicting evidence" > "$REASON_FILE";
+            else
+              echo "safety:unrecognized evidence (mode=$mode)" > "$REASON_FILE";
+            fi &&
+            printf '%s %s\n' "$RUN_ID" "$(cat "$REASON_FILE")"
+            >> .spur/memory/wrapup-routes.log &&
+            exit 0
 
   - id: doc-sync
     description: >
@@ -106,7 +151,8 @@ states:
             rules; do not write task/feature corpus. THEN extract working learnings from tasks ${vars.tasks} —
             conventions, errors fixed, patterns, gotchas, grouped by date and task WBS — as raw markdown
             (no fences) and END your final message with that markdown (it is captured to .spur/run/wrapup-learnings.md).
-          # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
+          # Declared Layer-1 role (0538 R2): routing reason beside the agent:
+          # pin.
           role: coder
           answerFile: .spur/run/wrapup-learnings.md
           expectFile: .spur/run/wrapup-learnings.md
@@ -158,12 +204,18 @@ states:
       enters this state when vars.feature is set) and fails loud (dogfood 2026-08-15,
       feature I3: a silent exit 0 made the wrap look complete with no transition).
     onEnter:
-      # Genuinely soft: the terminating `exit 0` must be reached on BOTH branches, so
-      # the sync is chained with `;` — with `&&` a non-zero sync skipped `exit 0` and
-      # aborted the run at this state, discarding the learnings/metrics that already
-      # landed and never reaching branch-cleanup/done (the exact failure the state
-      # description promises against). `feature-sync-bounded.ts` is a Spur-monorepo
-      # path (`spur init` does not scaffold `plugins/sp/`), so seeded projects fall
+      # Genuinely soft: the terminating `exit 0` must be reached on BOTH
+      # branches, so
+      # the sync is chained with `;` — with `&&` a non-zero sync skipped `exit
+      # 0` and
+      # aborted the run at this state, discarding the learnings/metrics that
+      # already
+      # landed and never reaching branch-cleanup/done (the exact failure the
+      # state
+      # description promises against). `feature-sync-bounded.ts` is a
+      # Spur-monorepo
+      # path (`spur init` does not scaffold `plugins/sp/`), so seeded projects
+      # fall
       # back to the plain `spur feature sync` verb.
       # R1 (0625): a feature transition that changed state may have armed a
       # feature-level finding the per-task fast gate (spur-check) never sees.
@@ -221,7 +273,8 @@ states:
       - kind: note
         options:
           message: "Wrap-up pipeline complete for tasks: ${vars.tasks}. Learnings at .spur/memory/learnings.md, metrics at .spur/memory/wrapup-metrics.jsonl."
-      # Checkpoint write: record session state for resume (Phase 4, task 0171 R3)
+      # Checkpoint write: record session state for resume (Phase 4, task 0171
+      # R3)
       - kind: shell
         options:
           command: 'mkdir -p .spur/memory/sessions && echo "checkpoint: wrapup-pipeline done tasks=$tasks ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)" > .spur/memory/sessions/wrapup-checkpoint.md'
@@ -237,25 +290,28 @@ transitions:
     guard:
       kind: always
 
-  # ── task-resolve: non-empty -> doc-sync, empty/unparseable -> skipped ──
-  # `|| echo 0` is load-bearing: a malformed vars.tasks (or a box without `jq`) makes
-  # `jq length` emit nothing, and bare `test "" -gt 0` exits 2 — so BOTH edges failed
-  # and the run died with an opaque `no-passing-transition` instead of skipping. The
-  # trailing `always` edge is the belt-and-braces defense for any other guard fault.
+  # ── task-resolve: proportional route table (task 0758 R1-R4) ──
   - from: task-resolve
-    to: doc-sync
-    description: Task list resolved and non-empty — begin doc-sync.
+    to: skipped
+    description: Task list is empty — skip wrap-up.
     guard:
       kind: shell
       options:
-        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -gt 0'
+        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -eq 0'
   - from: task-resolve
-    to: skipped
-    description: Task list is empty — skip wrap-up.
+    to: metrics-record
+    description: Proportional fast path — complete and consistent evidence bypasses doc-sync.
     guard:
       kind: shell
       options:
-        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -eq 0'
+        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -gt 0 && test "$mode" = fast'
+  - from: task-resolve
+    to: doc-sync
+    description: Proportional safety path — missing/unknown/conflicting evidence routes to full doc-sync.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -gt 0 && test "$mode" != fast'
   - from: task-resolve
     to: skipped
     description: Defense — task list unparseable; skip rather than fail with no-passing-transition.
@@ -270,7 +326,8 @@ transitions:
       kind: always
 
   # ── metrics-record: conditional routing based on feature and merge ──
-  # Declaration order matters: feature-transition is tried first (if feature is set),
+  # Declaration order matters: feature-transition is tried first (if feature is
+  # set),
   # then branch-cleanup (if merge=true but no feature), then done (neither).
   - from: metrics-record
     to: feature-transition
@@ -311,7 +368,8 @@ transitions:
         command: 'test "$merge" != true'
 
   # ── branch-cleanup: HITL exhaustive routing (yes / no / cancel → done) ──
-  # No irreversible git op is wired yet; confirmation is recorded, then wrap completes.
+  # No irreversible git op is wired yet; confirmation is recorded, then wrap
+  # completes.
   - from: branch-cleanup
     to: done
     description: Branch cleanup HITL answered — wrap-up complete.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.71",
+    "version": "0.3.73",
     "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.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",
+        "@gobing-ai/ts-db": "^0.4.56",
+        "@gobing-ai/ts-ai-runner": "^0.4.56",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.56",
+        "@gobing-ai/ts-infra": "^0.4.56",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.56",
+        "@gobing-ai/ts-rule-engine": "^0.4.56",
+        "@gobing-ai/ts-runtime": "^0.4.56",
+        "@gobing-ai/ts-utils": "^0.4.56",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.71",
+    "version": "0.3.73",
     "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,76 @@ 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 command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
+        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 command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
+        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 +403,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 +530,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 +587,7 @@ export {
   printUsage,
   parseArgs,
   main,
+  getSpurHistoryHealth,
   getGitCommits,
   getDateRange,
   getCcusageData,