@gobing-ai/spur 0.3.80 → 0.3.82

package/config/workflows/idea-pipeline.yaml

@@ -331,7 +331,7 @@ states:
       - kind: agent.run
         options:
           agent: ${vars.planningAgent}
-          input: "Run sp:spec-decomposition for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and design doc. SIZING FIRST, before any JSON: apply the skill's `Default to NOT decomposing` rubric to the whole unit of work — if it scores 0-2 the correct output is a ONE-entry batch, not many. Scenario count is not task count: merge scenarios that one task delivers (same file surface, same subsystem, or unreadable apart in review), and list every scenario a task covers in its background. Merging never costs AC coverage — one task may carry several scenarios. Do not emit one entry per scenario or per requirement by reflex. Then produce a task-batch JSON array at .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `design`, `plan`, `acceptance_criteria`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. `design`, `plan`, and `acceptance_criteria` are supported batch fields and normal default planning fills them from your analysis; the per-task refine step after batch-create still deepens them when a task needs more detail. Validate locally against the schema before emitting. Also emit the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json: a JSON array (one entry per batch item) of `{ name: <exact batch item name>, depends_on_names: [<batch item names>] }` declaring ordering/dependencies between the batch items; use `[]` when no ordering exists. Every `name` and every dependency must match exactly one batch item `name` — it is private workflow data, not part of task-batch.schema.json."
+          input: "Run sp:spec-decomposition for feature ${vars.featureId} per skill references/decomposition.md § Idea-pipeline emission: sizing first, then the batch JSON at .spur/run/${vars.__runId}-idea-task-batch.json and the private task-order sidecar at .spur/run/${vars.__runId}-idea-task-order.json."
           # Declared Layer-1 role (0538 R2): routing reason beside the agent: pin.
           role: planner
           expectFile: .spur/run/${vars.__runId}-idea-task-batch.json
@@ -341,6 +341,8 @@ states:
       # unique, every sidecar name/dependency must refer to exactly one batch name, and — the
       # converse (F2, 0518 verify) — every batch name must appear in the sidecar, so a partial
       # sidecar can never silently skip `task deps` for an unlisted item (`[]` is valid).
+      # (warn) stays inline by design: one jq predicate over two run-scoped files; splitting
+      # it into a script would hide the exact fail-closed contract this guard pins (0824).
       - kind: shell
         options:
           command: >-
@@ -380,17 +382,22 @@ states:
       (CLI error or malformed result) writes the failed sentinel, preserving the
       existing retry behavior.
     onEnter:
+      # (e) idempotent batch creation: sentinel + temp/mv atomicity stay inline (0824);
+      # the jq verdict check keeps the done sentinel truthful so handoff-finalize can
+      # zip batch names to the returned WBS list.
       - kind: shell
         options:
           command: >-
-            if test -f .spur/run/$__runId-idea-batch-create.done; then exit 0; fi;
-            rm -f .spur/run/$__runId-idea-batch-create.failed .spur/run/$__runId-idea-batch-create-result.json .spur/run/$__runId-idea-batch-create-result.json.tmp;
-            if $spurBin task batch-create --file .spur/run/$__runId-idea-task-batch.json --skip-ready --json > .spur/run/$__runId-idea-batch-create-result.json.tmp && jq -e ".created == (.wbs | length)" .spur/run/$__runId-idea-batch-create-result.json.tmp >/dev/null 2>&1; then
-              mv .spur/run/$__runId-idea-batch-create-result.json.tmp .spur/run/$__runId-idea-batch-create-result.json &&
-              date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.done;
+            P=".spur/run/$__runId-idea-batch-create" &&
+            test ! -f "$P.done" || exit 0 &&
+            rm -f "$P.failed" "$P-result.json" "$P-result.json.tmp" &&
+            if $spurBin task batch-create --file .spur/run/$__runId-idea-task-batch.json --skip-ready --json > "$P-result.json.tmp" &&
+              jq -e ".created == (.wbs | length)" "$P-result.json.tmp" >/dev/null 2>&1; then
+              mv "$P-result.json.tmp" "$P-result.json" &&
+              date -u +%Y-%m-%dT%H:%M:%SZ > "$P.done";
             else
