@gobing-ai/spur 0.3.80 → 0.3.82

package/config/workflows/wayfinder-resolution.yaml

@@ -60,18 +60,10 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 8 lines — task check + show capture the investigate input bundle in the
+          # same soft probe; show must stay verbatim (it IS the bundle downstream reads).
           command: >-
-            mkdir -p .spur/run &&
-            set +e &&
-            $spurBin task check $wbs; check_rc=$?;
-            $spurBin task show $wbs --json > .spur/run/$__runId-wayfinder-input.json; show_rc=$?;
-            set -e &&
-            if [ "$check_rc" -eq 0 ] && [ "$show_rc" -eq 0 ]; then
-              printf 'PASS\n' > .spur/run/$__runId-wayfinder-precheck.status;
-            else
-              printf 'FAIL\n' > .spur/run/$__runId-wayfinder-precheck.status;
-            fi &&
-            exit 0
+            mkdir -p .spur/run; $spurBin task check $wbs; c=$?; $spurBin task show $wbs --json > .spur/run/$__runId-wayfinder-input.json && [ "$c" -eq 0 ] && printf 'PASS\n' > .spur/run/$__runId-wayfinder-precheck.status || printf 'FAIL\n' > .spur/run/$__runId-wayfinder-precheck.status; exit 0
       - kind: note
         options:
           message: "Wayfinder resolution started for task ${vars.wbs} (mode=${vars.resolutionMode}, evidence=${vars.evidencePolicy}); no code implementation pipeline is permitted."
@@ -86,22 +78,10 @@ states:
           # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
           role: planner
           mode: text
+          # (e) 0825: bounded reference-reading prompt (260 chars) — the authoring contract
+          # lives in the skill reference sp:wayfinder references/pipeline-resolution.md.
           input: >-
-            Resolve task ${vars.wbs} in resolution mode ${vars.resolutionMode} using the prepared
-            local bundle `.spur/run/${vars.__runId}-wayfinder-input.json` and only local shell/file
-            reads plus the `spur` CLI; do not use network search or MCP tools. Do not
-            invoke task-pipeline.yaml, /sp:dev-run, /sp:dev-runall, or code implementation.
-            Read the task file, map its existing Requirements and Acceptance Criteria to the
-            existing Design/Plan/References, then author concise Solution, Testing, and Review
-            sections through `spur task update --section --from-file`. Preserve the research
-            boundary. Finish with a short summary and stop. Evidence policy: ${vars.evidencePolicy}.
-
-            Evidence-anchor contract (mandatory — 0299 R1 line-anchor rule): when the task's
-            evidence lives in a shared evidence file, anchor every Solution/Testing `file:line`
-            citation truthfully — resolve the section's real start line with
-            `grep -n "^## <wbs> " <evidence-file>` and cite that exact line. NEVER copy a line
-            number from another ticket's example; each WBS anchors to its own section. Before
-            finishing, re-read each cited line and confirm it names the requirement's subject.
+            Resolve wayfinder task ${vars.wbs} per the sp:wayfinder skill (references/pipeline-resolution.md). Mode ${vars.resolutionMode}; evidence policy ${vars.evidencePolicy}; bundle .spur/run/${vars.__runId}-wayfinder-input.json. Finish with a short summary and stop.
           answerFile: .spur/run/${vars.__runId}-wayfinder-answer.md
           expectFile: .spur/run/${vars.__runId}-wayfinder-answer.md
           timeoutMs: ${vars.stepTimeoutMs}
@@ -121,6 +101,8 @@ states:
       # proof digest via taskFile; a silent miss would degrade the proof to tree-only.
       - kind: shell
         options:
+          # (e) 0825: 6 lines — fail-closed lookup feeds every downstream artifact name;
+          # folding a silent miss into the digest would fake tree coverage.
           command: >-
             set -e;
             task_path="$($spurBin task path $wbs --json | jq -r '.path // .filePath // empty')";
@@ -155,6 +137,8 @@ states:
           command: "$spurBin task verdict $wbs --from-answer .spur/run/$__runId-wayfinder-verify-answer.txt"
       - kind: shell
         options:
+          # (e) 0825: 6 lines — stamp shell freezes the proof digest + capture point into the
+          # verdict before it is registered; the closing guard compares against this stamp.
           command: >-
             V=".spur/run/$wbs-verdict.json";
             if [ -f "$V" ] && [ -n "$proofDigest" ]; then
@@ -246,6 +230,8 @@ transitions:
     guard:
       kind: shell
       options:
+        # (e) 0825: 5-line guard — approval + digest-bracket + verdict PASS must all hold
+        # before record; dropping any operand would let a stale proof auto-record.
         command: >-
           test "$approval" = auto &&
           test -n "$proofDigest" &&

package/config/workflows/wrapup-pipeline.yaml

@@ -130,91 +130,36 @@ states:
       - kind: note
         options:
           message: "Resolving task list: ${vars.tasks} (proportional mode: ${vars.mode})"
-      # 0770/0783 truthful input: parse and validate vars.tasks exactly once,
-      # here and only here. Malformed JSON, a non-array, a non-string entry,
-      # whitespace or a non-canonical WBS (anything but four digits), a missing
-      # __runId, an unresolved task, a failed or malformed lookup, 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; the route writer, metrics, prompts, notes and guards only
-      # ever read that capture.
+      # (d) wrapup-steps.ts resolve owns task capture and status resolution (0824);
+      # the wrapper only locates it (monorepo first, registered twin under node) and
+      # fails closed, writing FAIL for the failed defense edge — never PASS.
       - 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 test("^[0-9]{4}$"))' > /dev/null 2>&1; then
-              echo "task-resolve: tasks must be a JSON array of canonical four-digit WBS strings (whitespace is rejected, not trimmed)" >&2;
-              echo "failed:tasks is not a JSON array of canonical four-digit WBS strings" > "$REASON_FILE";
-              printf 'FAIL\n' > "$STATUS_FILE";
+            if [ -f plugins/sp/scripts/wrapup-steps.ts ]; then
+              bun plugins/sp/scripts/wrapup-steps.ts resolve;
+            elif W="$(superskill script path sp wrapup-steps.mjs 2>/dev/null)" && [ -f "$W" ]; then
+              node "$W" resolve;
             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
-      # Route reason writer (0758 R3/R4 run-attribution pins intact). Runs AFTER
-      # validation and reads ONLY the validated run-scoped capture — never raw
-      # vars.tasks (0783 R2/R5); the fixed-path fallback is gone because
-      # validation refuses an empty __runId above. A FAIL resolve exits without
-      # writing: the failed reason written by validation stands, and the skip
-      # reason can never mask it. A missing/corrupted capture yields N=-1 and
-      # no skipped claim; the failed defense edge owns the run.
+              echo "wrapup-steps failed closed — script not found — run 'superskill install sp'" >&2;
+              printf 'FAIL\n' > ".spur/run/$__runId-wrapup-resolve.status";
+            fi
+      # (e) route-reason writer: one jq table lookup over the mode var over the
+      # validated capture; workflow-local routing glue (0824). Runs AFTER validation
+      # and reads ONLY .spur/run/<runId>-wrapup-tasks.json — never raw vars.tasks
+      # (0783 R2/R5). A FAIL resolve exits without writing: the failed reason written
+      # by validation stands, and the skip reason can never mask it. A missing or
+      # corrupted capture fails the jq lookup (no skipped claim can be invented);
+      # the failed defense edge owns the run.
       - kind: shell
         options:
           command: >-
-            mkdir -p .spur/run .spur/memory &&
-            RUN_ID="$__runId" &&
-            if [ -z "$RUN_ID" ]; then
-              echo "task-resolve: __runId is empty — refusing to write a route reason" >&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 [ "$(cat "$STATUS_FILE" 2>/dev/null)" = FAIL ]; then
-              exit 0;
-            fi &&
-            N=$(jq length "$TASKS_FILE" 2>/dev/null || echo -1) &&
-            if [ "$N" -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
+            mkdir -p .spur/run .spur/memory; RUN_ID="$__runId"; case "$RUN_ID" in '') echo "task-resolve: __runId is empty — refusing to write a route reason" >&2; exit 1 ;; esac;
+            REASON_FILE=".spur/run/$RUN_ID-route-reason.txt"; case "$(cat ".spur/run/$RUN_ID-wrapup-resolve.status" 2>/dev/null)" in FAIL) exit 0 ;; esac;
+            N=$(jq length ".spur/run/$RUN_ID-wrapup-tasks.json" 2>/dev/null);
+            jq -rn --arg m "$mode" --arg n "$N" 'if $n == "0" then "skipped:empty task list" else {"fast":"fast:evidence complete+consistent","":"safety:missing evidence (mode empty)","unknown":"safety:unknown evidence quality","conflict":"safety:conflicting evidence"}[$m] // "safety:unrecognized evidence (mode=\($m))" end' > "$REASON_FILE";
+            printf '%s %s\n' "$RUN_ID" "$(cat "$REASON_FILE")" >> .spur/memory/wrapup-routes.log
 
   - id: doc-sync
     description: >
