@gobing-ai/spur 0.3.93 → 0.3.95

package/plugins/sp/skills/session-review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: session-review
-description: "Review the active coding-agent session: separate resolved from open issues with evidence, propose bounded improvements. With --triage, apply pure-doc / 1–2-line fixes inline and file the rest as one task. Triggers: review this session, wrap-up, triage findings."
+description: "Review the active coding-agent session: separate resolved from open issues with evidence, propose bounded improvements. With --triage, apply pure-doc / 1–2-line fixes inline and file the rest as one or more tasks. Triggers: review this session, wrap-up, triage findings."
 license: Apache-2.0
 version: 1.1.0
 metadata:
@@ -31,7 +31,7 @@ cross-agent windows, recurrence, trends, or quantitative performance forensics.
 | Argument | Description | Default |
 | --- | --- | --- |
 | `[focus]` | Question or operation to emphasize. It changes ordering, not evidence collection. | full active session |
-| `--triage` | Opt into bounded remediation after the report: apply direct fixes (pure docs / one-to-two-line fixes) inline, then file all remaining actionable findings as exactly one new task via the CLI-gated corpus surface. | off (report-only) |
+| `--triage` | Opt into bounded remediation after the report: apply direct fixes (pure docs / one-to-two-line fixes) inline, then file all remaining actionable findings as one or more implement-ready tasks via the CLI-gated corpus surface. | off (report-only) |
 
 ## Evidence boundary
 
@@ -64,13 +64,15 @@ three buckets — never skip triage and start fixing from the raw findings list.
    - **Note** — pre-existing, environmental, or ownerless observations; report only.
 2. **Apply direct fixes inline** — smallest surgical diff, project style, and re-verify each
    with the targeted check (lint / test / the exact command that exhibited the issue).
-3. **Create exactly one task** for the Task bucket through the CLI-gated corpus surface
-   (`spur task create`, then `spur task update <wbs> --section <s> --from-file` per section).
-   One task, not one per finding: each finding keeps its evidence, a suggested fix direction,
-   and an AC where verifiable. Exclude what direct fixes already resolved — say so in the task
-   Background instead.
+3. **File the Task bucket as one or more tasks** by the shared filing rule in
+   [dev-operations.md § 2. review](../spur-dev/references/dev-operations.md#2-review) (Triage
+   step 3): one task per cohesive unit one agent can implement and verify in one run, under the
+   existing feature that owns the surface (never a new root feature), implement-ready, written
+   only through `spur task create --skip-ready` + `spur task update <wbs> --section <s> --from-file`.
+   Not one task per finding: each finding keeps its evidence, fix direction, and an AC where
+   verifiable. Exclude what direct fixes already resolved — say so in the task Background.
 4. **Report** — add a Triage section: applied fixes (path + one-line what + verification) and
-   the created task WBS. The Resolved/Open tables keep their evidence rules unchanged.
+   each created task WBS. The Resolved/Open tables keep their evidence rules unchanged.
 
 ## Protocol
 
@@ -156,7 +158,7 @@ improvement. Use `None` when the session is complete and no follow-up is justifi
   to imported-history analysis.
 - Report-only by default: do not create or update corpus items or edit files. The single exception
   is `--triage` mode, which permits exactly two mutation classes — direct fixes from the triage
-  bucket, and the one triage task. Anything beyond that stays a proposal.
+  bucket, and the triage tasks. Anything beyond that stays a proposal.
 - Do not turn a single low-impact observation into a new policy. Report it as a candidate until it
   recurs or demonstrates a high-impact contract violation.
 

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

@@ -156,7 +156,7 @@ backfill, and a lifecycle transition. Collapses the pipeline's record step to on
 | ---- | ------ |
 | `--verdict-file <path>` | Verdict JSON (default `.spur/run/<wbs>-verdict.json`). |
 | `--solution-from-diff` | Backfill `Solution` from `git diff -U0` **only when Solution is bare**. |
-| `--transition <status>` | Optional lifecycle transition after writing. **Never `done`.** |
+| `--transition <status>` | Optional lifecycle transition after writing. `done` is a **guarded** path: it requires a PASS verdict, auto-walks `wip → testing → done`, and auto-creates the pipeline run-link; a non-PASS verdict errors instead of transitioning. |
 
 **Verdict shape** (`.spur/run/<wbs>-verdict.json`):
 