-              rm -f .spur/run/$__runId-idea-batch-create-result.json.tmp;
-              date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.failed;
+              rm -f "$P-result.json.tmp" &&
+              date -u +%Y-%m-%dT%H:%M:%SZ > "$P.failed";
             fi
 
   - id: ready-prepare
@@ -411,24 +418,22 @@ states:
           # Declared Layer-1 role (0538 R2), same planner executor as decompose.
           role: planner
           timeoutMs: ${vars.stepTimeoutMs}
+          # (warn) non-slash pointer: the 0788 checklist is per-checkout (digest via the
+          # project's own computePlanningDigest), so the bounded prompt pins the skill
+          # reference instead of a command; artifacts are gated by answerFile/expectFile.
           input: >-
-            Ready-by-default preparation for feature ${vars.featureId} (0788). The created WBS
-            values are in .spur/run/${vars.__runId}-idea-batch-create-result.json under .wbs.
-            For EACH wbs: resolve the task file with `spur task path <wbs> --json`; open the
-            task doc and apply the ready-refinement checklist — make requirements, design,
-            plan, acceptance criteria, decisions, dependencies and premises present and
-            non-placeholder so `spur task check <wbs> --json` exits 0; edit only planning
-            sections, never Solution/Testing/Review/History. Record one checklist row per id
-            with concrete evidence of how you verified it. Compute the planning digest with
-            the project's own implementation when this is a monorepo checkout:
-            `bun -e 'const m = await import("./packages/app/src/services/task-readiness"); console.log(m.computePlanningDigest(await Bun.file(process.argv[1]).text()))' <task-file>`
-            — when that is impossible in this checkout, set status "skipped" instead of
-            guessing a digest. Finally write .spur/run/${vars.__runId}-idea-ready.json with
-            exactly this shape: {"runId":"${vars.__runId}","depth":"ready","tasks":[{"wbs":"<wbs>","status":"ready" or "failed" or "skipped","planningDigest":"<sha256 hex>","checks":[{"id":"requirements" or "design" or "plan" or "ac" or "decisions" or "dependencies" or "premises","pass":true or false,"evidence":"<how verified>"}]}]}. A task you cannot fully prepare gets status "failed" or "skipped" — never fabricate evidence; the handoff degrades to refineall.
+            Run the ready-prepare stage for feature ${vars.featureId} per sp:spur-dev
+            references/planning-workflow.md § Step 5.6 (Ready preparation): read
+            .spur/run/${vars.__runId}-idea-batch-create-result.json and write
+            .spur/run/${vars.__runId}-idea-ready.json.
+          answerFile: .spur/run/${vars.__runId}-ready-prepare-answer.txt
+          expectFile: .spur/run/${vars.__runId}-ready-prepare-answer.txt
       # Fail-closed shape validation (mirrors the order-sidecar guard). Absence is
       # normalized to an empty sidecar: finalize and the seeded fallback then degrade
       # the recommendation to refineall instead of failing the run. A PRESENT but
       # malformed sidecar fails the run here — it must not masquerade as evidence.
+      # (warn) stays inline by design: single jq shape predicate over the run-scoped
+      # sidecar; the failed/skipped rows are what degrade the recommendation (0824).
       - kind: shell
         options:
           command: >-
@@ -447,87 +452,23 @@ states:
       A mapping or CLI error fails the run before terminal handoff; an unready
       task is a successful planning outcome recorded as a refineall recommendation.
     onEnter:
-      # F1 (0518 verify): the per-task check loop fails closed. A stderr-only (non-JSON)
-      # `task check --json` exception would otherwise drop that task from the JSONL results
-      # without failing the run (the loop's exit status is its last body command), silently
-      # flipping the recommendation to runall — violating R3's any-fail=>refineall invariant.
-      # Each `jq -c … >> "$CHECKS"` appends under `|| exit 1`, and a row-count assertion
-      # (CHECKS lines == WBS count) gates the recommendation computation.
-      # D5-O (R4): the deterministic writer owns finalization wherever it exists.
-      # `idea-handoff-cli.ts` calls the tested `finalizeIdeaHandoff` capability and
-      # implements this exact contract (equal-length/unique-name zip, `spur task deps`,
-      # `spur feature refresh`, per-task check with a row-count assertion, and a single
-      # recommended next command). `spur init` never scaffolds `packages/`, so seeded
-      # projects fall through to the portable shell program below — the same
-      # monorepo-writer/shell-fallback split the wrap-up metrics hop uses (0604 Q&A).
+      # (d) idea-handoff owns finalization (0824): the bundled finalizeIdeaHandoff
+      # capability runs from the monorepo checkout first; seeded projects (no
+      # packages/, no plugins/) resolve the registered idea-handoff.mjs twin under
+      # bare node; neither present fails closed (exit 1) instead of silently
+      # skipping finalization. The zip/deps/refresh/check/report contract itself is
+      # pinned by finalizeIdeaHandoff unit tests, not by this file.
       - kind: shell
         options:
           command: >-
             if [ -f packages/app/src/workflow/idea-handoff-cli.ts ]; then
               bun packages/app/src/workflow/idea-handoff-cli.ts;