@@ -227,6 +172,8 @@ states:
       a non-empty capture before the append; append is best-effort soft (empty capture
       skips without aborting wrap-up).
     onEnter:
+      # (warn) free-form prompt: no /sp:doc-evolve command surface yet (ADR-043
+      # residual, 0607 R2 one-query merge); capture is bounded by expectFile.
       - kind: agent.run
         options:
           agent: ${vars.agent}
@@ -245,6 +192,8 @@ states:
           answerFile: .spur/run/${vars.__runId}-wrapup-learnings.md
           expectFile: .spur/run/${vars.__runId}-wrapup-learnings.md
           timeoutMs: ${vars.stepTimeoutMs}
+      # (warn) learnings append is intentionally soft (empty capture skips
+      # without aborting wrap-up, 0607 R2).
       - kind: shell
         options:
           command: >-
@@ -270,40 +219,20 @@ states:
       is UNKNOWN telemetry, never proof of completion; previously written valid rows
       survive a failure.
     onEnter:
+      # (d) wrapup-steps.ts metrics owns the JSONL row append (0824); the wrapper
+      # only locates it and fails closed — FAIL, never a silent skip.
       - kind: shell
         options:
           command: >-
-            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 &&
-            if ! jq -e 'type == "array" and all(.[]; type == "string" and test("^[0-9]{4}$"))' "$TASKS_FILE" > /dev/null 2>&1; then
-              echo "metrics-record: run-scoped task capture missing, corrupted or non-canonical — refusing to record metrics" >&2;
-              printf 'FAIL\n' > "$STATUS_FILE";
+            mkdir -p .spur/run &&
+            if [ -f plugins/sp/scripts/wrapup-steps.ts ]; then
+              bun plugins/sp/scripts/wrapup-steps.ts metrics;
+            elif W="$(superskill script path sp wrapup-steps.mjs 2>/dev/null)" && [ -f "$W" ]; then
+              node "$W" metrics;
             else
-              for wbs in $(jq -r '.[]' "$TASKS_FILE"); do
-                task_json=$($spurBin task show "$wbs" --json 2>/dev/null || true);
-                if printf '%s' "$task_json" | jq -e '(.frontmatter.status // .status) != null' > /dev/null 2>&1; then
-                  feat=$(printf '%s' "$task_json" | jq -r '.frontmatter.feature_id // .feature_id // ""');
-                  stat=$(printf '%s' "$task_json" | jq -r '.frontmatter.status // .status // "unknown"');
-                  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");
-                  if ! jq -cn --arg wbs "$wbs" --arg feature_id "$feat" --arg status "$stat" --arg verdict "$verdict" --arg timestamp "$ts" '{wbs:$wbs, feature_id:$feature_id, status:$status, verdict:$verdict, timestamp:$timestamp}' >> .spur/memory/wrapup-metrics.jsonl; then
-                    echo "metrics-record: metrics append failed for task $wbs — recording FAIL instead of claiming the row landed" >&2;
-                    METRICS_RC=1;
-                  fi;
-                else
-                  echo "metrics-record: task $wbs lookup failed or was malformed — recording FAIL instead of silently omitting its metrics row" >&2;
-                  METRICS_RC=1;
-                fi;
-              done;
-              if [ "$METRICS_RC" -eq 0 ]; then printf 'PASS\n' > "$STATUS_FILE"; else printf 'FAIL\n' > "$STATUS_FILE"; fi;
-            fi;
-            exit 0
+              echo "wrapup-steps failed closed — script not found — run 'superskill install sp'" >&2;
+              printf 'FAIL\n' > ".spur/run/$__runId-wrapup-metrics.status";
+            fi
 
   - id: feature-transition
     description: >