@@ -334,6 +334,14 @@ column to distinguish AC rows from requirement rows:
 `Status`: `MET` | `PARTIAL` | `UNMET` | `N/A`. `Evidence Type`: `test` | `command` | `static-ref`
 (or `static`) | `manual-review` (or `manual`) | `llm-judge` (or `judge`) | `n/a` (or `na`).
 
+**Graduating tasks — one row keyed to both checks (0993).** A task whose linked feature has
+`ac_altitude: graduating` must satisfy two independent id spaces: the feature scenario alias
+`AC-<i>` (which credits the scenario) and the task checkbox id `AC<i>` (which the box flip needs).
+Key the row **`AC<n> — <scenario title>`**, omitting the scenario's own `R<n>` label — then one row
+does both: `normalizeTitle` strips the `AC<n>` prefix so the row still matches the scenario title,
+and `prefixId` normalizes `AC<n>` so the box flips. A bare `AC<n>` credits no scenario; a bare
+`AC-<i>` flips no box; a title carrying the scenario's `R<n>` label matches neither.
+
 **Evidence rule (behavior-bearing AC):** an AC row with `status: MET` on a behavior-bearing id
 (no `[advisory]`/`[non-core]`/`[non-behavior]`/`[docs-only]` marker) MUST carry `test` or
 `command` evidence; any other evidence type downgrades the row to `PARTIAL` and caps the verdict.

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

@@ -68,7 +68,7 @@ each would be scope creep for one-liner procedures.
 | #   | Operation  | Command             | Backing           | Skill / Verb                                                                       | Arg-hint                                                                                                                                                                                               |
 | --- | ---------- | ------------------- | ----------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | 1   | unit       | `dev-unit`          | `Skill()`         | `sp:code-testing`                                                                  | `<target> [--coverage <pct>] [--agent <inline\|auto\|name>] [--auto]`                                                                                                                                  |
-| 2   | review     | `dev-review`        | `Skill()`         | `sp:code-verification` (`review`) + `sp:functional-review` + `sp:code-improvement` | `[<wbs\|path>] [--agent <inline\|auto\|name>] [--focus <dims>] [--fix (deprecated)]`                                                                                                                   |
+| 2   | review     | `dev-review`        | `Skill()`         | `sp:code-verification` (`review`) + `sp:functional-review` + `sp:code-improvement` | `[<wbs\|path>] [--agent <inline\|auto\|name>] [--focus <dims>] [--triage] [--worktree [<name>]]`                                                                                                       |
 | 3   | verify     | `dev-verify`        | `Skill()`         | `sp:code-verification` (`verify`)                                                  | `<wbs> [--agent <inline\|auto\|name>] [--fix <none\|blockers-first\|all>] [--focus <lens>] [--bdd] [--auto] [--force] [--next] [--skip-shippable]`                                                     |
 | 3a  | verifyall  | `dev-verifyall`     | `Skill()` → agent | `sp:spur-dev` (`verifyall`)                                                        | `--tasks <selector> [--feature <id>] [--agent <inline\|auto\|name>] [--fix <none\|blockers-first\|all>] [--focus <lens>] [--bdd] [--auto] [--force] [--next] [--json] [--skip-shippable] [--worktree [<name>]]` |
 | 4   | run        | `dev-run`           | `Skill()`         | `sp:spur-dev` (`run` / `implement`)                                                | `<wbs> [--mode <full\|implement>] [--agent <inline\|auto\|name>] [--auto] [--next] [--wrap] [--continue] [--worktree [<name>]]`                                                                                              |
@@ -116,7 +116,13 @@ must not be changed without updating the backing skill.
 - **Modes:**
   - **WBS mode (`<wbs>`)**: Runs functional requirements traceability (`sp:functional-review`), SECUA framework (`sp:code-verification`), and architectural depth (`sp:code-improvement`). The three skills return review fragments; the coordinator writes the combined `## Review` (F92 0593 R1).
   - **Path mode (`<path>`)**: Runs advisory SECUA framework (`sp:code-verification`) and architectural depth (`sp:code-improvement`). Performs no task mutation.
