@gobing-ai/spur 0.3.78 → 0.3.81

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.78",
+    "version": "0.3.81",
     "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.60",
-        "@gobing-ai/ts-ai-runner": "^0.4.60",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.4.60",
-        "@gobing-ai/ts-infra": "^0.4.60",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.60",
-        "@gobing-ai/ts-rule-engine": "^0.4.60",
-        "@gobing-ai/ts-runtime": "^0.4.60",
-        "@gobing-ai/ts-utils": "^0.4.60",
+        "@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

@@ -171,10 +171,12 @@ Commands above are thin wrappers; the actual logic lives in `skills/`. The spine
 dispatches five competency skills by function — design (`sp:sys-architecture`), decomposition
 (`sp:spec-decomposition`), implementation (`sp:code-implementation`), testing (`sp:code-testing`),
 and verification (`sp:code-verification`) — plus a CLI facade (`sp:spur-cli`, one reference per
-`spur` noun) and standalone technique skills (`sp:next-router`, `sp:test-driven-development`, `sp:brainstorm`,
-`sp:wayfinder`, `sp:sys-debugging`, `sp:code-review`, `sp:code-simplification`, `sp:code-improvement`,
-`sp:parallel-execution`, `sp:branch-workflow`, `sp:doc-evolve`, `sp:dogfood-testing`,
-`sp:daily-summary`, `sp:reverse-engineering`, `sp:issue-finding`, `sp:conflict-finding`,
+`spur` noun) and standalone technique skills (`sp:next-router`, `sp:next-feature`,
+`sp:test-driven-development`, `sp:source-driven-development`, `sp:doubt-driven-development`,
+`sp:brainstorm`, `sp:wayfinder`, `sp:sys-debugging`, `sp:code-review`, `sp:pr-reviewing`,
+`sp:functional-review`, `sp:code-simplification`, `sp:code-improvement`, `sp:parallel-execution`,
+`sp:branch-workflow`, `sp:doc-evolve`, `sp:dogfood-testing`, `sp:daily-summary`,
+`sp:reverse-engineering`, `sp:history-anatomy`, `sp:issue-finding`, `sp:conflict-finding`,
 `sp:indexed-context`, `sp:session-review`, `sp:redesign-web-ui`). See
 [skills/spur-dev/SKILL.md](skills/spur-dev/SKILL.md)'s Step routing table for which skill owns which
 pipeline step.
@@ -183,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
@@ -215,6 +217,7 @@ plugins/sp/
 │   │   └── references/routing-table.md
 │   ├── parallel-execution/          # Fan-out decision framework + patterns
 │   │   └── references/{fan-out-patterns, result-synthesis}.md
+│   ├── pr-reviewing/                # GitHub PR review loop backing /sp:dev-pr-review
 │   ├── source-driven-development/   # Source-first API/contract verification (SKILL.md only)
 │   ├── spec-decomposition/          # Feature/spec → task-batch competency
 │   │   └── references/decomposition.md
@@ -224,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,
@@ -255,6 +260,8 @@ plugins/sp/
 ├── agents/                          # 4 specialist subagents (expert-spur, super-coder, super-planner, super-reviewer)
 ├── hooks/                           # hooks.json + task-write-guard.{ts,test.ts} + context-{session-start,post-tool,session-stop}.ts
 │                                    # + careful-guard.{ts,test.ts} + context-hooks.test.ts + token-estimate.test.ts
+│                                    # + shared policy modules: agent-hint.ts, destructive-policy.{ts,test.ts}, task-file-policy.{ts,test.ts}
+│                                    # + pi/guard-extension.{ts,test.ts} (plugin.json `extensions.pi` entry point)
 ├── scripts/                         # Executable helpers, split from prompts (ADR-031) — validate-commands.ts (thin-wrapper validator), batch-preflight.ts + scripts/<skill>/
 │                                    # (daily-summary: {daily-summary, logger}.ts; dogfood-testing: {detect-pipeline-driving, validate-report}.ts)
 ├── tests/                           # Plugin tests — command-contract.test.ts + skill-structure.test.ts + batch-preflight.test.ts + per-skill suites
@@ -318,14 +325,20 @@ surface or run one workflow. All skills target the same five core platforms: `cl
 | `daily-summary`             | 1.0.0 | Daily summary report generator — orchestrates ccusage CLI + git history into structured markdown summaries                                                                                                                                 |
 | `doc-evolve`                | 1.0   | Key-document evolution per `docs/99_PROJECT_CONSTITUTION.md` — drift audits, same-commit sync checks, frontmatter-contract verification, machine-appended lessons                                                                          |
 | `reverse-engineering`       | 1.1   | Codebase analysis / HLD generation / audit — depth-driven reverse engineering with orthogonal mode, focus, and format controls; backs `/sp:dev-reverse`                                                                                    |
-| `issue-finding`             | 1.1   | Session-log forensics — multi-source discovery, bottleneck ranking, optional topic focus, CLI-gated fix task generation; **legacy path** — superseded by `history-anatomy` for indexed reporting; backs no current command; directly invocable as sp:issue-finding |
+| `issue-finding`             | 2.0   | Session-log forensics — multi-source discovery, bottleneck ranking, optional topic focus, CLI-gated fix task generation; **legacy path** — superseded by `history-anatomy` for indexed reporting; backs no current command; directly invocable as sp:issue-finding |
 | `conflict-finding`          | 1.0   | Authority-aware semantic audit — four-pillar (source/task/feature/authority) conflict discovery, claim-specific authority resolution, reproducible evidence, confirmed owner-routed remediation; backs `/sp:dev-find-conflict`             |
 | `next-feature`              | 1.0   | Prompt-first feature frontier prioritizer — sync-first precondition, B3 actionability gate (cited, never restated), tiered rubric over measured signals, D1–D4 defect proposals conforming to the restructure map schema; backs `/sp:dev-find-next` |
 | `pr-reviewing`              | 1.0   | GitHub Codex PR review — PR prepare/reuse, `@codex review` request with per-HEAD dedupe, bounded polling, findings normalization, validated fix + re-review; spine SSOT `pr-review.yaml` + `scripts/pr-reviewing.ts`; backs `/sp:dev-pr-review`     |
 | `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.0   | 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                                                                                           |
+| `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)
 
@@ -418,7 +431,7 @@ the pipeline's Phase 7 review step.
 | ---------------- | ------------ | ----------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------- |
 | `expert-spur`    | expert       | `sp:spur-cli`                                                           | green   | "create tasks", "feature lifecycle", "add a rule", "author a workflow"          |
 | `super-coder`    | builder      | `sp:sys-architecture` + `sp:code-implementation` + `sp:code-testing` + `sp:sys-debugging` | blue    | "implement this", "write the code", "fix this bug", "design the architecture"   |
-| `super-planner`  | orchestrator | `sp:spur-dev` + `sp:dogfood-testing`                                    | green   | "run this task end to end", "run all tasks", "run the batch", "runall"          |
+| `super-planner`  | orchestrator | `sp:spur-dev` + `sp:parallel-execution` + `sp:dogfood-testing` + `sp:next-router` | green   | "run this task end to end", "run all tasks", "run the batch", "runall"          |
 | `super-reviewer` | reviewer     | `sp:code-verification` + `sp:functional-review` + `sp:code-improvement` | crimson | "review this", "check the code", "SECUA review", "run task 0042 through review" |
 
 Each agent has:
@@ -483,6 +496,7 @@ 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`                                                                                                                                                                                                                                |