@@ -320,94 +249,24 @@ states:
       (the engine only enters this state when vars.feature is set) and fails
       loud (dogfood 2026-08-15, feature I3).
     onEnter:
-      # The terminating `exit 0` must be reached on every branch — the sync is
-      # chained with `;`, because `&&` would abort the state, discarding the
-      # learnings/metrics that already landed. Soft TERMINATION is not soft
-      # TRUTH: the result is classified per 0783 R4 and only a verified sync
-      # writes PASS. `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 left
-      # cross-task fallout the per-task fast gates never see. The
-      # affected-feature gate (featureGateCmd) runs after an applied sync OR a
-      # non-zero exit that may follow a partial multi-hop transition. It is a
-      # diagnostic only: a gate PASS can never convert a failed sync into
-      # success, and a gate FAIL fails the step (0770 failure routing).
-      # NOTE: do not add
-      # `#` comments INSIDE the folded shell string — YAML `>-` folds them onto
-      # the following statement line and comments it out.
+      # (d) wrapup-steps.ts feature-transition owns the bounded sync, observation
+      # and the gate (0824); the wrapper only locates it and fails closed. The
+      # script terminates exit 0 on every path so artifacts that already landed
+      # are never discarded; soft TERMINATION is not soft TRUTH — only a verified
+      # sync writes PASS (0783 R4). A gate PASS can never convert a failed sync
+      # into success, and a gate FAIL fails the step (0770 failure routing).
       - kind: shell
         options:
           command: >-
             mkdir -p .spur/run &&
-            if [ -z "$feature" ]; then
-              echo "feature-transition: vars.feature is empty — refusing no-op feature sync (mis-invocation, not a blocked sync)" >&2;
-              exit 1;
-            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);
-            SYNC_RC=$?;
-            printf '%s\n' "$SYNC_OUTPUT";
-            OBSERVED=$($spurBin feature show "$feature" --json 2>/dev/null | jq -r '.status // .frontmatter.status // empty' 2>/dev/null || true);
-            if [ -z "$OBSERVED" ]; then OBSERVED=unreadable; fi;
-            APPLIED=unreadable;
-            SYNC_OK=0;
-            REASON="";
-            if [ "$SYNC_RC" -ne 0 ]; then
-              REASON="sync exited nonzero (rc=$SYNC_RC)";
-            elif ! printf '%s' "$SYNC_OUTPUT" | jq -e 'type == "object" and (.proposal | type == "object") and (.proposal.featureId | type == "string") and (.proposal.from | type == "string") and (.proposal.to | type == "string") and (.applied | type == "boolean")' > /dev/null 2>&1; then
-              REASON="malformed or unreadable sync result";
-            else
-              P_FROM=$(printf '%s' "$SYNC_OUTPUT" | jq -r '.proposal.from // ""');
-              P_TO=$(printf '%s' "$SYNC_OUTPUT" | jq -r '.proposal.to // ""');
-              APPLIED=$(printf '%s' "$SYNC_OUTPUT" | jq -r '.applied');
-              if [ "$(printf '%s' "$SYNC_OUTPUT" | jq -r '.proposal.featureId // ""')" != "$feature" ]; then
-                REASON="sync proposal does not match feature $feature";
-              elif [ "$(printf '%s' "$SYNC_OUTPUT" | jq -r '.proposal.gateBlocked // false')" = "true" ]; then
-                REASON="sync proposal is gate-blocked — a blocked sync is not a no-change success";
-              elif [ "$(printf '%s' "$SYNC_OUTPUT" | jq -r '.proposal.requiresConfirm // false')" = "true" ]; then
-                REASON="sync proposal requires operator confirmation";
-              elif [ "$APPLIED" = "true" ] && [ "$OBSERVED" != "$P_TO" ]; then
-                REASON="applied sync did not land on the proposal target (observed=$OBSERVED, to=$P_TO)";
-              elif [ "$APPLIED" = "false" ] && { [ "$P_FROM" != "$P_TO" ] || [ "$OBSERVED" != "$P_TO" ]; }; then
-                REASON="sync applied nothing without a from==to observed no-op (from=$P_FROM, to=$P_TO, observed=$OBSERVED)";
-              else
-                SYNC_OK=1;
-              fi;
-            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 feature gate: $featureGateCmd";
-              if sh -c "$featureGateCmd"; then
-                GATE="PASS";
-                echo "feature-transition: feature gate PASS for feature $feature";
-              else
-                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) — feature gate skipped";
-            fi;
-            SYNC_STATUS="PASS";
-            if [ "$SYNC_OK" -ne 1 ] || [ "$GATE" = "FAIL" ]; then
-              SYNC_STATUS="FAIL";
-              echo "feature-transition: required synchronization failed for $feature — $REASON; gate=$GATE" >&2;
-            elif [ "$APPLIED" = "false" ]; then
-              echo "feature-transition: feature sync verified for $feature (from==to observed at $OBSERVED, gate=$GATE) — explicit no-change";
-            else
-              echo "feature-transition: feature sync verified for $feature (applied, observed=$OBSERVED, gate=$GATE)";
-            fi;
-            if [ "$SYNC_STATUS" = "PASS" ]; then
-              printf 'PASS\n' > ".spur/run/$__runId-wrapup-sync.status";
+            if [ -f plugins/sp/scripts/wrapup-steps.ts ]; then
+              bun plugins/sp/scripts/wrapup-steps.ts feature-transition;
+            elif W="$(superskill script path sp wrapup-steps.mjs 2>/dev/null)" && [ -f "$W" ]; then
+              node "$W" feature-transition;
             else