-- **Inputs:** `<wbs|path>` (required). Review executes inline (in-session) by default. `--agent <inline|auto|name>` selector accepted (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--focus <lens>` narrows to one SECUA dimension. Note: `--fix` and `--next` are **deprecated** (no-op with warning; route remediation to `/sp:dev-verify --fix` and progression to `/sp:dev-next`).
+- **Inputs:** `<wbs|path>` (required). Review executes inline (in-session) by default. `--agent <inline|auto|name>` selector accepted (see [SSOT](cross-cutting.md#inline-default-execution-surface)). `--focus <lens>` narrows to one SECUA dimension. `--triage` opts into bounded remediation after the report (below). `--worktree [<name>]` isolates the triage writes (below; requires `--triage`). Note: `--fix` and `--next` are **deprecated** (no-op with warning; route remediation to `--triage` or `/sp:dev-verify --fix` and progression to `/sp:dev-next`). The task pipeline's review stage never passes `--triage` or `--worktree`.
+- **Triage (`--triage`):** runs inline in the invoking session after the merged report — never inside `sp:super-reviewer` or the review skills, which stay report-only. With `--agent <name>`, only the review is delegated; triage still runs inline on the returned findings. Never fix straight from the raw findings list:
+  1. **Bucket every finding exactly once.** **Direct fix** — local, low-risk, obvious root cause: no design choice, no public-surface / schema / dependency change, not a shared write path, verifiable by a targeted check (docs, a guard, a missing throw, a wrong path helper, a stale comment). **Task** — real and actionable but needs design, crosses modules, touches a public surface, or is not verifiable locally; skip it when an existing task already owns it (cite that WBS). **Note** — pre-existing, environmental, or ownerless; report only.
+  2. **Apply direct fixes** — smallest surgical diff in project style, then re-verify each with its targeted check (focused test, lint, or the exact command that exhibited the defect). A fix that grows beyond the bar or fails its check moves to the Task bucket with what was learned; do not leave it half-applied.
+  3. **File the Task bucket as one or more tasks**, one per cohesive unit of work that one agent can implement and verify in one run — split unrelated fixes, merge findings that share a root cause or file set. File under the existing feature that owns the affected surface; if none fits, create a child feature under the closest existing parent — never a new root feature. Write through the CLI-gated corpus surface only (`spur task create --feature <id> --skip-ready`, then `spur task update <wbs> --section <s> --from-file`). Each task must meet the implement-ready bar ([§ 5. refine](#5-refine), `--depth ready`) so it cannot drift: per finding the evidence (`file:line`), the defect, the chosen fix direction with rejected alternatives, file targets, AC, and out-of-scope; promote `backlog → todo` only when `spur task check <wbs> --json` is clean. Name what the direct fixes already resolved in each task's Background.
+  4. **Gate and report.** Run the project gate once after the direct fixes. Report a Triage section: each applied fix (path + one-line what + verification), each filed task (WBS + feature + scope), and the Notes. Never commit or create a branch outside `--worktree`.
+- **Worktree (`--worktree [<name>]`):** omitted → all writes land in the current working tree on the current branch; no branch creation, checkout, or commit (the operator commits). Given → the [execution-batch.md § Worktree isolation](execution-batch.md#worktree-isolation---worktree-name) lifecycle as a run of one: marker `command` = `dev-review`, `selector` = the review target, derived branch/directory slug = the WBS or the path's basename (`sp/review-<slug>-<short-id>`). Admission is "the target resolves" (a known WBS or an existing path) — no `quickReadiness` task-set check. Review and triage both run in the tree; WT-3b commits the fixes and filed tasks. The WT-4 success condition reads as "every direct fix passed its check and the project gate is green"; a failed check or gate takes the WT-5 retention path. Rejected without `--triage` (WT-7) — to review another worktree read-only, pass a path inside it.
 - **Backing:** `sp:functional-review`, `sp:code-verification` (review mode), `sp:code-improvement`.
 - **Behavior:** WBS mode runs functional traceability + SECUA + architecture depth, ranking findings P1–P4, and hands the merged report to the review coordinator, which writes `## Review`. Component skills never write `## Review` in coordinated mode. Path mode runs advisory SECUA + architecture depth with no task mutation.
 - **Delegation:** WBS mode: `sp:functional-review` + `sp:code-verification` (review) + `sp:code-improvement`; Path mode: `sp:code-verification` (review) + `sp:code-improvement`.

package/plugins/sp/skills/spur-dev/references/execution-batch.md

@@ -490,16 +490,41 @@ Evidence persistence precedes destructive cleanup: a persistence failure (unread
 disk-full, missing directory) routes to **WT-5** — the worktree and branch are retained so a green
 batch can never destroy its own evidence. Reuse mode retains its operator-owned tree but still
 persists the Step 5 report under the invoking tree; the reused tree's `.spur/run/` remains the live
-copy while that tree lives on.
-
-**Stage records are worktree-local too (0948 R9, E7 Finding 5).** The persisted report and verdict
-JSONs above are the batch's *summary* evidence. Each task's own per-stage run record
-(`.spur/run/<runId>.md` + `.state.json`, plus gate/answer artifacts) is written inside the
-worktree's `.spur/run/` and **is removed with the worktree** in create mode. A merged batch
-therefore leaves no per-stage run record in the invoking tree unless it is copied out. Anything
-auditing "what did this batch actually run?" must copy those records out **before** WT-4 removal —
-the E7 batch lost exactly this evidence this way. The rule is the same one above: copy out first,
-then remove; a copy failure retains the worktree.
+copy while that tree lives on. The per-run provenance — the worktree DB's run/action rows and the
+`.spur/run/<runId>.md` + `.state.json` records — is persisted mechanically by WT-4a's
+`inline-run-setup.ts --persist-out --from <worktree> [--task-file <merged-task>]...` call,
+not by hand.
+
+**Stage records are worktree-local too (0948 R9, E7 Finding 5; persisted by 0975 R1).** Each task's
+own per-stage run record (`.spur/run/<runId>.md` + `.state.json`) and the worktree DB's run rows are
+written inside the worktree and **are removed with it** in create mode — the E7 batch lost exactly
+this evidence. Copying them out is no longer a manual audit-time duty: WT-4a (create-mode block
+below) runs `inline-run-setup.ts --persist-out --from "$WT_PATH"` **before** WT-4b holder cleanup,
+which copies the run/action/phase/transition/workflow-state rows and both record files into the
+invoking tree.
+
+**Cited evidence rides the same call (0984 R1/R2).** The driver forwards each merged task file with
+repeatable `--task-file <path>` (paths resolved in the invoking tree after the FF merge, e.g.
+`spur task show <wbs> --json` → `.filePath`), and persist-out then copies/verifies every literal
+`.spur/run/<file>` that file cites — WBS verdicts, check receipts, test-gate logs, run-ID records —
+so a merged task file never anchors a path that died with the tree. Abbreviated references
+(`fadca099-…`, `run-*-ac87.log`, `{batch-report.md,…}`) are not literal files and carry no
+obligation; neither do root-qualified paths (`knowledge-kit/.spur/run/…`, `/abs/.spur/run/…`),
+which cite another project's evidence — cite foreign run artifacts that way, never bare. A citation missing in BOTH trees, a divergent cited file (never overwritten — reconcile
+by hand), an unreadable task file, or more than 64 distinct cited files fails the pass → WT-5.
+
+The shapes are pinned (task 0975 R1; `record-missing` and citation behavior per 0984): idempotent on re-persist;
+success exits 0 printing
+`{"ok":true,"persisted":<n>,"skipped":[{"id":<run-id>,"reason":"id-exists"|"external-key-conflict"|"record-conflict:<file>"|"record-missing:<file>"|"cited-directory:<name>"|"cited-symlink:<name>"|"cited-non-file:<name>"}]}`
+— an `id-exists` / `external-key-conflict` skip never modifies the pre-existing target rows, a
+`record-conflict:<file>` skip never overwrites a divergent invoking-tree record, and a
+`record-missing:<file>` skip is a known `task-lifecycle`/`feature-lifecycle` row with no record file
+at all (its inserted DB row still counts in `persisted` — 0984 R5). Any failure
+exits 1 printing `{"ok":false,"error":<message>}` (a worktree DB run id that is not a single safe
+filename component is rejected before any target write). Any persist-out failure
+routes to **WT-5** — worktree and branch retained — the same copy-out-first contract as the
+verdict persistence above. After a green persist-out, `spur workflow progress --json` in the
+invoking tree shows the merged run `done` with its per-action rows.
 
 ## Step 6 — Batch wrap (`--wrap` / `--next`) (F96 task 0952 R1)
 