-              exit $?;
-            fi;
-            BATCH=".spur/run/$__runId-idea-task-batch.json" &&
-            RESULT=".spur/run/$__runId-idea-batch-create-result.json" &&
-            ORDER=".spur/run/$__runId-idea-task-order.json" &&
-            REPORT=".spur/run/$__runId-idea-handoff.md" &&
-            DEPMAP=".spur/run/$__runId-idea-dep-map.tsv" &&
-            CHECKS=".spur/run/$__runId-idea-check-results.jsonl" &&
-            rm -f "$DEPMAP" "$CHECKS" &&
-            jq -e --slurpfile b "$BATCH" '(.wbs | length) == ($b[0] | length) and (($b[0] | map(.name) | unique | length) == ($b[0] | length))' "$RESULT" >/dev/null &&
-            jq -r --slurpfile b "$BATCH" --slurpfile r "$RESULT" --slurpfile o "$ORDER" '
-              ($b[0] | map(.name)) as $names | ($r[0].wbs) as $wbs |
-              $o[0] | .[] |
-              (.name as $n | $names | index($n)) as $i |
-              (if $i == null or $wbs[$i] == null then "MISSING" else $wbs[$i] end) as $own |
-              ((.depends_on_names // []) | map(. as $dep | $names | index($dep) as $d | if $d == null then "MISSING" else $wbs[$d] end) | join(" ")) as $deps |
-              [.name, $own, $deps] | @tsv
-            ' "$ORDER" > "$DEPMAP" &&
-            while IFS="$(printf '\t')" read -r name own deps; do
-              test "$own" != MISSING || exit 1;
-              if test -n "$deps"; then
-                for d in $deps; do test "$d" != MISSING || exit 1; done;
-                $spurBin task deps "$own" set $deps --json >/dev/null || exit 1;
-              fi;
-            done < "$DEPMAP" &&
-            $spurBin feature refresh --feature "$featureId" --json >/dev/null &&
-            WBS_LIST=$(jq -r '.wbs | join(" ")' "$RESULT") &&
-            for wbs in $WBS_LIST; do
-              TMP=".spur/run/$__runId-idea-check-$wbs.tmp";
-              if $spurBin task check "$wbs" --json > "$TMP" 2>&1; then P=true; else P=false; fi;
-              jq -c --arg w "$wbs" --argjson p "$P" 'if (type == "array" and length > 0) then {wbs: $w, pass: $p, status: (.[0].status // "unknown")} else {wbs: $w, pass: $p, status: "missing"} end' "$TMP" >> "$CHECKS" || exit 1;
-              rm -f "$TMP";
-            done &&
-            CHECK_ROWS=$(wc -l < "$CHECKS" | tr -d ' ') &&
-            WBS_COUNT=$(printf '%s\n' $WBS_LIST | wc -l | tr -d ' ') &&
-            test "$CHECK_ROWS" = "$WBS_COUNT" &&
-            READY=".spur/run/$__runId-idea-ready.json" &&
-            (test -f "$READY" || printf '{"tasks":[]}\n' > "$READY") &&
-            NEXT=$(jq -r --arg feature "$featureId" --slurpfile c "$CHECKS" --slurpfile k "$READY" 'if (($c | any(.[]; .pass == false)) or (($k[0].tasks // []) | length == 0) or (($k[0].tasks // []) | any(.[]; .status != "ready"))) then "/sp:dev-refineall --feature \($feature) --auto --depth ready" else "/sp:dev-runall --feature \($feature) --auto" end' "$RESULT") &&
-            {
-              echo "# Idea pipeline handoff report";
-              echo;
-              echo "Feature: $featureId";
-              echo "Run ID: $__runId";
-              echo;
-              echo "## Created tasks";
-              printf '%s\n' $WBS_LIST | sed 's/^/  - /';
-              echo;
-              echo "## Per-task readiness (spur task check)";
-              echo;
-              echo "| WBS | Outcome |";
-              echo "|-----|---------|";
-              while IFS= read -r line; do
-                w=$(printf '%s' "$line" | jq -r '.wbs');
-                o=$(printf '%s' "$line" | jq -r 'if .pass then "PASS" else "FAIL" end');
-                printf '| %s | %s |\n' "$w" "$o";
-              done < "$CHECKS";
-              echo;
-              echo "## Next command";
-              echo;
-              echo "$NEXT";
-            } > "$REPORT"
-
+            elif H="$(superskill script path sp idea-handoff.mjs 2>/dev/null)" && [ -f "$H" ]; then
+              node "$H";
+            else
+              echo "idea handoff failed closed — idea-handoff script not found — run 'superskill install sp'" >&2;
+              exit 1;
+            fi
   - id: handoff
     description: >
       Terminal — idea pipeline complete. Ordering applied, roster refreshed, and
@@ -627,6 +568,8 @@ transitions:
   - from: ac-generate
     to: system-design
     description: "profile=auto, check passed, design route — run system design."
+    # (warn) 4 test segments: profile gate + captured status + route signal jointly own the
+    # route; guards never re-run the CLI (0769), so there is nothing smaller to extract.
     guard:
       kind: shell
       options:
@@ -635,6 +578,8 @@ transitions:
   - from: ac-generate
     to: decompose
     description: "profile=auto, check passed, skip-design route — go directly to decompose."
+    # (warn) 5 test segments: same as auto-skip 1 plus the OR'd design=auto/needs_design=false
+    # pair that keeps one captured signal file authoritative for both routes (0769).
     guard:
       kind: shell
       options:
@@ -643,6 +588,8 @@ transitions:
   - from: ac-generate
     to: ac-generate
     description: "profile=auto, check failed, retry cap not reached — re-run ac-generate."
+    # (warn) 4 test segments: profile gate + captured status + captured retry count; the
+    # retry loop is the smallest honest formulation of cap<3 routing (0769).
     guard:
       kind: shell
       options:
@@ -651,6 +598,8 @@ transitions:
   - from: ac-generate
     to: failed
     description: "profile=auto, check failed after 3 retries — escalate to failed."
+    # (warn) 4 test segments: mirror of the retry guard with cap>=3; keeping escalation and
+    # retry as one test-chain pair makes the cap boundary auditable in the diff (0769).
     guard:
       kind: shell
       options:
@@ -667,6 +616,8 @@ transitions:
   - from: feature-check
     to: system-design
     description: Feature check passed, design route — run system design.
+    # (warn) 4 test segments: HITL answer + captured status + design route; same shape as the
+    # ac-generate auto-skips, reading the same captured signal files (0769).
     guard:
       kind: shell
       options:
@@ -674,6 +625,8 @@ transitions:
   - from: feature-check
     to: decompose
     description: Feature check passed, skip-design route — go directly to decompose.
+    # (warn) 5 test segments: same as the feature-check design route plus the OR'd
+    # design=auto/needs_design=false pair (0769).
     guard:
       kind: shell
       options:
@@ -681,6 +634,8 @@ transitions:
   - from: feature-check
     to: ac-generate
     description: "Feature check failed — revise AC (retry cap: 3)."
+    # (warn) 4 test segments: HITL reject/failed-status OR-pair + captured retry count; the
+    # interactive retry mirror of the ac-generate cap<3 guard (0769).
     guard:
       kind: shell
       options:
@@ -688,6 +643,7 @@ transitions:
   - from: feature-check
     to: failed
     description: Feature check failed after 3 retries — escalate to failed.
+    # (warn) 4 test segments: mirror of the revise guard with cap>=3 (0769).
     guard:
       kind: shell
       options:

package/config/workflows/pr-review.yaml

@@ -67,6 +67,8 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 10 lines — detached-HEAD/dirty/gh-auth/base-refusal probes must record
+          # before any push can publish; split would let a half-probed run continue.
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-preflight.status" &&
@@ -83,6 +85,8 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 9 lines — hygiene verdict + json capture land together; the status-file
+          # fallback keeps a silent driver from passing the gate.
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-hygiene.status" &&
@@ -100,16 +104,10 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 7 lines — unchanged shape (optional preReviewCmd probe, SKIP/PASS/FAIL)
+          # condensed onto folded one-liners to hold the §1.2 budget.
           command: >-
-            mkdir -p .spur/run &&
-            STATUS_FILE=".spur/run/$__runId-pr-precheck.status" &&
-            if [ -z "$preReviewCmd" ]; then
-              printf 'SKIP\n' > "$STATUS_FILE";
-            else
-              set +e; sh -c "$preReviewCmd"; rc=$?; set -e;
-              if [ "$rc" -eq 0 ]; then printf 'PASS\n' > "$STATUS_FILE"; else printf 'FAIL\n' > "$STATUS_FILE"; fi;
-            fi &&
-            exit 0
+            mkdir -p .spur/run; if [ -z "$preReviewCmd" ]; then R=SKIP; elif sh -c "$preReviewCmd"; then R=PASS; else R=FAIL; fi; printf '%s\n' "$R" > ".spur/run/$__runId-pr-precheck.status"
 
   - id: push
     description: >
@@ -118,6 +116,8 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 9 lines — push result and status fallback are atomic; a split could
+          # publish commits without recording the outcome.
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-push.status" &&
@@ -133,6 +133,8 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 9 lines — PR dedupe lookup captures its record for the downstream
+          # review link; ensure + capture must not race.
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-ensure.status" &&
@@ -150,19 +152,10 @@ states:
     onEnter:
       - kind: shell
         options:
+          # (e) 0825: 10 lines — the write-then-read split is the file-var transport feeding
+          # wait/collect and must stay one action (same record, same run scope).
           command: >-
-            mkdir -p .spur/run &&
-            STATUS_FILE=".spur/run/$__runId-pr-request.status" &&
-            FORCE_FLAG="" &&
-            if [ "$mode" = "rerun" ]; then FORCE_FLAG="--force"; fi &&
-            set +e &&
-            bun "$(superskill script path sp pr-reviewing.ts)" request --focus "$focus" $FORCE_FLAG --json
-            --status-file "$STATUS_FILE" > ".spur/run/$__runId-pr-request.json";
-            rc=$?; set -e &&
-            if [ ! -f "$STATUS_FILE" ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi &&
-            [ -f ".spur/run/$__runId-pr-request.json" ] &&
-            bun -e 'const fs=require("node:fs");const r=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));fs.writeFileSync(process.argv[2],(r.requestedAt ?? "")+"\n");fs.writeFileSync(process.argv[3],(r.head ?? "")+"\n")' ".spur/run/$__runId-pr-request.json" ".spur/run/$__runId-pr-since.txt" ".spur/run/$__runId-pr-head.txt";
-            exit 0
+            mkdir -p .spur/run; case "$mode" in rerun) F=--force ;; *) F= ;; esac; bun "$(superskill script path sp pr-reviewing.ts)" request --focus "$focus" $F --json --status-file ".spur/run/$__runId-pr-request.status" > ".spur/run/$__runId-pr-request.json"; [ -f ".spur/run/$__runId-pr-request.status" ] || printf 'FAIL\n' > ".spur/run/$__runId-pr-request.status"; jq -e . ".spur/run/$__runId-pr-request.json" > /dev/null 2>&1 && jq -r '.requestedAt // ""' ".spur/run/$__runId-pr-request.json" > ".spur/run/$__runId-pr-since.txt" && jq -r '.head // ""' ".spur/run/$__runId-pr-request.json" > ".spur/run/$__runId-pr-head.txt"; exit 0
 
   - id: wait
     description: >
@@ -181,6 +174,8 @@ states:
           var: prHead
       - kind: shell
         options:
+          # (e) 0825: 9 lines — bounded wait loop keeps rc bookkeeping so a crashed driver
+          # fails closed instead of polling forever.
           command: >-
             mkdir -p .spur/run &&
             STATUS_FILE=".spur/run/$__runId-pr-wait.status" &&
@@ -206,19 +201,10 @@ states:
           var: prHead
       - kind: shell
         options:
+          # (e) 0825: 9 lines — collect + status must run against the same since/head pair
+          # before the composite status is decided (same 0771 record contract).
           command: >-
-            mkdir -p .spur/run &&
-            STATUS_FILE=".spur/run/$__runId-pr-collect.status" &&
-            set +e &&
-            bun "$(superskill script path sp pr-reviewing.ts)" collect --since "$prSince" --head "$prHead" --json
-            --status-file "$STATUS_FILE" > ".spur/run/$__runId-pr-findings.json";
-            collect_rc=$?;
-            bun "$(superskill script path sp pr-reviewing.ts)" status --since "$prSince" --head "$prHead" --json > ".spur/run/$__runId-pr-status.json";
-            status_rc=$?; set -e &&
-            if [ "$collect_rc" -ne 0 ] || [ "$status_rc" -ne 0 ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi &&
-            if [ ! -f "$STATUS_FILE" ]; then printf 'FAIL\n' > "$STATUS_FILE"; fi &&
-            { cat ".spur/run/$__runId-pr-findings.json" 2>/dev/null || true; } &&
-            exit 0
+            mkdir -p .spur/run; bun "$(superskill script path sp pr-reviewing.ts)" collect --since "$prSince" --head "$prHead" --json --status-file ".spur/run/$__runId-pr-collect.status" > ".spur/run/$__runId-pr-findings.json"; c=$?; bun "$(superskill script path sp pr-reviewing.ts)" status --since "$prSince" --head "$prHead" --json > ".spur/run/$__runId-pr-status.json" && [ "$c" -eq 0 ] && [ -f ".spur/run/$__runId-pr-collect.status" ] || printf 'FAIL\n' > ".spur/run/$__runId-pr-collect.status"; cat ".spur/run/$__runId-pr-findings.json" 2>/dev/null; exit 0
 
   - id: done
     description: Terminal — review collected; findings artifact at .spur/run/${vars.__runId}-pr-findings.json
@@ -308,6 +294,8 @@ transitions:
     guard:
       kind: shell
       options:
+        # (e) 0825: 4-predicate guard — ALREADY_REQUESTED/REQUESTED pair state is the
+        # fallback route when the review driver stalls (mode/noWait honored).
         command: 'test "$(cat .spur/run/$__runId-pr-request.status 2>/dev/null)" = ALREADY_REQUESTED || { test "$(cat .spur/run/$__runId-pr-request.status 2>/dev/null)" = REQUESTED && { test "$mode" = "submit" || test "$noWait" = "true"; }; }'
   - from: request
     to: wait