@gobing-ai/spur 0.3.94 → 0.3.95

package/plugins/sp/scripts/wrapup-steps.mjs

@@ -172,6 +172,31 @@ function readFileSyncSafe(path) {
     return null;
   }
 }
+function verdictFromTestingSection(content) {
+  const heading = /^#{1,6}\s+Testing\s*$/m.exec(content);
+  if (!heading)
+    return null;
+  const level = heading[0].match(/^#+/)?.[0]?.length ?? 2;
+  const rest = content.slice(heading.index + heading[0].length);
+  const next = new RegExp(`^#{1,${level}}\\s+\\S`, "m").exec(rest);
+  const section = next ? rest.slice(0, next.index) : rest;
+  for (const line of section.split(`
+`)) {
+    const m = /^(?:-\s*|\*\*)?Verdict:\s*(PASS|PARTIAL|FAIL|UNKNOWN)\b/i.exec(line.trim());
+    if (m?.[1] !== undefined)
+      return m[1].toUpperCase();
+  }
+  return null;
+}
+function verdictOfArtifact(verdictPath) {
+  try {
+    const raw = jqPick(JSON.parse(readFileSync(verdictPath, "utf8")).verdict, "");
+    const text = jqText(raw);
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+}
 function runMetrics(env, options = {}) {
   const cwd = options.cwd;
   const runId = env.__runId ?? "";
@@ -212,15 +237,13 @@ function runMetrics(env, options = {}) {
     const frontmatter = parsed.frontmatter !== null && typeof parsed.frontmatter === "object" ? parsed.frontmatter : {};
     const featureId = String(jqPick(frontmatter.feature_id, parsed.feature_id, ""));
     const status2 = String(jqPick(frontmatter.status, parsed.status, "unknown"));
-    let verdict = "UNKNOWN";
     const verdictPath = join(".spur", "run", `${wbs}-verdict.json`);
-    if (existsSync(abs(verdictPath))) {
-      try {
-        const raw = jqPick(JSON.parse(readFileSync(abs(verdictPath), "utf8")).verdict, "UNKNOWN");
-        const text = raw === "UNKNOWN" ? "UNKNOWN" : jqText(raw);
-        if (text.length > 0)
-          verdict = text;
-      } catch {}
+    const artifactVerdict = verdictOfArtifact(abs(verdictPath));
+    const trackedVerdict = verdictFromTestingSection(typeof parsed.content === "string" ? parsed.content : "");
+    const verdict = artifactVerdict ?? trackedVerdict ?? "UNKNOWN";
+    if (verdict === "UNKNOWN") {
+      process.stderr.write(`metrics-record: task ${wbs} has no certifying verdict \u2014 ${verdictPath}: ${artifactVerdict ?? "missing or carries none"}, tracked Testing: ${trackedVerdict ?? "no Verdict: line"} \u2014 recording UNKNOWN telemetry
+`);
     }
     const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
     const row = { wbs, feature_id: featureId, status: status2, verdict, timestamp };
@@ -403,6 +426,7 @@ function main(argv, env = getEnvVars(), options = {}) {
 }
 export {
   writeRouteReason,
+  verdictFromTestingSection,
   taskStatusOf,
   spurCommand,
   runMetrics,

package/plugins/sp/scripts/wrapup-steps.ts

@@ -269,6 +269,49 @@ function readFileSyncSafe(path: string): string | null {
     }
 }
 
+/**
+ * Verdict from a task record's tracked `Testing` section — the durable copy that outlives a
+ * worktree teardown or clone (F93). Local copy of `parseVerdictLine` and of the `Testing` slice
+ * in `extractTestingSection` (`packages/app/src/services/task-record.ts`) because ADR-065 keeps
+ * plugin scripts on builtin and relative imports only; keep the three literals in step by hand
+ * (the parity guard in `plugins/sp/tests/wrapup-steps.test.ts` reads the canonical literals).
+ *
+ * The slice rule is the canonical one verbatim — `#{1,6}` heading, end at the next
+ * same-or-higher heading — so an `# Testing` or `#### Testing` heading, and an h4 subheading
+ * inside a `## Testing` section, read the same here and in the app. One deliberate difference:
+ * with no `Testing` heading at all this returns null instead of falling back to the whole
+ * document, so a `Verdict:` token in another section cannot be misread as this task's verdict.
+ */
+export function verdictFromTestingSection(content: string): string | null {
+    const heading = /^#{1,6}\s+Testing\s*$/m.exec(content);
+    if (!heading) return null;
+    const level = heading[0].match(/^#+/)?.[0]?.length ?? 2;
+    const rest = content.slice(heading.index + heading[0].length);
+    const next = new RegExp(`^#{1,${level}}\\s+\\S`, 'm').exec(rest);
+    const section = next ? rest.slice(0, next.index) : rest;
+    for (const line of section.split('\n')) {
+        // Line-anchored (optionally after `- ` bullet or `**` bold) so evidence text
+        // containing a mid-line "Verdict:" token cannot be misread as the section verdict.
+        const m = /^(?:-\s*|\*\*)?Verdict:\s*(PASS|PARTIAL|FAIL|UNKNOWN)\b/i.exec(line.trim());
+        if (m?.[1] !== undefined) return m[1].toUpperCase();
+    }
+    return null;
+}
+
+/**
+ * `verdict` field of a verdict artifact; null when the file is absent, unreadable, malformed or
+ * carries no usable verdict (jq `//` semantics: null, undefined and false all count as missing).
+ */
+function verdictOfArtifact(verdictPath: string): string | null {
+    try {
+        const raw = jqPick((JSON.parse(readFileSync(verdictPath, 'utf8')) as { verdict?: unknown }).verdict, '');
+        const text = jqText(raw);
+        return text.length > 0 ? text : null;
+    } catch {
+        return null;
+    }
+}
+
 export interface MetricsResult {
     status: 'PASS' | 'FAIL';
     statusFile: string;
@@ -323,17 +366,20 @@ export function runMetrics(env: WrapupStepsEnv, options: WrapupStepsOptions = {}
         const featureId = String(jqPick(frontmatter.feature_id, parsed.feature_id, ''));
         const status = String(jqPick(frontmatter.status, parsed.status, 'unknown'));
 
-        // jq `//` semantics: null and false count as missing; an empty string result stays UNKNOWN.
-        let verdict = 'UNKNOWN';
+        // The verdict artifact stays the first source (F93 R2); when it is gone — a worktree run
+        // fast-forwards and removes the tree, taking the gitignored artifact with it — the tracked
+        // `Testing` line `task record` already wrote into the task file is the durable copy. Honest
+        // UNKNOWN is the last resort, and it is telemetry, never proof of completion.
         const verdictPath = join('.spur', 'run', `${wbs}-verdict.json`);
-        if (existsSync(abs(verdictPath))) {
-            try {
-                const raw = jqPick(JSON.parse(readFileSync(abs(verdictPath), 'utf8')).verdict, 'UNKNOWN');
-                const text = raw === 'UNKNOWN' ? 'UNKNOWN' : jqText(raw);
-                if (text.length > 0) verdict = text;
-            } catch {
-                // unreadable verdict file keeps UNKNOWN telemetry
-            }
+        const artifactVerdict = verdictOfArtifact(abs(verdictPath));
+        const trackedVerdict = verdictFromTestingSection(typeof parsed.content === 'string' ? parsed.content : '');
+        const verdict = artifactVerdict ?? trackedVerdict ?? 'UNKNOWN';
+        if (verdict === 'UNKNOWN') {
+            // R3: name the task, the artifact path and the tracked state. An explicit UNKNOWN on
+            // either source is still an uncertified row, so it reports the same way as a miss.
+            process.stderr.write(
+                `metrics-record: task ${wbs} has no certifying verdict — ${verdictPath}: ${artifactVerdict ?? 'missing or carries none'}, tracked Testing: ${trackedVerdict ?? 'no Verdict: line'} — recording UNKNOWN telemetry\n`,
+            );
         }
 
         const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');

package/plugins/sp/skills/code-verification/SKILL.md

@@ -259,17 +259,22 @@ the deterministic Testing writer `spur task record` (section authorship never ha
 
 ```bash
 # write .spur/run/<wbs>-verdict.json (shape in references/verdict-schema.md), then:
-# F96 residual sweep (observe-only): scan + fold BEFORE record, under every --fix mode.
+spur task record <wbs> --verdict-file .spur/run/<wbs>-verdict.json  # renders ## Testing, flips proven boxes
+# F96 residual sweep (observe-only): scan + fold AFTER record, under every --fix mode (0987).
 RESIDUAL=$(superskill script path sp residual-scan.mjs)
 node "$RESIDUAL" scan <wbs>
 node "$RESIDUAL" fold <wbs>
-spur task record <wbs> --verdict-file .spur/run/<wbs>-verdict.json  # renders ## Testing
+# Downgrade only: re-record so Testing carries the final (folded) verdict.
+[ "$(jq -r .verdict .spur/run/<wbs>-verdict.json)" = PASS ] \
+  || spur task record <wbs> --verdict-file .spur/run/<wbs>-verdict.json
 ```
 
-> **Residual fold (F96).** `scan` reads `.spur/run/` artifacts and writes `residuals.json` +
-> `residual-report.md`; `fold` rewrites the **just-written** verdict artifact's `residual-sweep`
-> check in place (PASS → PARTIAL when a blocking residual exists), so `record` transcribes the
-> downgraded verdict — a manual verify cannot certify what the pipeline would reject. Resolve the
+> **Residual fold (F96).** `scan` reads `.spur/run/` artifacts and the post-record task file and
+> writes `residuals.json` + `residual-report.md`; `fold` rewrites the verdict artifact's
+> `residual-sweep` check in place (PASS → PARTIAL when a blocking residual exists), and the
+> downgrade-only re-record transcribes it — a manual verify cannot certify what the pipeline would
+> reject. The sweep runs after `record` (same order as the pipeline, 0983/0987): before it, a
+> verdict-proven box is still unticked and a clean PASS would fold to PARTIAL. Resolve the
 > script via `superskill script path sp residual-scan.mjs`; shipped surfaces never reference
 > `plugins/sp/scripts/` directly (script-contract-check rule 4). When the task reaches `done`
 > through `--next`, run `residual-scan settle` (links follow-up tasks; best-effort).
@@ -322,7 +327,7 @@ Verdict: PASS
 ### SECUA Review
 | Priority | Dimension | Location | Finding |
 | --- | --- | --- | --- |
-| P4 | — | — | No P1–P3 findings; verify verdict PASS |
+| P4 | — | — | No findings (verify verdict PASS) |
 ```
 
 The per-requirement traceability table MUST use `| Req | Status | Evidence |` (exactly this header, no `R#`/`R`/`Requirement` variant — `Status` in column 2 — and no extra columns between Req and Status). The Acceptance Criteria table MUST use `| AC | Status | Evidence Type | Evidence |`.

package/plugins/sp/skills/code-verification/references/verdict-schema.md

@@ -118,6 +118,17 @@ fail — invalid status (`MET | PARTIAL | UNMET` for requirements;
 manual-review | llm-judge | n/a`, or a `+` compound), and empty evidence. Interrupted runs keep the
 rows that pass the lint and complete only the missing IDs on retry.
 
+**Feature-credited AC ids are narrower than the lint's accepted set (task 0966 finding).** A row keyed
+by a bare checklist ordinal (`AC1`) passes `verify-answer-lint` — it resolves to the task's AC
+checklist label — but `feature-check.rowMatchesScenario` credits a linked feature scenario only by the
+scenario's normalized title or its `AC-N` ordinal alias. Such a row therefore carries a PASS verdict
+while crediting no scenario, and the feature's `verifying → done` gate denies with
+`L4.scenario-unverified` / `L4.verdict-rows-match-no-scenario`. When the task has a linked feature,
+key each AC row `AC-N` (1-based scenario ordinal, hyphenated) or by the exact scenario title.
+A scenario-keyed row (`R3 — <title>`) ticks the task AC box whose line aliases that scenario
+(`- [ ] AC1 — R3 — <title>`) during `spur task record` (0996); a scenario key no AC line aliases
+ticks nothing, so alias every graduated scenario on its AC line.
+
 **Concrete anchors only (task 0804 R9).** An evidence anchor must be a concrete existing `file:line`
 (or `file:start-end`) path. A glob or directory summary (`src/services/*.ts`, `the retry
 classifiers in task-pipeline.yaml`) is not an anchor: expand it into the specific cited files/ranges

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

@@ -253,7 +253,7 @@ shape, e.g. `| Req | Status | Evidence |` alone, is structurally rejected and de
 ```markdown
 | Priority | Dimension | Location | Finding |
 | --- | --- | --- | --- |
-| P4 | — | — | No P1–P3 findings; functional verdict PASS |
+| P4 | — | — | No findings (functional verdict PASS) |
 
 | Req | Status | Evidence |
 | --- | --- | --- |

package/plugins/sp/skills/next-router/references/routing-table.md

@@ -113,7 +113,7 @@ token, deterministic).
 | C3 | A5/A6 when Testing empty/N/A **and** verify would fail for missing tests — only if prior implement claims code exists | Coverage/test signal: `bun test` fail attributed to task paths OR explicit "insufficient tests" in prior verify verdict artifact `.spur/run/<wbs>-verdict.json` | test fail / coverage gap | `/sp:dev-unit <wbs> --auto` | continue |
 | C4 | A3/A5/A6 when operator or task tags mention rules, OR `spur rule run` last report dirty in `.spur/` if present | `spur rule run` (default project preset) non-zero with findings | rule findings | **HITL STOP** — print rule summary; suggest `/sp:rule-scan` or `rule-add`/`rule-refine` (do not auto-author rules) | continue |
 | C5 | A6 only | Existing `.spur/run/<wbs>-verdict.json` with FAIL and findings pointing at coverage | verdict artifact | `/sp:dev-unit <wbs>` then re-verify on next invocation (`--once` friendly) | `/sp:dev-verify …` |
-| C6 | A4/A5 | `.spur/run/<wbs>-verdict.json` has a failing (PARTIAL/FAIL) `residual-sweep` check — the bounded remediation loop already ran and failed (F96) | folded verdict artifact | **HITL STOP** — print `.spur/run/<wbs>-residual-report.md` and the recovery command `/sp:dev-run <wbs>`; never auto-dispatch a fix (repeating the loop unattended burns quota without new information) | continue |
+| C6 | A4/A5 | `.spur/run/<wbs>-verdict.json` has a failing (PARTIAL/FAIL) `residual-sweep` check — residual blockers survived the pipeline sweep (F96) | folded verdict artifact | **HITL STOP** — print `.spur/run/<wbs>-residual-report.md` and the recovery command `/sp:dev-run <wbs>`; never auto-dispatch a fix (repeating the loop unattended burns quota without new information) | continue |
 
 **C-row precedence note (F96):** C6 outranks C2/C3/C5 for the same task — a residual-sweep failure
 means the workspace holds unfinished task residue, so fixall/unit reruns would either clean it

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/execution-batch.md

@@ -492,7 +492,8 @@ batch can never destroy its own evidence. Reuse mode retains its operator-owned
 persists the Step 5 report under the invoking tree; the reused tree's `.spur/run/` remains the live
 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>` call, not by hand.
+`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
@@ -500,10 +501,25 @@ written inside the worktree and **are removed with it** in create mode — the E
 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. The shapes are pinned (task 0975 R1): 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>"}]}`
+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 any failure
+`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
@@ -828,12 +844,16 @@ git merge --ff-only "$BRANCH"          # FF-only: never rebase, merge-commit, or
 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). Idempotent; conflicts are reported, never
-# overwritten. A non-zero exit — including a half-readable worktree — must NOT
-# proceed to WT-4b removal:
-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)"
-bun "$SETUP_SCRIPT" --persist-out --from "$WT_PATH" \
+# 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). $WT_PATH above is the EXACT

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;

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"]
+}