+              echo "wrapup-steps failed closed — script not found — run 'superskill install sp'" >&2;
               printf 'FAIL\n' > ".spur/run/$__runId-wrapup-sync.status";
-            fi;
-            exit 0
+            fi
 
   - id: branch-cleanup
     description: >

package/package.json

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

package/plugins/sp/README.md

@@ -185,7 +185,7 @@ pipeline step.
 
 ```
 plugins/sp/
-├── skills/                          # Domain knowledge + workflow docs (32 skills)
+├── skills/                          # Domain knowledge + workflow docs (34 skills)
 │   ├── brainstorm/                  # Structured ideation workflow
 │   │   ├── agents/openai.yaml
 │   │   ├── examples/ideation-example.md
@@ -227,6 +227,8 @@ plugins/sp/
 │   │       ├── features.md  +  features/{verbs, acceptance-criteria, roadmap-priority}.md
 │   │       ├── rules.md  +  rules/{operations, authoring-rules, fine-tuning, validation-and-extension}.md
 │   │       └── workflows.md  +  workflows/{operations, authoring-workflows, validation-and-extension}.md
+│   ├── spur-composer/               # Cross-noun selection, composition ladder, rule tuning; applies doctor proposals
+│   ├── spur-doctor/                 # Read-only artifact evaluation → proposal table (backs spur-composer)
 │   ├── spur-dev/                    # Thin planning→execution orchestration spine
 │   │   └── references/  # ac-style-guide, cross-cutting, decision-brief, dev-operations,
 │   │                      execution-batch, execution-workflow, feature-link-helper,
@@ -330,7 +332,13 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `indexed-context`           | 1.0   | Cross-agent project context — anatomy/learnings/pitfalls/buglog/memory in `.spur/context/`; hook-tracked token-ledger; graceful degradation on agents without hooks                                                                        |
 | `history-anatomy`           | 1.0   | Diagnostic interpretation owner over already-imported history — daily/ad-hoc mode contract, closed finding taxonomy, twelve-section report contract, `enrich`/`validate` rubrics; no workflow launch, no JSONL fallback, no corpus mutation                                                                   |
 | `session-review`            | 1.1   | Inline review of the active coding-agent session — compact outcomes, evidence-backed resolved/open issue classification, proposal-only improvements, and next actions; no workflow, import, delegation, or mutation                                                                                           |
+| `spur-composer`             | 1.0   | Cross-noun composition — workflow catalog selection, the ephemeral→project→shared ladder, ADR-115 budgets, trace-driven rule tuning; applies accepted `spur-doctor` proposals through `spur` verbs; never judges its own output and never runs a recurring loop                                              |
+| `spur-doctor`               | 1.0   | Cross-noun evaluation — read-only CLI evidence per noun (task/feature/rule/workflow/agent spec), reflection over `history-anatomy` findings through a closed action-class map, and a proposal table; writes nothing; diagnoses artifacts, not runtime environments (`spur agent doctor`'s job)                |
 | `redesign-web-ui`           | 1.0   | Existing-UI visual upgrade — audit generic AI fingerprints, apply in-stack polish against `DESIGN.md` / live tokens, verify behavior and viewports; does not migrate frameworks                                                                                                                            |
+| `taste-refactoring-api`     | —     | API design and refactoring for REST/HTTP, RPC/gRPC, GraphQL, and event contracts; compatibility, security, and migration review |
+| `taste-refactoring-ui`      | —     | UI design and refactoring with visual hierarchy, typography, spacing, color, and interaction review |
+| `taste-refactoring-architect` | —   | Architecture review, simplification, and refactoring; boundary modeling, dependency reduction, and migration planning |
+| `taste-refactoring-tests`   | —     | Test suite refactoring for failure sensitivity, regression detection, and assertion strength; eliminates brittle mocks |
 
 #### Bounded coexistence and retirement gate — `sp:issue-finding` (HA-S1 0661)
 
@@ -488,12 +496,13 @@ hold `SKILL.md` and prompt-side companions only.
 | `hooks/context-*.ts`                                 | Runtime for the three registered context hooks (session-start, post-tool, session-stop) — token-cost estimation + ledger append for `sp:indexed-context`                                                                                                                                          |
 | `hooks/careful-guard.ts`                             | Opt-in destructive-command guard (unwired — see Hooks above)                                                                                                                                                                                                                                      |
 | `scripts/batch-preflight.ts`                         | Pure TABLE A STOP evaluation for `super-planner` — skip doomed pipeline launches without spawning a Skill subprocess; recovery hints map stuck statuses to a single `/sp:dev-*` hop                                                                                                               |
+| `scripts/workflow-step-profile.ts`                   | Read-only step profile from `spur workflow trace` — per node and action-kind durations, idle gaps, session mode and `cacheHit` coverage, plus the ADR-115 cache-window flags `sp:spur-doctor` turns into workflow-optimization proposals |
 | `scripts/dogfood-testing/detect-pipeline-driving.ts` | Word-boundary detector for pipeline-driving testees (leading-space invariant)                                                                                                                                                                                                                     |
 | `scripts/dogfood-testing/validate-report.ts`         | Pure `validateReport(md)` — footer-mandatory + 7-check finalize-or-abort contract with stable error codes                                                                                                                                                                                         |
 | `scripts/daily-summary/{daily-summary,logger}.ts`    | ccusage + git-history orchestration helpers for `sp:daily-summary`                                                                                                                                                                                                                                |
 | `scripts/feature-sync-bounded.ts`                    | Bounded retry-suppression wrapper for `spur feature sync` during batch/wrap-up runs — suppresses identical L4-blocked repeats                                                                                                              |
 | `scripts/stage-registry-adapter.ts`                  | dev-next golden-path adapter over the canonical stage registry — TABLE A/B/C resolution bridge for the status-aware facade                                                                                                                |
-| `scripts/task-size-precheck.ts`                      | Pipeline size precheck guard (R2) + size-vs-executor-capability gate (R3) — evaluates R-item/Plan-count limits to PASS/FAIL                                                                                                              |
+| `scripts/task-size-precheck.ts`                      | Pipeline size precheck guard (R2) — evaluates R-item/Plan-count limits to PASS/FAIL                                                                                                              |
 | `scripts/validate-flag-contracts.ts`                 | Mechanical consistency gate — compares flag claims across command files, flag-glossary, cross-cutting, dev-operations, and ADR; reports disagreements                                                                                    |
 | `*.test.ts`                                          | Unit suites — in `hooks/` for guards, in `tests/<skill>/` per ADR-031 pairing                                                                                                                                                                                                                     |
 
@@ -527,7 +536,7 @@ graph TB
     end
 
     subgraph "Execution layer"
-        CLI["spur CLI<br/>task · feature · rule · workflow<br/>· agent · history · team · message"]
+        CLI["spur CLI<br/>task · feature · rule · workflow<br/>· agent · history · message"]
         SCRIPT["hooks/task-write-guard.ts"]
     end
 

package/plugins/sp/agents/expert-spur.md

@@ -1,7 +1,7 @@
 ---
 name: expert-spur
 description: |
-  Use PROACTIVELY for "create tasks for this feature", "update all task statuses", "audit task traceability", "create a feature with acceptance criteria", "harden the rule catalog", "author a batch of workflows", or "expert-spur". Multi-step corpus work across `spur task`, `feature`, `rule`, and `workflow`: batch creation, status sweeps, section campaigns, traceability audits, rule hardening, and workflow authoring/refactoring. For one deterministic operation, run the CLI directly.
+  Use PROACTIVELY for "create tasks for this feature", "update all task statuses", "audit task traceability", "create a feature with acceptance criteria", "harden the rule catalog", "author a batch of workflows", "compose a workflow", "tune a rule", "apply accepted doctor proposals", "evaluate spur artifact health", "reflect over history findings", or "expert-spur". Multi-step corpus work across `spur task`, `feature`, `rule`, `workflow`, and agent specs: batch creation, status sweeps, section campaigns, traceability audits, rule hardening, workflow authoring/refactoring, composition and tuning (sp:spur-composer), and evaluation/reflection proposal passes (sp:spur-doctor). For one deterministic operation, run the CLI directly. Recurring evolution loops and multi-agent coordination belong to sp:super-planner — never this agent.
 
   <example>
   Context: Batch task status update across a feature.
@@ -12,19 +12,23 @@ description: |
 tools: [Read, Grep, Glob, Bash, Skill]
 model: inherit
 color: green
-skills: [sp:spur-cli]
+skills: [sp:spur-cli, sp:spur-composer, sp:spur-doctor]
 ---
 
 # Expert Spur
 
 Thin specialist for multi-step Spur **corpus** work. The backend skill `sp:spur-cli` owns noun,
 verb, flag, output, and exit semantics; this agent selects its task/feature/rule/workflow reference,
-sequences operations, and evaluates each result before continuing.
+sequences operations, and evaluates each result before continuing. Composition, tuning, evaluation
+and reflection campaigns are method-backed by `sp:spur-composer` and `sp:spur-doctor`; their verbs
+and flags still resolve through the `sp:spur-cli` references.
 
 ## Role
 
-You are the Spur corpus steward: a specialist sequencer over `skill: sp:spur-cli`, not a second
-implementation of the CLI or lifecycle spine.
+You are the Spur corpus steward: a specialist sequencer over `skill: sp:spur-cli`, backed by
+`sp:spur-composer` (select, compose, tune, apply) and `sp:spur-doctor` (evaluate, reflect, propose).
+You are not a second implementation of the CLI or lifecycle spine, not a coordinator, and not a
+recurring loop.
 
 ## Scope
 
@@ -34,19 +38,28 @@ Use for:
 - Cross-corpus traceability or structural audits.
 - Rule catalog authoring, validation, execution, and hardening.
 - Workflow fit decisions, authoring/refactoring, validation, dry-runs, and trace comparison.
-
-Do not use for one CLI invocation. Do not use for planning→implementation→verification lifecycle
-or batch task execution; `sp:spur-dev` owns that orchestration. The backend skill covers the other
+- Composition and tuning campaigns via `sp:spur-composer`: catalog selection, the composition
+  ladder, trace-driven rule tuning, and applying accepted doctor proposals.
+- Evaluation and reflection campaigns via `sp:spur-doctor`: read-only evidence, history-finding
+  reflection, and a proposal table.
+
+One bounded campaign per dispatch. Do not use for one CLI invocation. Do not use for
+planning→implementation→verification lifecycle or batch task execution; `sp:spur-dev` owns that
+orchestration. Recurring evolution loops and multi-agent coordination are not this agent's duty —
+they hand off to `sp:super-planner` or a workflow (§ Hand-offs). The backend skill covers the other
 CLI nouns for direct use, but they are not this corpus specialist's scope.
 
 ## Process
 
 1. Load `plugins/sp/skills/spur-cli/SKILL.md` and the exact noun reference before invoking a verb.
-2. Resolve and freeze the target set. Report ambiguity instead of guessing identifiers or flags.
-3. Run the noun's read/check/validate path before mutation where available.
-4. Mutate only through `spur`; parse `--json` output when the verb advertises it.
-5. Inspect each result before the next dependent operation; stop on structural or validation failure.
-6. Run affected-input checks after mutation (constitution T11): after task/feature batch writes,
+2. For compose/tune/apply work, load `plugins/sp/skills/spur-composer/SKILL.md` first; for
+   evaluate/reflect/propose work, load `plugins/sp/skills/spur-doctor/SKILL.md` first. Follow the
+   owning skill's method; never restate it here.
+3. Resolve and freeze the target set. Report ambiguity instead of guessing identifiers or flags.
+4. Run the noun's read/check/validate path before mutation where available.
+5. Mutate only through `spur`; parse `--json` output when the verb advertises it.
+6. Inspect each result before the next dependent operation; stop on structural or validation failure.
+7. Run affected-input checks after mutation (constitution T11): after task/feature batch writes,
    run `spur task check <wbs>` / `spur feature check <id>` for each changed document and its
    required linked evidence — not a corpus sweep. The explicit unsuppressed audit
    (`spur task check --corpus --json`) is reserved for checker-policy changes (T10).
@@ -71,13 +84,19 @@ their runbook here.
 - Reimplement CLI validation in prose or shell.
 - Never drive the planning/execution lifecycle; do not run application implementation or task
   pipelines through this agent.
+- Drive a task batch through execution, chain campaigns into a recurring loop, or dispatch and
+  coordinate multiple agents — no batch driving, no recurring loops, no coordination dispatch here;
+  they hand off to `sp:super-planner` or a workflow.
+- Use `spur agent loop` — a supervisor-internal, forbidden surface. Agent specs are read through
+  `spur agent list --specs`.
 
 ## Output Format
 
 ```markdown
 ## Spur Corpus Operations Report
 
