@gobing-ai/spur 0.3.72 → 0.3.74

package/config/workflows/wrapup-pipeline.yaml

@@ -1,48 +1,74 @@
-# 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
 #          -> feature-transition (conditional: if vars.feature set)
 #          -> branch-cleanup (conditional: if vars.merge=true)
 #          -> done
-#        (task-resolve with empty list short-circuits to `skipped`).
+#        task-resolve with a VALIDATED empty list short-circuits to `skipped`;
+#        invalid wrap input, an unresolved/non-completed task, a failed metrics
+#        capture, a failed required sync, or a failed feature gate routes to
+#        `failed` (0770) instead of being absorbed by an always-defensive skip.
 #
 # 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
-#     does not abort wrap-up after learnings/metrics already landed.
-#   - branch-cleanup HITL is exhaustive (yes/no/cancel → done; missing answer defense).
+# - feature-transition is a soft shell (always exit 0); a failed required sync
+#     or feature gate records FAIL and routes to `failed` instead of claiming
+#     success (0770).
+# - 0770 truthful outcomes: vars.tasks is parsed and validated ONCE at
+#     task-resolve (JSON array of non-empty WBS strings, every member resolved
+#     via `task show` to a completed status); siblings consume the normalized
+#     run-scoped artifact and never re-parse raw input (malformed input can no
+#     longer be silently re-interpreted as an empty list). All captures are
+#     run-scoped under .spur/run/<runId>-wrapup-*; a lookup failure is
+#     recorded, never silently omitted as success.
+# - branch-cleanup HITL is exhaustive (yes/no/cancel → done; missing answer
+# defense) and consent-only: it records the decision, performs no git op.
 #   - Wrap-up never mutates task status (consumes completed work only).
 
 "$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
 kind: state-machine
 name: wrapup-pipeline
+version: "1"
 description: "Post-execution wrap-up: doc-sync (doc drift + learning capture), metrics, feature-transition, branch-cleanup"
 iterationBound: 10
 initialState: start
 terminalStates:
   - done
   - skipped
+  - failed
+failureStates:
+  - failed
 vars:
   tasks: "[]"
   feature: ""
@@ -50,20 +76,14 @@ 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
-  # 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
-  # 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.
+  # Recheck the affected feature after sync (D61 / ADR-108), not the corpus
+  # or full code suite. Explicit caller overrides remain supported.
   # 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"
+  featureGateCmd: '$spurBin feature check "$feature"'
   __hitlAnswer: ""
 
 states:
@@ -78,13 +98,92 @@ 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 ONCE and evaluate closed proportional routing (0758
+      R1-R4). Validation (0770): vars.tasks must be a JSON array of non-empty
+      WBS strings, deduplicated in first-seen order, and every member must
+      resolve via `spur task show` to a completed status (done/cancelled).
+      Invalid input or an unresolved/non-completed task records FAIL (reason
+      into the run-scoped reason file) and routes to `failed`; siblings consume
+      the normalized run-scoped artifact .spur/run/<runId>-wrapup-tasks.json
+      and never re-parse raw input. A validated 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
+      # 0770 truthful input: parse and validate vars.tasks exactly once, here.
+      # Malformed JSON, a non-array, a non-string or empty entry, an unresolved
+      # task, or a task not at a completed status records FAIL (routed to
+      # `failed` by the first declared edge) and is never re-interpreted as an
+      # empty list by a later sibling guard. The normalized, deduplicated list
+      # is persisted run-scoped; metrics/doc siblings only ever read it.
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run &&
+            RUN_ID="$__runId" &&
+            if [ -z "$RUN_ID" ]; then
+              echo "task-resolve: __runId is empty — refusing the legacy fixed-path fallback" >&2;
+              exit 1;
+            fi &&
+            REASON_FILE=".spur/run/$RUN_ID-route-reason.txt" &&
+            STATUS_FILE=".spur/run/$RUN_ID-wrapup-resolve.status" &&
+            TASKS_FILE=".spur/run/$RUN_ID-wrapup-tasks.json" &&
+            if ! printf '%s' "$tasks" | jq -e 'type == "array" and all(.[]; type == "string" and length > 0)' > /dev/null 2>&1; then
+              echo "task-resolve: tasks must be a JSON array of non-empty WBS strings" >&2;
+              echo "failed:tasks is not a JSON array of non-empty WBS strings" > "$REASON_FILE";
+              printf 'FAIL\n' > "$STATUS_FILE";
+            else
+              printf '%s' "$tasks" | jq -c 'reduce .[] as $w ([]; if any(.[]; . == $w) then . else . + [$w] end)' > "$TASKS_FILE";
+              RESOLVE_RC=0;
+              for wbs in $(jq -r '.[]' "$TASKS_FILE"); do
+                TASK_JSON=$($spurBin task show "$wbs" --json 2>/dev/null || true);
+                TASK_STATUS=$(printf '%s' "$TASK_JSON" | jq -r '.frontmatter.status // .status // empty' 2>/dev/null || true);
+                if [ "$TASK_STATUS" != "done" ] && [ "$TASK_STATUS" != "cancelled" ]; then
+                  STATUS_DISPLAY="$TASK_STATUS";
+                  if [ -z "$STATUS_DISPLAY" ]; then STATUS_DISPLAY=unresolved; fi;
+                  echo "task-resolve: task $wbs did not resolve to a completed status (status=$STATUS_DISPLAY)" >&2;
+                  RESOLVE_RC=1;
+                fi;
+              done;
+              if [ "$RESOLVE_RC" -eq 0 ]; then
+                printf 'PASS\n' > "$STATUS_FILE";
+              else
+                echo "failed:unresolved or non-completed task (see $TASKS_FILE)" > "$REASON_FILE";
+                printf 'FAIL\n' > "$STATUS_FILE";
+              fi;
+            fi;
+            exit 0
 
   - id: doc-sync
     description: >