@@ -538,7 +563,7 @@ all subsequent tools, agents, task/feature writes, and run artifacts use the con
 tree's cwd. A stale or empty selector, an unsupported mode, or an invalid target creates no tree and
 no marker (WT-2/WT-7), and the required Git safety checks (WT-1) still precede creation.
 
-> **Command wiring (task 0814 R3).** The four worktree-capable commands (`dev-run`, `dev-runall`,
+> **Command wiring (task 0814 R3).** The four task-set worktree commands (`dev-run`, `dev-runall`,
 > `dev-refineall`, `dev-verifyall`) each call `quickReadiness` with their operation (`run`/`refine`/
 > `verify`), the resolved selector/status, and the filtered-set size **before** WT-1/WT-2. The
 > admission outcome gates the tree: an invalid/empty selector, unsupported mode, or a target that
@@ -557,6 +582,13 @@ non-PASS verify verdict, or a HITL pause that ends the run take the WT-5 retenti
 full pipeline is eligible — `--worktree --mode implement` is rejected (WT-7), because that mode is
 the pipeline's implement stage and already runs in the driver's tree.
 
+**Review triage `dev-review` (run of one).** `/sp:dev-review <target> --triage --worktree [<name>]`
+runs this lifecycle around one review-plus-triage pass: WT-1…WT-6 apply unchanged, the marker's
+`command` is `dev-review` and its `selector` is the review target, and the slug is the WBS or the
+path's basename (`sp/review-<slug>-<short-id>`). It skips `quickReadiness` (there is no task set;
+admission is "the target resolves"). WT-4 success reads as "every direct fix passed its check and the
+project gate is green"; anything else takes WT-5. Contract: [dev-operations.md § 2. review](dev-operations.md#2-review).
+
 One flag, two modes (see the glossary entry for the ownership rule). Bare `--worktree` is **create
 mode** (cut a fresh branch + sibling tree). `--worktree <name>` is **reuse mode** (attach to a tree
 that already exists); name resolution (§ WT-2 below) runs before WT-1. The deltas each mode applies