-**Noun(s):** task | feature | rule | workflow
+**Noun(s):** task | feature | rule | workflow | agent spec
+**Method:** corpus campaign | compose/tune (`sp:spur-composer`) | evaluate/reflect (`sp:spur-doctor`)
 **Scope:** <resolved ids/files>
 **Confidence:** HIGH | MEDIUM | LOW
 
@@ -95,11 +114,14 @@ their runbook here.
 
 ## Platform Notes
 
-- Claude Code: use `Skill(skill="sp:spur-cli", args="<noun> <query>")`, then Bash for `spur`.
-- Other platforms: invoke `sp:spur-cli` directly; the agent wrapper is optional.
+- Claude Code: load the bound skill the campaign needs — `Skill(skill="sp:spur-cli" | "sp:spur-composer" | "sp:spur-doctor", args="<query>")` — then Bash for `spur`.
+- Other platforms: invoke the bound `sp:*` skill directly; the agent wrapper is optional.
 
-## Dispatch surface
+## Hand-offs
 
-If corpus work must be dispatched again, follow
+This agent runs one bounded campaign per dispatch and reports. Batch driving of task pipelines,
+recurring evolution loops, and multi-agent coordination are not dispatch duties here — hand them
+to `sp:super-planner` or a workflow definition. If the operator explicitly asks for a follow-up
+corpus dispatch, its surface contract is
 [dispatch-surface.md](../skills/parallel-execution/references/dispatch-surface.md): native subagent
-by default, `spur agent run` only on a named trigger.
+by default, `spur agent run` only on a named trigger — never `spur agent loop`.

package/plugins/sp/lib/idea-handoff.generated.d.mts

@@ -0,0 +1,17 @@
+/**
+ * GENERATED by scripts/commands/bundle-plugin-lib.ts — do not edit.
+ * Source of truth: packages/app/src/workflow/idea-handoff-cli.ts (task 0824).
+ */
+export declare interface IdeaHandoffCliEnv {
+    __runId?: string;
+    featureId?: string;
+    spurBin?: string;
+}
+export declare interface IdeaHandoffCliOutcome {
+    exitCode: number;
+    result?: unknown;
+}
+export declare function runIdeaHandoffCli(
+    env: IdeaHandoffCliEnv,
+    run?: (input: { runId: string; featureId: string; spurBin: string }) => Promise<unknown>,
+): Promise<IdeaHandoffCliOutcome>;