@@ -105,71 +204,92 @@ states:
             docs/00_ADR.md, docs/03_ARCHITECTURE.md, docs/04_DESIGN.md, docs/design/* per constitution edit
             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.
+            (no fences) and END your final message with that markdown (it is captured to the
+            run-scoped .spur/run/${vars.__runId}-wrapup-learnings.md).
+          # 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
+          answerFile: .spur/run/${vars.__runId}-wrapup-learnings.md
+          expectFile: .spur/run/${vars.__runId}-wrapup-learnings.md
           timeoutMs: ${vars.stepTimeoutMs}
       - kind: shell
         options:
           command: >-
-            mkdir -p .spur/memory &&
-            if test -s .spur/run/wrapup-learnings.md; then
-              cat .spur/run/wrapup-learnings.md >> .spur/memory/learnings.md &&
+            mkdir -p .spur/run .spur/memory &&
+            LEARNINGS_FILE=".spur/run/$__runId-wrapup-learnings.md" &&
+            if test -s "$LEARNINGS_FILE"; then
+              cat "$LEARNINGS_FILE" >> .spur/memory/learnings.md &&
               printf '\n' >> .spur/memory/learnings.md;
             else
-              echo "wrapup: learning capture missing or empty at $PWD/.spur/run/wrapup-learnings.md - append skipped" >&2;
+              echo "wrapup: learning capture missing or empty at $PWD/$LEARNINGS_FILE - append skipped" >&2;
             fi &&
             exit 0
 
   - id: metrics-record
     description: >
       Append one JSONL row per task to .spur/memory/wrapup-metrics.jsonl deterministically.
+      Reads ONLY the normalized run-scoped task list written by task-resolve (0770):
+      a lookup failure for any member records FAIL and routes to `failed` — a
+      missing metrics row is never silently absorbed as success.
     onEnter:
       - kind: shell
         options:
           command: >-
-            mkdir -p .spur/memory &&
-            printf '%s' "$tasks" | jq -r '(if type == "string" then (try fromjson catch .) else . end) | if type == "array" then .[] else empty end' |
-            while IFS= read -r wbs; do
-              if [ -n "$wbs" ]; then
-                task_json=$($spurBin task show "$wbs" --json 2>/dev/null || true);
-                if [ -n "$task_json" ]; then
-                  feat=$(printf '%s' "$task_json" | jq -r '.frontmatter.feature_id // .feature_id // empty' 2>/dev/null || true);
-                  stat=$(printf '%s' "$task_json" | jq -r '.frontmatter.status // .status // "unknown"' 2>/dev/null || true);
-                  verdict="UNKNOWN";
-                  if [ -f ".spur/run/$wbs-verdict.json" ]; then
-                    v=$(jq -r '.verdict // "UNKNOWN"' ".spur/run/$wbs-verdict.json" 2>/dev/null || true);
-                    if [ -n "$v" ]; then verdict="$v"; fi;
-                  fi;
-                  ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ");
-                  printf '{"wbs":"%s","feature_id":"%s","status":"%s","verdict":"%s","timestamp":"%s"}\n' "$wbs" "$feat" "$stat" "$verdict" "$ts" >> .spur/memory/wrapup-metrics.jsonl;
+            mkdir -p .spur/run .spur/memory &&
+            STATUS_FILE=".spur/run/$__runId-wrapup-metrics.status" &&
+            TASKS_FILE=".spur/run/$__runId-wrapup-tasks.json" &&
+            METRICS_RC=0 &&
+            for wbs in $(jq -r '.[]' "$TASKS_FILE" 2>/dev/null); do
+              task_json=$($spurBin task show "$wbs" --json 2>/dev/null || true);
+              if [ -n "$task_json" ]; then
+                feat=$(printf '%s' "$task_json" | jq -r '.frontmatter.feature_id // .feature_id // empty' 2>/dev/null || true);
+                stat=$(printf '%s' "$task_json" | jq -r '.frontmatter.status // .status // "unknown"' 2>/dev/null || true);
+                verdict="UNKNOWN";
+                if [ -f ".spur/run/$wbs-verdict.json" ]; then
+                  v=$(jq -r '.verdict // "UNKNOWN"' ".spur/run/$wbs-verdict.json" 2>/dev/null || true);
+                  if [ -n "$v" ]; then verdict="$v"; fi;
                 fi;
+                ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ");
+                printf '{"wbs":"%s","feature_id":"%s","status":"%s","verdict":"%s","timestamp":"%s"}\n' "$wbs" "$feat" "$stat" "$verdict" "$ts" >> .spur/memory/wrapup-metrics.jsonl;
+              else
+                echo "metrics-record: task $wbs did not resolve — recording FAIL instead of silently omitting its metrics row" >&2;
+                METRICS_RC=1;
               fi;
-            done &&
+            done;
+            if [ "$METRICS_RC" -eq 0 ]; then printf 'PASS\n' > "$STATUS_FILE"; else printf 'FAIL\n' > "$STATUS_FILE"; fi;
             exit 0
 
   - id: feature-transition
     description: >
       If vars.feature is set, sync feature status via bounded feature-sync-bounded
-      (0411). Soft shell — blocked/failed sync must not abort wrap-up after metrics.
-      Empty vars.feature is NOT a blocked sync but a mis-invocation (the engine only
-      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).
+      (0411). Soft shell — the run is never aborted after learnings/metrics
+      landed; instead (0770) a failed required sync or a failed feature gate
+      records FAIL in the run-scoped sync status and routes to `failed`, and a
+      successful sync that applied no transition is reported as an explicit
+      no-change. Empty vars.feature is NOT a blocked sync but a mis-invocation
+      (the engine only 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.
-      # Run the corpus-aware gate after an applied sync OR a non-zero exit that
-      # may follow a partial multi-hop transition, then report PASS/FAIL. Soft
-      # by design: the operator decides, and wrap-up never hard-fails here.
+      # R1 (0625): a feature transition that changed state may have left
+      # cross-task fallout the per-task fast gates never see. Run the
+      # affected-feature gate (featureGateCmd) after an
+      # applied sync OR a non-zero exit that may follow a partial multi-hop
+      # transition, then report PASS/FAIL. Soft by design: the operator
+      # decides, and wrap-up never hard-fails here.
       # NOTE: do not add
       # `#` comments INSIDE the folded shell string — YAML `>-` folds them onto
       # the following statement line and comments it out.
@@ -189,24 +309,41 @@ states:
             fi);
             SYNC_RC=$?;
             printf '%s\n' "$SYNC_OUTPUT";
-            APPLIED=$(printf '%s' "$SYNC_OUTPUT" | jq -r '.applied // false' 2>/dev/null || echo false);
+            if printf '%s' "$SYNC_OUTPUT" | jq -e 'has("applied")' > /dev/null 2>&1; then
+              APPLIED=$(printf '%s' "$SYNC_OUTPUT" | jq -r '.applied // false' 2>/dev/null || echo false);
+            else
+              APPLIED="invalid";
+            fi;
+            GATE="skipped";
             if [ "$APPLIED" = "true" ] || [ "$SYNC_RC" -ne 0 ]; then
-              echo "feature-transition: sync applied or failed after a possible partial transition for $feature — running corpus-aware gate: $featureGateCmd";
+              echo "feature-transition: sync applied or failed after a possible partial transition for $feature — running feature gate: $featureGateCmd";
               if sh -c "$featureGateCmd"; then
-                echo "feature-transition: corpus-aware gate PASS for feature $feature";
+                GATE="PASS";
+                echo "feature-transition: feature gate PASS for feature $feature";
               else
-                echo "feature-transition: corpus-aware gate FAIL for feature $feature — inspect findings before reporting the transition complete" >&2;
+                GATE="FAIL";
+                echo "feature-transition: feature gate FAIL for feature $feature — inspect findings before reporting the transition complete" >&2;
               fi;
             else
-              echo "feature-transition: sync did not apply a transition (rc=$SYNC_RC, applied=$APPLIED) — corpus-aware gate skipped";
+              echo "feature-transition: sync did not apply a transition (rc=$SYNC_RC, applied=$APPLIED) — feature gate skipped (explicit no-change)";
+            fi;
+            SYNC_STATUS="PASS";
+            if [ "$SYNC_RC" -ne 0 ] || [ "$GATE" = "FAIL" ] || [ "$APPLIED" = "invalid" ]; then SYNC_STATUS="FAIL"; fi;
+            if [ "$SYNC_STATUS" = "PASS" ]; then
+              printf 'PASS\n' > ".spur/run/$__runId-wrapup-sync.status";
+            else
+              printf 'FAIL\n' > ".spur/run/$__runId-wrapup-sync.status";
             fi;
             exit 0
 
   - id: branch-cleanup
     description: >
-      Irreversible HITL gate. If vars.merge=true, dispatch branch cleanup (merge or
-      delete). This gate ALWAYS pauses — even under --auto — because branch operations
-      are irreversible (Auto-Decision Principle #6). The operator must explicitly confirm.
+      Irreversible-operation HITL gate, consent-only (0770). If vars.merge=true,
+      branch cleanup (merge or delete) is a candidate — but this gate records
+      the operator decision and performs NO git operation itself; an operator
+      or a separate approved surface executes any actual merge/delete. This
+      gate ALWAYS pauses — even under --auto — because branch operations are
+      irreversible (Auto-Decision Principle #6).
     pause: true
     onEnter:
       - kind: hitl.confirm
@@ -215,13 +352,15 @@ states:
 
   - id: done
     description: >
-      Terminal — wrap-up complete. Output summary: tasks wrapped, learnings captured,
-      metrics recorded, feature advanced (if applicable), branch cleaned (if applicable).
+      Terminal — wrap-up complete. Summary: tasks wrapped, learnings captured,
+      metrics recorded, feature advanced or explicitly no-change (if applicable),
+      branch-cleanup decision recorded (consent-only; no git operation performed).
     onEnter:
       - 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)
+          message: "Wrap-up pipeline complete for tasks: ${vars.tasks}. Learnings at .spur/memory/learnings.md, metrics at .spur/memory/wrapup-metrics.jsonl. Branch cleanup: consent recorded only (merge=${vars.merge}); no git operation performed by wrap-up."
+      # 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'
@@ -229,6 +368,13 @@ states:
   - id: skipped
     description: Terminal — wrap-up skipped (empty task list or operator abort).
 
+  - id: failed
+    description: >
+      Terminal — wrap-up failed (0770): invalid wrap input, an unresolved or
+      non-completed task, a failed metrics capture, a failed required sync, or
+      a failed feature gate. Already-written artifacts (learnings, metrics
+      rows, route reason) are preserved; nothing is rolled back.
+
 transitions:
   # ── start -> task-resolve ──
   - from: start
@@ -237,18 +383,17 @@ 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: validation fail + proportional route table (0758 R1-R4, 0770) ──
   - from: task-resolve
-    to: doc-sync
-    description: Task list resolved and non-empty — begin doc-sync.
+    to: failed
+    description: >
+      Validation FAIL (0770): malformed wrap input, a non-string/empty entry, an
+      unresolved or non-completed task, or an empty __runId. Declared before the
+      route edges so invalid input can never be absorbed by the empty-list skip.
     guard:
       kind: shell
       options:
-        command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -gt 0'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-resolve.status 2>/dev/null)" = FAIL'
   - from: task-resolve
     to: skipped
     description: Task list is empty — skip wrap-up.
@@ -257,8 +402,24 @@ transitions:
       options:
         command: 'test "$(echo "$tasks" | jq length 2>/dev/null || echo 0)" -eq 0'
   - from: task-resolve
-    to: skipped
-    description: Defense — task list unparseable; skip rather than fail with no-passing-transition.
+    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)" -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: failed
+    description: >
+      Defense (0770) — no PASS/FAIL resolve status (shell crashed or never ran):
+      route to `failed` rather than claiming a skip.
     guard:
       kind: always
 
@@ -269,49 +430,71 @@ transitions:
     guard:
       kind: always
 
-  # ── metrics-record: conditional routing based on feature and merge ──
-  # Declaration order matters: feature-transition is tried first (if feature is set),
-  # then branch-cleanup (if merge=true but no feature), then done (neither).
+  # ── metrics-record: fail edge, then conditional routing (feature → merge → done) ──
+  # Declaration order matters: the FAIL edge is tried first (0770), then
+  # feature-transition (if feature is set), then branch-cleanup (if merge=true
+  # but no feature), then done (neither). Routing edges additionally require
+  # the metrics status PASS so a missing status can never claim success.
+  - from: metrics-record
+    to: failed
+    description: >
+      Metrics capture failed for at least one task — a missing metrics row is
+      recorded as failure, never silently omitted as success (0770).
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat .spur/run/$__runId-wrapup-metrics.status 2>/dev/null)" = FAIL'
   - from: metrics-record
     to: feature-transition
-    description: Feature id is set — advance feature through legal lifecycle edges.
+    description: Metrics PASS and feature id is set — advance feature through legal lifecycle edges.
     guard:
       kind: shell
       options:
-        command: 'test -n "$feature"'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-metrics.status 2>/dev/null)" = PASS && test -n "$feature"'
   - from: metrics-record
     to: branch-cleanup
-    description: No feature id, but merge is requested — go to branch cleanup.
+    description: Metrics PASS, no feature id, but merge is requested — go to branch cleanup.
     guard:
       kind: shell
       options:
-        command: 'test -z "$feature" && test "$merge" = true'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-metrics.status 2>/dev/null)" = PASS && test -z "$feature" && test "$merge" = true'
   - from: metrics-record
     to: done
-    description: No feature id and no merge — wrap-up is done.
+    description: Metrics PASS, no feature id and no merge — wrap-up is done.
     guard:
       kind: shell
       options:
-        command: 'test -z "$feature" && test "$merge" != true'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-metrics.status 2>/dev/null)" = PASS && test -z "$feature" && test "$merge" != true'
 
-  # ── feature-transition: -> branch-cleanup (if merge) or done ──
+  # ── feature-transition: fail edge, then branch-cleanup (if merge) or done ──
+  - from: feature-transition
+    to: failed
+    description: >
+      Required synchronization failed (0770): non-zero sync exit, an invalid
+      sync result, or a failed feature gate. The failed status carries the
+      actual reason; already-written learnings/metrics stay on disk.
+    guard:
+      kind: shell
+      options:
+        command: 'test "$(cat .spur/run/$__runId-wrapup-sync.status 2>/dev/null)" = FAIL'
   - from: feature-transition
     to: branch-cleanup
-    description: Feature advanced — merge is requested.
+    description: Sync PASS — merge is requested.
     guard:
       kind: shell
       options:
-        command: 'test "$merge" = true'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-sync.status 2>/dev/null)" = PASS && test "$merge" = true'
   - from: feature-transition
     to: done
-    description: Feature advanced — no merge requested.
+    description: Sync PASS — no merge requested.
     guard:
       kind: shell
       options:
-        command: 'test "$merge" != true'
+        command: 'test "$(cat .spur/run/$__runId-wrapup-sync.status 2>/dev/null)" = PASS && 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.72",
+    "version": "0.3.74",
     "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.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",
+        "@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.72",
+    "version": "0.3.74",
     "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

@@ -194,15 +194,13 @@ async function getSpurHistoryHealth(date, dbPath = ".spur/spur.db") {
         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}"`;
+        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 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}"`;
+        const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
         remediationProposals.push({ key, title, command });
       }
       return {