@gobing-ai/spur 0.3.43 → 0.3.44

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
     },
     "plugins": [
         {
-            "version": "0.3.43",
+            "version": "0.3.44",
             "name": "sp",
             "source": "./plugins/sp",
             "description": "Spur - my harness toolkits"

package/config/templates/AGENTS.md

@@ -69,6 +69,11 @@ All product development work goes through the harness by default.
    auto`, a name, parallel/headless execution, direct `spur agent run`, and engine-driven workflow
    `agent.run` remain subprocess surfaces.
 
+**Task lookup fast path:** Given a WBS, do not search `docs/tasks*` or guess `--folder`. Use
+`spur task show <wbs> --json` for task metadata and content; its response also includes `filePath`.
+Use `spur task path <wbs> --json` only when a filesystem consumer needs the absolute path. Both
+commands resolve across configured task folders. Reuse the first `show` response within the run.
+
 **Platform fallback:** Platforms without slash commands and/or subagents still use the harness.
 Install the plugin through Superskill for the target platform, then use skills `sp:spur-dev`,
 `sp:spur-cli`, `sp:code-verification` (and related) plus the `spur` CLI. Do not invent a parallel

package/config/workflows/idea-pipeline.yaml

@@ -10,7 +10,7 @@
 # Shape: start -> discovery -> idea-eval -> feature-create -> ac-generate -> feature-check
 #          -> system-design (conditional: needs_design signal)
 #          -> design-approval (taste HITL gate; not auto-clicked by --auto)
-#          -> decompose -> batch-create -> handoff
+#          -> decompose -> batch-create -> handoff-finalize -> handoff
 #        (idea-eval rejection -> cancelled)
 #        (feature-check failure routes back to ac-generate; batch-create failure to decompose).
 #
@@ -128,20 +128,36 @@ states:
   - id: feature-create
     description: >
       Create a feature via spur feature create, or select an existing feature id.
-      The agent writes the feature id to .spur/run/${vars.__runId}-idea-feature-id.txt for subsequent
-      states to read. Prefer the enhanced idea from .spur/run/${vars.__runId}-idea-eval-report.md as
+      The agent writes the feature id to .spur/run/${vars.__runId}-idea-feature-id.txt and body-only
+      intent artifacts .spur/run/${vars.__runId}-idea-goal.md / -idea-scope.md. Goal carries
+      concise intent only; Scope carries explicit in/out boundaries — task breakdowns and
+      checklists never enter Goal. Shell actions then persist both sections through
+      `spur feature update --section Goal|Scope --from-file ...`; a missing/empty artifact
+      stops the state. Prefer the enhanced idea from .spur/run/${vars.__runId}-idea-eval-report.md as
       context; do not overwrite vars.idea.
     onEnter:
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: "Create a feature for the idea: ${vars.idea}. Read .spur/run/${vars.__runId}-idea-eval-report.md if present for the enhanced idea and scores. Use 'spur feature create \"<name>\" --json' to create it. Write the feature id to .spur/run/${vars.__runId}-idea-feature-id.txt. If an existing feature is appropriate, use its id instead."
+          input: "Create a feature for the idea: ${vars.idea}. Read .spur/run/${vars.__runId}-idea-eval-report.md if present for the enhanced idea and scores. Use 'spur feature create \"<name>\" --json' to create it. Write the feature id to .spur/run/${vars.__runId}-idea-feature-id.txt. If an existing feature is appropriate, use its id instead. Also write two body-only intent artifacts: .spur/run/${vars.__runId}-idea-goal.md with concise Goal intent only (a short statement of what the feature achieves; never task breakdowns, checklists, or how-to steps), and .spur/run/${vars.__runId}-idea-scope.md with explicit in-scope and out-of-scope boundary bullets."
           expectFile: .spur/run/${vars.__runId}-idea-feature-id.txt
           timeoutMs: ${vars.stepTimeoutMs}
       - kind: file.read.into-var
         options:
           path: .spur/run/${vars.__runId}-idea-feature-id.txt
           var: featureId
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run &&
+            test -s .spur/run/$__runId-idea-goal.md &&
+            $spurBin feature update "$featureId" --section Goal --from-file .spur/run/$__runId-idea-goal.md
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run &&
+            test -s .spur/run/$__runId-idea-scope.md &&
+            $spurBin feature update "$featureId" --section Scope --from-file .spur/run/$__runId-idea-scope.md
 
   - id: ac-generate
     description: >
@@ -177,7 +193,7 @@ states:
         options:
           command: >-
             if test -s .spur/run/$__runId-idea-ac-content.md; then
-              $spurBin feature update $featureId --section "Acceptance Criteria" --from-file .spur/run/$__runId-idea-ac-content.md && date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-ac-done.txt;
+              $spurBin feature update "$featureId" --section "Acceptance Criteria" --from-file .spur/run/$__runId-idea-ac-content.md && date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-ac-done.txt;
             else
               exit 0;
             fi
@@ -206,13 +222,33 @@ states:
       Dispatch sp:sys-architecture to produce the system design. This state runs
       only when needs_design=true (design=auto signal path). The agent creates ADR
       entries, architecture updates, and design satellites through constitution rules.
-      The design-approval state follows (taste gate).
+      A run-scoped design-review artifact (.spur/run/${vars.__runId}-idea-design-review.md)
+      with fixed headings `## Proposed design`, `## Operator feedback`, and `## Reconciliation`
+      carries operator rejection feedback back into this state: on the first pass the agent
+      fills `## Proposed design`; on retry (operator feedback present) it revises the design,
+      records the reconciliation, and updates invalidated Acceptance Criteria through
+      `spur feature update` before design can exit. The design-approval state follows (taste gate).
     onEnter:
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run &&
+            REVIEW=".spur/run/$__runId-idea-design-review.md" &&
+            test -f "$REVIEW" || printf '## Proposed design\n\n## Operator feedback\n\n## Reconciliation\n' > "$REVIEW"
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: "Run sp:sys-architecture for feature ${vars.featureId}. Read the brainstorm artifact and feature AC. Produce ADR entries, architecture updates, and design satellites (docs/design/<slug>.md) following the constitution edit rules. Do not write task or feature corpus files directly."
+          input: "Run sp:sys-architecture for feature ${vars.featureId}. Read the brainstorm artifact, feature AC, and .spur/run/${vars.__runId}-idea-design-review.md. Produce ADR entries, architecture updates, and design satellites (docs/design/<slug>.md) following the constitution edit rules. Do not write task or feature corpus files directly. Design-review contract (.spur/run/${vars.__runId}-idea-design-review.md, fixed headings `## Proposed design`, `## Operator feedback`, `## Reconciliation`): on the first pass write the proposed design summary under `## Proposed design` and leave `## Operator feedback` empty; on retry with operator feedback present, revise the design/ADR artifacts, document the changes under `## Reconciliation`, and when the feedback invalidates an Acceptance Criteria scenario write the revised AC section body to a file and persist it via `$spurBin feature update \"$featureId\" --section \"Acceptance Criteria\" --from-file <file>` — never edit feature corpus files directly."
+          expectFile: .spur/run/${vars.__runId}-idea-design-review.md
           timeoutMs: ${vars.stepTimeoutMs}
+      # expectFile proves existence only, and the onEnter skeleton pre-creates the file — so an
+      # agent no-op would still pass it (0515 P3-2). Fail closed: the `## Proposed design` section
+      # must carry non-whitespace content before design can exit to approval/decompose.
+      - kind: shell
+        options:
+          command: >-
+            REVIEW=".spur/run/$__runId-idea-design-review.md" &&
+            awk '/^## Proposed design/{f=1; next} /^## Operator feedback/{f=0} f' "$REVIEW" | grep -q '[^[:space:]]'
 
   - id: design-approval
     description: >
@@ -226,6 +262,11 @@ states:
       agent passes. The onEnter shell increments a reject counter; the `no`
       edge to system-design is capped at 1 revise, after which the run
       terminates as `failed` naming this gate.
+
+      Rejection must carry operator feedback: before answering `no`, the operator
+      records the concrete issue(s) in the run-scoped design-review artifact
+      (.spur/run/${vars.__runId}-idea-design-review.md) under `## Operator feedback` —
+      the revision pass reads it to reconcile invalidated AC before re-approval.
     pause: true
     onEnter:
       - kind: shell
@@ -233,23 +274,45 @@ states:
           command: 'mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-design-reject-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-design-reject-count'
       - kind: hitl.confirm
         options:
-          prompt: "Review the system design for feature ${vars.featureId}. Approve to proceed to decomposition?"
+          prompt: "Review the system design for feature ${vars.featureId}. Approve to proceed to decomposition? To reject, first record your feedback in .spur/run/${vars.__runId}-idea-design-review.md under the `## Operator feedback` heading, then answer no."
 
   - id: decompose
     description: >
       Dispatch sp:spec-decomposition with the brainstorm artifact, feature AC, and
       design doc as input. The agent produces a task-batch JSON file at
-      .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json.
+      .spur/run/${vars.__runId}-idea-task-batch.json, validated against task-batch.schema.json,
+      plus the private task-order sidecar .spur/run/${vars.__runId}-idea-task-order.json
+      (a JSON array of { name, depends_on_names[] }; `[]` when no ordering exists).
+      A post-agent shell action validates the sidecar shape before decomposition
+      can exit — missing or ambiguous title-to-WBS resolution fails before handoff.
     onEnter:
       - kind: shell
         options:
-          command: 'mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-decompose-retry-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-decompose-retry-count; rm -f .spur/run/$__runId-idea-task-batch.json .spur/run/$__runId-idea-batch-create.done .spur/run/$__runId-idea-batch-create.failed'
+          command: 'mkdir -p .spur/run && count=$(cat .spur/run/$__runId-idea-decompose-retry-count 2>/dev/null || echo 0); echo $((count + 1)) > .spur/run/$__runId-idea-decompose-retry-count; rm -f .spur/run/$__runId-idea-task-batch.json .spur/run/$__runId-idea-task-order.json .spur/run/$__runId-idea-batch-create.done .spur/run/$__runId-idea-batch-create.failed .spur/run/$__runId-idea-batch-create-result.json .spur/run/$__runId-idea-handoff.md'
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          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 apps/cli/schemas/task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. Validate locally against the schema before emitting."
+          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 apps/cli/schemas/task-batch.schema.json. Schema-permitted fields per entry: `name`, `background`, `requirements`, `feature_id`, `parent_wbs`, `priority`, `tags`, `template` — schema validation rejects anything else. Acceptance Criteria, Design, and Plan sections are filled in by the per-task refine step after batch-create, NOT at decompose time. 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."
           expectFile: .spur/run/${vars.__runId}-idea-task-batch.json
           timeoutMs: ${vars.stepTimeoutMs}
+      # R1 (0518): the task-order sidecar is the ordering contract for handoff-finalize.
+      # Validate it fails closed: sidecar must be an array, batch names unique, sidecar names
+      # 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).
+      - kind: shell
+        options:
+          command: >-
+            BATCH=".spur/run/$__runId-idea-task-batch.json" &&
+            ORDER=".spur/run/$__runId-idea-task-order.json" &&
+            jq -e --slurpfile b "$BATCH" '
+              (type == "array") and
+              (($b[0] | map(.name) | length) == ($b[0] | map(.name) | unique | length)) and
+              ((map(.name) | length) == (map(.name) | unique | length)) and
+              ((map(.name) - ($b[0] | map(.name))) | length == 0) and
+              ((($b[0] | map(.name)) - map(.name)) | length == 0) and
+              (((map(.depends_on_names // []) | flatten | unique) - ($b[0] | map(.name))) | length == 0)
+            ' "$ORDER" >/dev/null
 
   - id: batch-create
     description: >
@@ -269,21 +332,116 @@ states:
     description: >
       Executes task batch creation exactly once per decomposition attempt. The
       side effect lives in onEnter and records a sentinel; transition guards only
-      inspect sentinel/retry state.
+      inspect sentinel/retry state. The `--json` result is captured atomically in
+      .spur/run/${vars.__runId}-idea-batch-create-result.json (temp file + mv); the done
+      sentinel is written only after the JSON parses and `created == (.wbs | length)`,
+      so handoff-finalize can zip batch names to the returned WBS list. Any failure
+      (CLI error or malformed result) writes the failed sentinel, preserving the
+      existing retry behavior.
     onEnter:
       - 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; if $spurBin task batch-create --file .spur/run/$__runId-idea-task-batch.json; then date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.done; else date -u +%Y-%m-%dT%H:%M:%SZ > .spur/run/$__runId-idea-batch-create.failed; fi'
+          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 --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;
+            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;
+            fi
+
+  - id: handoff-finalize
+    description: >
+      Post-create finalization (0518): zip batch item names to the created WBS
+      values from the captured batch-create result (equal-length/unique-name
+      checks), apply every non-empty depends_on_names list through
+      `spur task deps`, refresh the feature roster, check every created task, and
+      write the run-scoped handoff report
+      (.spur/run/${vars.__runId}-idea-handoff.md) with exactly one next command.
+      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.
+      - kind: shell
+        options:
+          command: >-
+            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" &&
+            NEXT=$(jq -r --arg feature "$featureId" --slurpfile c "$CHECKS" 'if ($c | any(.[]; .pass == false)) 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"
 
   - id: handoff
     description: >
-      Terminal — idea pipeline complete. Output: feature id, task WBS list, and
-      the next command to run (/sp:dev-run <first-wbs> or /sp:dev-runall --feature <id> or --tasks feature:<id>).
-      No task execution — the pipeline stops here.
+      Terminal — idea pipeline complete. Ordering applied, roster refreshed, and
+      the handoff report written at .spur/run/${vars.__runId}-idea-handoff.md:
+      feature id, task WBS list, per-task readiness, and exactly one recommended
+      next command (ready-depth refineall when any task is unready, else auto
+      runall). No task execution — the pipeline stops here.
     onEnter:
       - kind: note
         options:
-          message: "Idea pipeline handoff. Feature: ${vars.featureId}. Tasks created. Next: /sp:dev-runall --feature ${vars.featureId}"
+          message: "Idea pipeline handoff. Feature: ${vars.featureId}. See .spur/run/${vars.__runId}-idea-handoff.md for the created task list and recommended next command."
       # Checkpoint write: record session state for resume (Phase 4, task 0171 R3)
       - kind: shell
         options:
@@ -374,7 +532,7 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "$profile" = auto && $spurBin feature check $featureId && test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" != false'
+        command: 'test "$profile" = auto && $spurBin feature check "$featureId" && test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" != false'
   # Auto-skip 2: pass + skip-design route → decompose
   - from: ac-generate
     to: decompose
@@ -382,7 +540,7 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "$profile" = auto && $spurBin feature check $featureId && (test "$design" = skip || (test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" = false))'
+        command: 'test "$profile" = auto && $spurBin feature check "$featureId" && (test "$design" = skip || (test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" = false))'
   # Auto-skip 3: check failed, retry < 3 → loop back to ac-generate (self-loop)
   - from: ac-generate
     to: ac-generate
@@ -390,7 +548,7 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "$profile" = auto && ! $spurBin feature check $featureId && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -lt 3'
+        command: 'test "$profile" = auto && ! $spurBin feature check "$featureId" && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -lt 3'
   # Auto-skip 4: check failed, retry cap reached → escalate to failed
   - from: ac-generate
     to: failed
@@ -398,7 +556,7 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "$profile" = auto && ! $spurBin feature check $featureId && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -ge 3'
+        command: 'test "$profile" = auto && ! $spurBin feature check "$featureId" && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -ge 3'
   # Interactive fallback: enter feature-check HITL gate
   - from: ac-generate
     to: feature-check
@@ -414,28 +572,28 @@ transitions:
     guard:
       kind: shell
       options:
-        command: 'test "$__hitlAnswer" = yes && $spurBin feature check $featureId && test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" != false'
+        command: 'test "$__hitlAnswer" = yes && $spurBin feature check "$featureId" && test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" != false'
   - from: feature-check
     to: decompose
     description: Feature check passed, skip-design route — go directly to decompose.
     guard:
       kind: shell
       options:
-        command: 'test "$__hitlAnswer" = yes && $spurBin feature check $featureId && (test "$design" = skip || (test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" = false))'
+        command: 'test "$__hitlAnswer" = yes && $spurBin feature check "$featureId" && (test "$design" = skip || (test "$design" = auto && test "$(jq -r .needs_design .spur/run/$__runId-idea-needs-design.json 2>/dev/null)" = false))'
   - from: feature-check
     to: ac-generate
     description: "Feature check failed — revise AC (retry cap: 3)."
     guard:
       kind: shell
       options:
-        command: '(test "$__hitlAnswer" = no || ! $spurBin feature check $featureId) && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -lt 3'
+        command: '(test "$__hitlAnswer" = no || ! $spurBin feature check "$featureId") && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -lt 3'
   - from: feature-check
     to: failed
     description: Feature check failed after 3 retries — escalate to failed.
     guard:
       kind: shell
       options:
-        command: '(test "$__hitlAnswer" = no || ! $spurBin feature check $featureId) && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -ge 3'
+        command: '(test "$__hitlAnswer" = no || ! $spurBin feature check "$featureId") && test "$(cat .spur/run/$__runId-idea-ac-retry-count 2>/dev/null || echo 0)" -ge 3'
   - from: feature-check
     to: cancelled
     description: Operator cancelled the feature-check gate.
@@ -448,25 +606,32 @@ transitions:
   # Declaration order: auto-skip guard tried FIRST (like task-pipeline's review->verify pattern).
   - from: system-design
     to: decompose
-    description: profile=auto AND design_approved=true — skip design approval gate.
+    description: profile=auto AND design_approved=true AND feature check passes — skip design approval gate.
     guard:
       kind: shell
       options:
-        command: 'test "$profile" = auto && test "$design_approved" = true'
+        command: 'test "$profile" = auto && test "$design_approved" = true && $spurBin feature check "$featureId"'
   - from: system-design
     to: design-approval
     description: System design done — gate on design approval.
     guard:
       kind: always
 
-  # ── design-approval -> decompose (after operator approval) ──
+  # ── design-approval -> decompose (after operator approval), AC-failure -> feature-check ──
   - from: design-approval
     to: decompose
-    description: Design approved — proceed to decomposition.
+    description: Design approved and feature check passes — proceed to decomposition.
     guard:
       kind: shell
       options:
-        command: 'test "$__hitlAnswer" = yes'
+        command: 'test "$__hitlAnswer" = yes && $spurBin feature check "$featureId"'
+  - from: design-approval
+    to: feature-check
+    description: "Design approved but feature check fails — route back through the AC gate (revise AC, retry cap: 3)."
+    guard:
+      kind: shell
+      options:
+        command: 'test "$__hitlAnswer" = yes && ! $spurBin feature check "$featureId"'
   - from: design-approval
     to: system-design
     description: "Design rejected - revise system design (cap: 1 revise)."
@@ -526,10 +691,10 @@ transitions:
       options:
         command: 'test "$__hitlAnswer" = cancel'
 
-  # ── batch-create-run: success -> handoff, failure -> decompose (retry cap: 3), failure+cap -> failed ──
+  # ── batch-create-run: success -> handoff-finalize, failure -> decompose (retry cap: 3), failure+cap -> failed ──
   - from: batch-create-run
-    to: handoff
-    description: Batch created — handoff.
+    to: handoff-finalize
+    description: Batch created and result captured — apply ordering, refresh roster, write handoff report.
     guard:
       kind: shell
       options:
@@ -548,3 +713,10 @@ transitions:
       kind: shell
       options:
         command: 'test -f .spur/run/$__runId-idea-batch-create.failed && test "$(cat .spur/run/$__runId-idea-decompose-retry-count 2>/dev/null || echo 0)" -ge 3'
+
+  # ── handoff-finalize: -> handoff (terminal) ──
+  - from: handoff-finalize
+    to: handoff
+    description: Ordering applied, roster refreshed, handoff report written — terminal handoff.
+    guard:
+      kind: always

package/config/workflows/task-pipeline.yaml

@@ -451,7 +451,7 @@ states:
       - kind: agent.run
         options:
           agent: ${vars.agent}
-          input: /sp:dev-verify ${vars.wbs} --auto --fix all
+          input: /sp:dev-verify ${vars.wbs} --auto --fix all --focus all
           timeoutMs: ${vars.stepTimeoutMs}
           answerFile: .spur/run/${vars.wbs}-verify-answer.txt
       - kind: shell

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.43",
+    "version": "0.3.44",
     "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",

package/plugins/sp/commands/dev-runall.md

@@ -36,7 +36,9 @@ Flags: `--tasks <selector>` (required — explicit WBS list, status pseudo-list,
 or `ready`), `--feature <id>` (sugar for `feature:<id>`; when the effective selector is
 feature-derived, `dev-runall` runs `spur feature check <id> --strict --json` **once** before
 resolving tasks — a non-zero strict check aborts the batch with verdict `aborted` and the
-structured findings, before any task pipeline action, task 0510 R2), `--mode`
+structured findings, before any task pipeline action, task 0510 R2; scoped: `L4.scenario-unverified`
+(the expected pre-run state of any not-yet-run feature) is reported verbatim but does not abort —
+any other strict error aborts), `--mode`
 `<sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset —
 see `execution-batch.md` § Parallel Execution), `--keep-going`
 (batch failure policy — skip a failed task's in-batch dependents, continue independents; default

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.43",
+    "version": "0.3.44",
     "description": "Spur — a local-first harness engineering toolkit that wraps mainstream coding agents with constraint checking, workflow orchestration, and history analytics.",
     "extensions": {
         "pi": ["./hooks/pi/guard-extension.ts"]

package/plugins/sp/skills/spur-cli/SKILL.md

@@ -101,6 +101,9 @@ the whole point of this facade is that the CLI surface has a single, scalable ho
   prose checks here.
 - **Not a competency.** Design, implementation, testing, and review are competency skills, not CLI
   verbs — they are not documented here.
+- **Not the orchestration owner.** The ADR-054 boundary: this facade owns CLI noun/verb/flag
+  semantics — including task and feature status-transition verbs — while multi-step lifecycle
+  orchestration belongs to `sp:spur-dev`.
 
 ## See also
 

package/plugins/sp/skills/spur-cli/references/features/hierarchy-mece.md

@@ -117,15 +117,15 @@ If any check fails → **child of best parent** or **task under existing feature
 | --- | --- | --- |
 | Board module + UX slice as child | `F8` Features board → `F81` detail action group | **Good** — same product surface, finer grain |
 | Restructure tooling under Feature CLI | `F3` Feature management CLI → `F31` restructure kit | **Good** — not a new root letter (was root `S`, moved) |
-| Runner vs plugin integration | `B` Agent execution (`spur agent`) vs `H` Agent integration (`plugins/sp`) | **Keep separate** — Goals at `B_agent-execution.md:14` vs `H_agent-integration.md:14`; **reject merge on “agent” alone** |
+| Runtime vs plugin harness | `B` Agent execution (`spur agent`) vs `I` sp plugin (`plugins/sp`) | **Keep separate** — B owns runner/process/session/executor behavior; I owns skills, commands, subagents, hooks, and orchestration guidance. H is frozen history. |
 | Observability UX as sibling roots | `J` board + `K` System Events table redesign + `L` payload enrichment | **Reparent K,L under J** — not body-merge; not peer roots (audit 0356) |
-| Plugin epics as new letters | `N` dev-next UX, `O` token architecture as roots beside `H` | **Reparent under H** — same plugin plane, finer grain |
+| Plugin epics as new letters | Historical `N` dev-next UX and `O` token architecture | **Historical move under H is retained; new plugin work goes under I** — do not extend frozen H |
 | Workflow observability as board root | `P` workflow run observability as peer of `D` Workflows | **Reparent under D** — object is `spur workflow run`, not board J |
 | Planning validation as root | `Q` AC-verifiable gates as peer of `F` Planning | **Reparent under F** |
 | Status feedback as root | `R` feature status loop as peer of `F` | **Reparent under F** (corpus status is planning) |
 | CLI backbone vs board product | `G` Collaboration (message/team CLI) vs `M` Teams board | **Keep both** — different surfaces; do not merge |
 | One-off polish as root | New letter for “fix button loading” | **Bad** — task under existing feature |
-| Done historical epic as root | `I` sp plugin hands-off ready (`done`) | **Keep** as historical root OK; optional later neatness under H |
+| Done plugin epic as root | `I1` sp plugin hands-off ready (`done`) | **Good after reparent** — completed delivery under durable plugin root I |
 
 ### Audit 0356 snapshot (A–R dispositions)
 
@@ -144,6 +144,11 @@ Authoritative seed for restructure mapping lives in task 0356 Solution and
 
 **Rejected merges:** B∪H (name-only overlap); J∪K body-merge (use reparent for K/L).
 
+**Ownership amendment (2026-08-11):** audit 0356 is a historical snapshot. The current active
+boundary is B = runtime agent execution, I = `sp` plugin harness, H = frozen mixed history. The
+applied map is `docs/plans/2026-08-11-sp-plugin-feature-tree-restructure-map.md`; do not place new
+work under H.
+
 ---
 
 ## Checklist: before `spur feature create`

package/plugins/sp/skills/spur-cli/references/tasks.md

@@ -18,6 +18,21 @@ pipeline run) lives in **`sp:spur-dev`** — do not reimplement that loop here.
 *drive* a task through its lifecycle, reach for `sp:spur-dev`; when you need to know *which verb
 does what*, this skill.
 
+## WBS lookup fast path
+
+Start from the WBS, not the corpus layout:
+
+```bash
+spur task show <wbs> --json  # metadata + full content + filePath
+spur task path <wbs> --json  # absolute path only
+```
+
+Do not search `docs/tasks*` or guess `--folder` to locate a known WBS. `show` is the default when an
+agent needs to read a task; use `path` only when another filesystem command needs the absolute path.
+Both commands resolve across configured task folders. Add `--folder` only when deliberately limiting
+the lookup to one non-default corpus. Capture `show` once per run and reuse its response instead of
+re-reading or re-tokenizing the task.
+
 ## Verb map
 
 | Verb | Purpose | Key flags |
@@ -219,6 +234,13 @@ spur task check --strict --json     # elevate ALL warnings to failures
 spur task check 0040 --strict-core  # the testing→done gate variant
 ```
 
+**Folder resolution (task 0522):** a WBS-targeted check (`<wbs>` present, no `--folder`) resolves
+the task across **all configured task folders** — the same resolution as `task show` / `task path` /
+`task update` — so a task in an inactive configured folder is checked, not reported missing. An
+explicit `--folder <path>` is normalized to an absolute path and restricts lookup to that single
+directory (relative and absolute spellings are equivalent). Unscoped checks (no WBS) and
+`task list` remain active-folder-only.
+
 `--json` emits the structured matrix — per-task findings (missing sections, broken feature edges,
 AC-coverage orphans via L4 traceability) keyed by WBS, plus a per-task `pass` verdict. **Query this,
 do not re-derive it**: parse the JSON to answer "which tasks are ready?", "what's blocking 0040?",

package/plugins/sp/skills/spur-dev/SKILL.md

@@ -45,6 +45,10 @@ the lifecycle*; the competency skills know *how to do each job*; the CLI knows *
 The skill was decomposed **by function** (ADR-028): design, decomposition, implementation, testing,
 and verification each became a standalone competency skill, leaving this spine to orchestrate them.
 
+**Ownership (ADR-054).** This spine owns multi-step lifecycle orchestration — intake, gates,
+decomposition, pipeline runs, HITL pauses. CLI noun/verb/flag semantics, including
+status-transition verbs, are the facade's (`sp:spur-cli`), never this skill's.
+
 **The competencies the spine dispatches:**
 
 | Unit of work | Competency skill |
@@ -154,13 +158,17 @@ CLI does.
    you ship corrupted corpus.
 2. **The pipeline, not you, writes results.** `## Testing` and `## Review` sections are
    filled by the pipeline's `record` step. Do not edit them directly during execution.
-3. **Check before every write.** Run `spur task check <wbs> --json` to know what sections
+3. **Resolve task IDs through the CLI.** Read a known WBS with `spur task show <wbs> --json`; it
+   returns metadata, full content, and `filePath` across configured task folders. Use `spur task
+   path <wbs> --json` only when another tool needs the absolute path. Never search `docs/tasks*` or
+   guess `--folder`; reuse the first `show` response throughout the run.
+4. **Check before every write.** Run `spur task check <wbs> --json` to know what sections
    the task needs at its current status. Guessing produces matrix violations.
-4. **AC titles are identity keys.** Renaming a scenario after tasks are created breaks
+5. **AC titles are identity keys.** Renaming a scenario after tasks are created breaks
    traceability edges. If you must rename, update the task's scenario references too.
-5. **Batch-create is atomic.** A single schema violation rejects the entire batch. Validate
+6. **Batch-create is atomic.** A single schema violation rejects the entire batch. Validate
    locally against `task-batch.schema.json` before invoking the CLI.
-6. **Two-halves seam.** The planning and execution halves share this skill today but are
+7. **Two-halves seam.** The planning and execution halves share this skill today but are
    designed to split cleanly. Keep new logic in one half or the other — never straddle the
    seam with cross-half dependencies.
 

package/plugins/sp/skills/spur-dev/references/dev-operations.md

@@ -288,7 +288,7 @@ must not be changed without updating the backing skill.
 ### 13. runall
 
 - **Purpose:** Run a batch of tasks through their pipelines in dependency-correct order — resolve a set, topo-sort, run each via `task-pipeline.yaml`, inspect verdicts, apply the failure policy, emit a batch report.
-- **Inputs:** `--tasks <selector>` (required — explicit WBS list, status pseudo-list, `feature:<id>`, or `ready`). `--mode <sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset per `execution-batch.md` § Parallel Execution). `--keep-going` skips a failed task's in-batch dependents and continues independents (default halts on first failure). `--auto` sets `profile=auto` on each per-task run (skips the HITL approve gate). `--feature <id>` is sugar for `--tasks feature:<id>`; when the effective selector is feature-derived, the batch runs `spur feature check <id> --strict --json` **once** before task resolution — a non-zero strict check aborts with verdict `aborted`, zero attempted tasks, and the structured findings (task 0510 R2). Explicit WBS/status/`ready` selectors add no feature check. The orchestrator loop itself continues in this session; interactive sequential omit/`inline` uses the host driver — host-controlled with eligible `agent.run` stages dispatching once to a native subagent and host fallback (task 0508) — while `--agent auto`/a name, parallel mode, and headless invocation keep the isolated per-task workflow subprocess boundary. `--agent <inline|auto|name>` pins the executor for the per-task stages (see [SSOT](cross-cutting.md#inline-default-execution-surface)); the value crosses into per-task `vars.agent`, not the orchestrator. `--json` emits the report as JSON. `--wrap` triggers `wrapup-pipeline.yaml` after the batch completes, `--next` chains each task to terminal status then runs the wrap hop **once for the batch**, `--continue` resumes from checkpoint.
+- **Inputs:** `--tasks <selector>` (required — explicit WBS list, status pseudo-list, `feature:<id>`, or `ready`). `--mode <sequential|parallel>` (default `sequential`; `parallel` fans out a proven-independent subset per `execution-batch.md` § Parallel Execution). `--keep-going` skips a failed task's in-batch dependents and continues independents (default halts on first failure). `--auto` sets `profile=auto` on each per-task run (skips the HITL approve gate). `--feature <id>` is sugar for `--tasks feature:<id>`; when the effective selector is feature-derived, the batch runs `spur feature check <id> --strict --json` **once** before task resolution — a non-zero strict check aborts with verdict `aborted`, zero attempted tasks, and the structured findings (task 0510 R2); scoped: `L4.scenario-unverified` (expected pre-run state of any not-yet-run feature) is reported verbatim but does not abort — any other strict error aborts. Explicit WBS/status/`ready` selectors add no feature check. The orchestrator loop itself continues in this session; interactive sequential omit/`inline` uses the host driver — host-controlled with eligible `agent.run` stages dispatching once to a native subagent and host fallback (task 0508) — while `--agent auto`/a name, parallel mode, and headless invocation keep the isolated per-task workflow subprocess boundary. `--agent <inline|auto|name>` pins the executor for the per-task stages (see [SSOT](cross-cutting.md#inline-default-execution-surface)); the value crosses into per-task `vars.agent`, not the orchestrator. `--json` emits the report as JSON. `--wrap` triggers `wrapup-pipeline.yaml` after the batch completes, `--next` chains each task to terminal status then runs the wrap hop **once for the batch**, `--continue` resumes from checkpoint.
 - **Three orthogonal axes (do not confuse):** `--keep-going` = batch failure policy (halt vs skip dependents); `--continue` = resume from checkpoint (pick up an interrupted batch); `--next` = per-task lifecycle chaining (advance status on a verdict — `dev-verify`/`dev-verifyall` only). `routing-table.md` offers `--continue` and `--next` as competing options for the same situation only when the batch was interrupted mid-run; otherwise they address different problems.
 - **Backing:** `sp:spur-dev` skill, `runall` operation → delegates the driver loop to the **`sp:super-planner`** agent (the batch orchestrator).
 - **Behavior:** The orchestrator reads [execution-batch.md](execution-batch.md) and drives: resolve selector → freeze set → topo-sort by `dependencies[]` (Kahn, WBS-ascending tie-break; cycle aborts) → resolve out-of-set deps by status (done → allow, else → block subtree) → run each task via `spur workflow run task-pipeline.yaml --async` + `spur workflow trace` polling → inspect terminal state + `.spur/run/<wbs>-verdict.json` → stop-the-batch default or `--keep-going` subtree skip → emit batch report. Per-task pipeline is invoked **verbatim** — no new FSM, no step edits. `--auto`/`--agent` are the only flags that cross the orchestrator→pipeline boundary (both into per-task `--vars`).