@@ -805,13 +837,27 @@ git checkout "$BASE_REF"
 [ "$(git rev-list --count "$BASE_SHA..$BRANCH")" -gt 0 ] \
   || { echo "halt: branch carries no commits - nothing to merge" >&2; false; }   # -> WT-5
 git merge --ff-only "$BRANCH"          # FF-only: never rebase, merge-commit, or resolve conflicts
-# if FF succeeded — WT-4a evidence persistence (Step 5, task 0720 R3) runs FIRST:
-# persist the batch report + verdict artifacts into the invoking tree's .spur/run/
-# before anything below touches the worktree. Persistence failure routes to WT-5.
+# if FF succeeded — WT-4a evidence persistence runs FIRST (Step 5, task 0720 R3):
+# persist the batch report + verdict artifacts AND the per-run provenance (task
+# 0975 R1) into the invoking tree before anything below touches the worktree.
+# Any persistence failure routes to WT-5 — the worktree and branch are retained.
+WT_PATH="$(cd "../<worktree-dir>" && pwd)"   # hoisted: needed by WT-4a AND WT-4b below
+# WT-4a provenance persist-out (task 0975 R1): copy the worktree DB's run rows plus
+# the .spur/run/<runId>.md + .state.json records into THIS tree. Run from the main
+# tree (cwd = the invoking tree). --task-file (0984 R2) forwards each merged task
+# file (post-merge path) so the cited .spur/run/<file> evidence is copied/verified
+# too. Resolve the merged path(s) BEFORE this block — an empty value exits 2:
+#   TASK_FILE="$(spur task show <wbs> --json | jq -r .filePath)"   # per done task;
+#   build TASK_FILE_ARGS=(--task-file "$TASK_FILE")                # one flag each
+# Idempotent; conflicts are reported, never overwritten. A non-zero exit —
+# including an unresolved or divergent citation, or a half-readable worktree — must
+# NOT proceed to WT-4b removal:
+SETUP_SCRIPT=plugins/sp/scripts/inline-run-setup.ts; [ -f config/plugin-scripts.json -a -f "$SETUP_SCRIPT" ] || SETUP_SCRIPT="$(superskill script path sp inline-run-setup.mjs 2>/dev/null)"
+bun "$SETUP_SCRIPT" --persist-out --from "$WT_PATH" "${TASK_FILE_ARGS[@]}" \
+  || { echo "halt: worktree run-record persist-out failed - worktree retained (WT-5)" >&2; exit 1; }
 #
-# WT-4b — bounded CWD-holder cleanup (task 0720 R1). Resolve the EXACT absolute
-# worktree path; a relative path or a stale entry matches the wrong processes.
-WT_PATH="$(cd "../<worktree-dir>" && pwd)"
+# WT-4b — bounded CWD-holder cleanup (task 0720 R1). $WT_PATH above is the EXACT
+# absolute worktree path; a relative path or a stale entry matches the wrong processes.
 # Holders = processes with any open fd under the worktree tree (lsof +D walks the
 # tree; CWD holders are the common case but +D also catches open-file holders —
 # over-match errs toward removal success; a plain -t <dir> matches only the
@@ -976,6 +1022,8 @@ fallback, because `<name>` was explicit and unambiguous intent.
 - **`--mode implement`** is rejected when combined with `--worktree` on `dev-run` — that mode *is*
   the pipeline's implement stage (bug-742) and runs in whatever tree the driver set up; a second
   worktree would split one task's evidence across two trees.
+- **`dev-review` without `--triage`** is rejected when combined with `--worktree` — a read-only
+  review writes nothing worth isolating; review another worktree by passing a path inside it.
 - **No** create-with-name (`--worktree <name>` never creates; an unresolvable name is an error),
   no `--worktree-keep` variant, no auto-cleanup of stale worktrees or markers from prior runs.
 

package/plugins/sp/skills/spur-dev/references/flag-glossary.md

@@ -410,6 +410,17 @@ Full checklist: [dev-operations.md](dev-operations.md) § refine (depth ready).
 Use the task's Gherkin scenarios as the verification lens on verify-family commands (`dev-verify`,
 `dev-verifyall`).
 
+### `--triage` — fix small findings, file the rest as tasks
+
+**Anchor:** `#flag-triage`.
+
+Review commands (`dev-review`, `dev-review-session`): after the report, bucket every finding once
+(direct fix / task / note), apply the direct fixes inline with a targeted check each, and file the
+remainder through `spur task` — never fix straight from the raw findings list. Off by default
+(report-only). Both file one or more implement-ready tasks sized per cohesive unit, under existing
+features ([dev-operations.md § 2. review](dev-operations.md#2-review)); `dev-review-session` keeps
+the stricter direct-fix bar (pure docs / one-to-two-line fixes).
+
 ### `--approve-taste` — pre-clear all taste gates this run
 
 **Anchor:** `#flag-approve-taste`.
@@ -422,9 +433,11 @@ flag sets both.
 
 **Anchor:** `#flag-worktree`.
 
-Batch commands plus single-task `dev-run` (`dev-refineall`, `dev-runall`, `dev-verifyall`,
-`dev-run`): run the entire driver loop inside an isolated git worktree instead of the operator's
-working directory. One flag, two modes:
+Batch commands plus single-task `dev-run` and review triage (`dev-refineall`, `dev-runall`,
+`dev-verifyall`, `dev-run`, `dev-review`): run the entire driver loop inside an isolated git
+worktree instead of the operator's working directory. On `dev-review` the flag requires `--triage`
+and wraps the review-plus-triage pass
+([dev-operations.md § 2. review](dev-operations.md#2-review)). One flag, two modes:
 
 - **Create mode** — bare `--worktree` (no value). Cut a fresh branch from the current HEAD's ref,
   create a sibling worktree with a derived name, run the batch there. On a fully successful batch

package/plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md

@@ -76,11 +76,14 @@ the human/native presentation layer — labels are display addresses only, never
    accept the inline run (0785 R3):
 
    ```bash
-   SETUP_SCRIPT="plugins/sp/scripts/inline-run-setup.ts";
-   [ -f "$SETUP_SCRIPT" ] || SETUP_SCRIPT="$(superskill script path sp inline-run-setup.mjs 2>/dev/null)";
+   SETUP_SCRIPT=plugins/sp/scripts/inline-run-setup.ts; [ -f config/plugin-scripts.json -a -f "$SETUP_SCRIPT" ] || SETUP_SCRIPT="$(superskill script path sp inline-run-setup.mjs 2>/dev/null)";
+   # 0960 R2: record the run's script-resolution identity beside the run row (the same file the
+   # pipelines' run-start action writes) so the inline path carries the same provenance.
+   RS=plugins/sp/scripts/script-root.ts; [ -f config/plugin-scripts.json -a -f "$RS" ] || RS="$(superskill script path sp script-root.mjs 2>/dev/null)";
+   RUNNER=bun; case "$RS" in *.mjs) RUNNER=node ;; esac; [ -f "$RS" ] && "$RUNNER" "$RS" --run-id "$RUN_ID" || echo "script-root failed closed — run 'superskill install sp --marketplace gobing-ai/spur'" >&2
    [ -n "$SETUP_SCRIPT" ] && [ -f "$SETUP_SCRIPT" ] && \
      bun "$SETUP_SCRIPT" --run-id "$RUN_ID" --file <selected-pipeline-yaml> \
-     || { echo "inline run setup failed closed — checker not found; run 'superskill install sp'" >&2; exit 1; }
+     || { echo "inline run setup failed closed — checker not found; run 'superskill install sp --marketplace gobing-ai/spur'" >&2; exit 1; }
    ```
 
    The delegate uses the source app service when the SPUR_BIN chain identifies a checkout;
@@ -511,7 +514,10 @@ The driver reaches it through the existing run delegate (`$SETUP_SCRIPT`,
   against the project workdir. The decision never pauses and never fails the run for model
   problems: a degraded outcome (feature switch off, no backend, error, timeout, low confidence)
   prints `ok:true` with `degraded:true`, the declared `reason`, and `value = default`, and exits
-  `0` — route on the resultFile's `.value` with the declared file guards. Only an invalid options
+  `0` — route on the resultFile's `.value` with the declared file guards. Every row carries
+  `source: model|default` (0976 R2), and the delegate appends
+  `decide node=<id> value=<v> source=<s> reason=<r>` to the run log, so a declared-default
+  fallback is never read as a model decision. Only an invalid options
   schema exits `1` (fail closed), and usage errors exit `2`. The `action_runs` trace row is
   best-effort exactly like `--action`.
 
@@ -524,7 +530,18 @@ The driver reaches it through the existing run delegate (`$SETUP_SCRIPT`,
   ```
 
   `--status` is the declared terminal state's verdict, not a guess: a run that reached a terminal
-  state is `done`; a run halted by a failing action under its error policy is `failed`.
+  state is `done`; a run halted by a failing action under its error policy is `failed`. On success
+  the close reports the recorded evidence: `{"ok":true,"runId":…,"actionRows":<n>}`.
+
+  **Zero-row done closes are a named failure (task 0975 R2).** A run closed `done` with **zero**
+  `action_runs` rows (`actionRows:0`) finalizes the row but exits `1` with
+  `{"ok":false,"code":"NO_ACTION_ROWS","actionRows":0}` — a run that claims success without a
+  single recorded action is exactly the untraced-runs gap ADR-117 closes, so the driver must
+  surface the code in its final report instead of reporting a clean close. The failure must NOT
+  be repaired by backfilling rows: the run row is already terminal, and hand-written rows are
+  forbidden (ADR-117) — record the finding and let the task's evidence show the gap. A `failed`
+  close with zero rows stays a clean `0` (a halt before the first boundary legitimately records
+  nothing), and any `done` close with `actionRows ≥ 1` exits `0`.
 
 **Best-effort at the action boundary only (ADR-117).** An `--action` persistence failure is
 recorded — the delegate appends a `trace-emission-failed` line to `.spur/run/<run-id>.md` and

package/plugins/sp/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../tooling/typescript/base.json",
+    "compilerOptions": {
+        "types": ["bun"],
+        "paths": { "@gobing-ai/spur-app": ["../../packages/app/src/index.ts"] }
+    },
+    "include": ["**/*.ts"]
+}