@gobing-ai/spur 0.3.72 → 0.3.74

package/plugins/sp/scripts/daily-summary/daily-summary.ts

@@ -369,16 +369,14 @@ export async function getSpurHistoryHealth(
                 const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, '_');
                 const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
                 const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
-                const body = `Finding: ${key}\\nObserved ${lp.repeats} redundant invocations in session ${lp.sessionId} (steps #${lp.fromSeq ?? 1}→#${lp.toSeq ?? lp.repeats}). Wasted tokens: ~${lp.wastedTokens}.`;
-                const command = `spur task create --section "Fix ${cleanTool} repetition loop" --body "${body}"`;
+                const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
                 remediationProposals.push({ key, title, command });
             }
 
             if (toolCalls > 0 && errorRatePct > 10) {
                 const key = 'reliability:tooling:high-error-rate';
                 const title = `Investigate high tool error rate (${errorRatePct.toFixed(1)}%)`;
-                const body = `Finding: ${key}\\nObserved ${toolErrors} errors across ${toolCalls} tool calls (${errorRatePct.toFixed(1)}% error rate) on ${date}.`;
-                const command = `spur task create --section "Investigate tool error rate spikes" --body "${body}"`;
+                const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
                 remediationProposals.push({ key, title, command });
             }
 

package/plugins/sp/scripts/history-anatomy-cache.mjs

@@ -198,6 +198,7 @@ function parseProvenance(reportMarkdown) {
       contractDigest: String(obj.contractDigest ?? ""),
       skillDigest: String(obj.skillDigest ?? ""),
       workflowDigest: String(obj.workflowDigest ?? ""),
+      helperDigest: String(obj.helperDigest ?? ""),
       coverage: coverage.map((c) => ({
         source: String(c.source ?? ""),
         status: String(c.status ?? ""),
@@ -244,6 +245,8 @@ function decideCache(cached, current, opts) {
     reasons.push("logic-changed:skill");
   if (cached.workflowDigest !== current.workflowDigest)
     reasons.push("logic-changed:workflow");
+  if (cached.helperDigest !== current.helperDigest)
+    reasons.push("logic-changed:helper");
   const currentSources = new Set(current.coverage.map((c) => c.source));
   if (cached.coverage.some((c) => !currentSources.has(c.source)))
     reasons.push("coverage-degraded");
@@ -473,6 +476,7 @@ function buildProvenance(opts) {
     contractDigest: logicDigest(opts.contractFile),
     skillDigest: logicDigest(opts.skillDir),
     workflowDigest: logicDigest(opts.workflowFile),
+    helperDigest: logicDigest(opts.helperFile),
     coverage,
     runId: opts.runId,
     currentArtifactPath: opts.artifact,
@@ -503,6 +507,7 @@ var YAML_KEYS = [
   "contractDigest",
   "skillDigest",
   "workflowDigest",
+  "helperDigest",
   "runId",
   "currentArtifactPath",
   "baselineArtifactPath",
@@ -595,7 +600,7 @@ function diffPorcelain(before, now, expects) {
   return [...porcelainPaths(now)].filter((p) => !beforePaths.has(p) && !expects.has(p)).sort();
 }
 var VALID_COMMANDS = "digest, check, paths, assert-clean, probe, stamp, refresh, publish";
-var PROBE_USAGE = "<script> probe --artifact <a.json> --target <report.md> [--baseline <b.json>] [--mode daily|ad-hoc] " + "[--date <YYYY-MM-DD>] [--recompute true] [--out <prov.json>] [--skill-dir <d>] [--contract <f>] [--workflow <f>]";
+var PROBE_USAGE = "<script> probe --artifact <a.json> --target <report.md> [--baseline <b.json>] [--mode daily|ad-hoc] " + "[--date <YYYY-MM-DD>] [--recompute true] [--out <prov.json>] [--skill-dir <d>] [--contract <f>] [--workflow <f>] [--helper <f>]";
 function parseFlags(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -729,6 +734,7 @@ ${result.problems.map((p) => `- ${p}
           skillDir: f["skill-dir"],
           contractFile: f.contract,
           workflowFile: f.workflow,
+          helperFile: f.helper,
           contractVersion: f["contract-version"],
           runId: f["run-id"],
           spurVersion: f["spur-version"]

package/plugins/sp/scripts/history-anatomy-cache.ts

@@ -4,7 +4,8 @@
  *
  * ADR-079 makes cache validity a *derived* fact, not a stored claim: a cached report is reusable
  * only for its model-authored half, and only when a freshly derived semantic digest of the analyze
- * artifact plus the contract/skill/workflow logic digests all match what the cache recorded.
+ * artifact plus the contract/skill/workflow/helper logic digests all match what the cache
+ * recorded (helper digest: task 0771 — the deterministic half is part of cache identity).
  *
  * This script performs deterministic file, hash, and schema work only — no finding, remediation,
  * severity, or ranking logic (that is judgment, owned by the sp:history-anatomy skill). Jobs:
@@ -68,6 +69,8 @@ export interface CacheProvenance {
     contractDigest: string;
     skillDigest: string;
     workflowDigest: string;
+    /** Digest of the executing helper twin itself (0771): a changed deterministic half invalidates. */
+    helperDigest: string;
     coverage: Array<{ source: string; status: string; lastImportedAt: string | null }>;
     // 0660 R7 audit fields. Recorded in the published frontmatter for provenance; deliberately
     // NOT part of the invalidation matrix — a changed run id or executor is not stale evidence.
@@ -243,6 +246,7 @@ export function parseProvenance(reportMarkdown: string): CacheProvenance | null
             contractDigest: String(obj.contractDigest ?? ''),
             skillDigest: String(obj.skillDigest ?? ''),
             workflowDigest: String(obj.workflowDigest ?? ''),
+            helperDigest: String(obj.helperDigest ?? ''),
             coverage: coverage.map((c) => ({
                 source: String(c.source ?? ''),
                 status: String(c.status ?? ''),
@@ -300,6 +304,7 @@ export function decideCache(
     if (cached.contractDigest !== current.contractDigest) reasons.push('logic-changed:contract');
     if (cached.skillDigest !== current.skillDigest) reasons.push('logic-changed:skill');
     if (cached.workflowDigest !== current.workflowDigest) reasons.push('logic-changed:workflow');
+    if (cached.helperDigest !== current.helperDigest) reasons.push('logic-changed:helper');
 
     // Coverage cannot degrade: the cache must not claim broader coverage than the current
     // analyze covers. If the cached report covered a source the current analyze no longer does,
@@ -601,6 +606,7 @@ export interface ProbeOptions {
     skillDir?: string;
     contractFile?: string;
     workflowFile?: string;
+    helperFile?: string;
     contractVersion?: string;
     runId?: string;
     spurVersion?: string;
@@ -660,6 +666,7 @@ export function buildProvenance(opts: ProbeOptions): CacheProvenance {
         contractDigest: logicDigest(opts.contractFile),
         skillDigest: logicDigest(opts.skillDir),
         workflowDigest: logicDigest(opts.workflowFile),
+        helperDigest: logicDigest(opts.helperFile),
         coverage,
         runId: opts.runId,
         currentArtifactPath: opts.artifact,
@@ -697,6 +704,7 @@ const YAML_KEYS: Array<keyof CacheProvenance> = [
     'contractDigest',
     'skillDigest',
     'workflowDigest',
+    'helperDigest',
     'runId',
     'currentArtifactPath',
     'baselineArtifactPath',
@@ -823,7 +831,7 @@ export function diffPorcelain(before: string, now: string, expects: Set<string>)
 const VALID_COMMANDS = 'digest, check, paths, assert-clean, probe, stamp, refresh, publish';
 const PROBE_USAGE =
     '<script> probe --artifact <a.json> --target <report.md> [--baseline <b.json>] [--mode daily|ad-hoc] ' +
-    '[--date <YYYY-MM-DD>] [--recompute true] [--out <prov.json>] [--skill-dir <d>] [--contract <f>] [--workflow <f>]';
+    '[--date <YYYY-MM-DD>] [--recompute true] [--out <prov.json>] [--skill-dir <d>] [--contract <f>] [--workflow <f>] [--helper <f>]';
 
 /** `--key value` / `--flag` → record. Bare flags become `"true"` so `--recompute` needs no value. */
 function parseFlags(args: string[]): Record<string, string | undefined> {
@@ -956,6 +964,7 @@ export function runCacheCli(argv: string[]): CacheCliResult {
                     skillDir: f['skill-dir'],
                     contractFile: f.contract,
                     workflowFile: f.workflow,
+                    helperFile: f.helper,
                     contractVersion: f['contract-version'],
                     runId: f['run-id'],
                     spurVersion: f['spur-version'],

package/plugins/sp/scripts/inline-pipeline-parity-check.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env bun
+/**
+ * inline-pipeline-parity-check — two-sided gate between the inline pipeline
+ * driver's documented action/guard set and the resolved action/guard sets in
+ * `.spur/workflows/task-pipeline.yaml` and `.spur/workflows/idea-pipeline.yaml`
+ * (task 0755 R2/R3).
+ *
+ * The driver reference at `plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md`
+ * documents the set of action and guard kinds it implements. The two runtime
+ * pipelines are the only consumers the driver needs to keep in step with. The
+ * check is a symmetric set diff: an element present in one and absent in the
+ * other fails the check and names the element.
+ *
+ * The set is defined in {@link DOCUMENTED} below; the driver's markdown list is
+ * the human mirror. Update both when the driver adds or drops a kind.
+ *
+ * Usage:
+ *   bun plugins/sp/scripts/inline-pipeline-parity-check.ts
+ *     [--root <path>]               default: repo root
+ *
+ * Exit code: 0 when the sets agree; 1 on any divergence. Violations are printed
+ * to stderr; a summary to stdout.
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+
+/** Documented action and guard set. Must stay in lockstep with the
+ *  "Supported action and guard set (0755 R2 parity contract)" section in
+ *  `plugins/sp/skills/spur-dev/references/inline-pipeline-driver.md`. The
+ *  driver supports a kind if ANY workflow in `.spur/workflows/*.yaml` uses
+ *  it (the driver applies to any selected pipeline per its reference doc). */
+const DOCUMENTED = {
+    actions: new Set([
+        'shell',
+        'note',
+        'doctor.probe',
+        'file.read.into-var',
+        'hitl.confirm',
+        'agent.run',
+        'proof.fingerprint',
+        'run.artifact',
+        'command.gate',
+    ]),
+    guards: new Set(['always', 'shell']),
+} as const;
+
+/** Directory of workflow definitions the driver is responsible for. */
+const WORKFLOW_DIR = join('config', 'workflows');
+
+/** Walk a state list and yield every `kind:` value found in `onEnter` action
+ *  lists. Skips the top-level workflow `kind:` (e.g. `state-machine`). */
+function collectActionKinds(states: unknown): Set<string> {
+    const out = new Set<string>();
+    if (!Array.isArray(states)) return out;
+    for (const state of states) {
+        if (typeof state !== 'object' || state === null) continue;
+        const onEnter = (state as { onEnter?: unknown }).onEnter;
+        if (!Array.isArray(onEnter)) continue;
+        for (const action of onEnter) {
+            if (typeof action !== 'object' || action === null) continue;
+            const kind = (action as { kind?: unknown }).kind;
+            if (typeof kind === 'string') out.add(kind);
+        }
+    }
+    return out;
+}
+
+/** Walk a transition list and yield every `guard.kind` value. */
+function collectGuardKinds(transitions: unknown): Set<string> {
+    const out = new Set<string>();
+    if (!Array.isArray(transitions)) return out;
+    for (const transition of transitions) {
+        if (typeof transition !== 'object' || transition === null) continue;
+        const guard = (transition as { guard?: { kind?: unknown } }).guard;
+        const kind = guard?.kind;
+        if (typeof kind === 'string') out.add(kind);
+    }
+    return out;
+}
+
+/** Symmetric set diff. Returns elements in `a` but not in `b`, and vice versa. */
+function diff<T>(a: Set<T>, b: Set<T>): { onlyInA: T[]; onlyInB: T[] } {
+    const onlyInA: T[] = [];
+    const onlyInB: T[] = [];
+    for (const x of a) if (!b.has(x)) onlyInA.push(x);
+    for (const x of b) if (!a.has(x)) onlyInB.push(x);
+    return { onlyInA, onlyInB };
+}
+
+function parseArgs(argv: string[]): { root: string } {
+    let root = resolve('.');
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--root' && i + 1 < argv.length) {
+            root = resolve(argv[++i] ?? '.');
+        } else if (arg === '--help' || arg === '-h') {
+            process.stdout.write('Usage: bun inline-pipeline-parity-check.ts [--root <path>]\n');
+            process.exit(0);
+        }
+    }
+    return { root };
+}
+
+function listWorkflowFiles(dir: string): string[] {
+    let entries: string[];
+    try {
+        entries = readdirSync(dir);
+    } catch {
+        return [];
+    }
+    return entries.filter((e) => e.endsWith('.yaml')).map((e) => join(dir, e));
+}
+
+async function main(): Promise<number> {
+    const { root } = parseArgs(process.argv.slice(2));
+    const errors: string[] = [];
+
+    const workflowDir = join(root, WORKFLOW_DIR);
+    if (!statSync(workflowDir, { throwIfNoEntry: false })) {
+        process.stderr.write(`inline-pipeline-parity-check: workflow directory not found: ${workflowDir}\n`);
+        return 1;
+    }
+
+    const files = listWorkflowFiles(workflowDir);
+    if (files.length === 0) {
+        process.stderr.write(`inline-pipeline-parity-check: no .yaml workflows found in ${workflowDir}\n`);
+        return 1;
+    }
+
+    const unionActions = new Set<string>();
+    const unionGuards = new Set<string>();
+    const perFileKinds: { path: string; actions: Set<string>; guards: Set<string> }[] = [];
+
+    for (const path of files) {
+        let parsed: unknown;
+        try {
+            parsed = parseYaml(readFileSync(path, 'utf8'));
+        } catch (err) {
+            errors.push(`${path}: failed to parse (${err instanceof Error ? err.message : String(err)})`);
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null) {
+            continue;
+        }
+        const def = parsed as { states?: unknown; transitions?: unknown };
+        const actions = collectActionKinds(def.states);
+        const guards = collectGuardKinds(def.transitions);
+        perFileKinds.push({ path, actions, guards });
+        for (const a of actions) unionActions.add(a);
+        for (const g of guards) unionGuards.add(g);
+    }
+
+    const actionDiff = diff(unionActions, DOCUMENTED.actions);
+    const guardDiff = diff(unionGuards, DOCUMENTED.guards);
+
+    for (const x of actionDiff.onlyInA) {
+        const usedIn = perFileKinds.filter((f) => f.actions.has(x)).map((f) => f.path);
+        errors.push(`action kind "${x}" used in YAML (${usedIn.join(', ')}) but absent from inline-pipeline-driver.md`);
+    }
+    for (const x of actionDiff.onlyInB) {
+        errors.push(`action kind "${x}" documented in inline-pipeline-driver.md but never used in any workflow`);
+    }
+    for (const x of guardDiff.onlyInA) {
+        const usedIn = perFileKinds.filter((f) => f.guards.has(x)).map((f) => f.path);
+        errors.push(`guard kind "${x}" used in YAML (${usedIn.join(', ')}) but absent from inline-pipeline-driver.md`);
+    }
+    for (const x of guardDiff.onlyInB) {
+        errors.push(`guard kind "${x}" documented in inline-pipeline-driver.md but never used in any workflow`);
+    }
+
+    if (errors.length > 0) {
+        process.stderr.write(`inline-pipeline-parity-check: ${errors.length} divergence(s)\n`);
+        for (const e of errors) process.stderr.write(`  - ${e}\n`);
+        return 1;
+    }
+
+    process.stdout.write(
+        `inline-pipeline-parity-check: ok (${unionActions.size} actions, ${unionGuards.size} guards agree across ${files.length} workflows)\n`,
+    );
+    return 0;
+}
+
+process.exit(await main());

package/plugins/sp/scripts/pr-reviewing.mjs

@@ -325,7 +325,11 @@ function hasPendingRequest(comments, head, login) {
 }
 function requireExpectedHead(args, pr) {
   const expected = args.flags.get("--head");
-  if (expected && expected !== pr.headRefOid) {
+  if (!expected) {
+    writeStatus(args, "FAIL");
+    fail(args, "--head <sha> is required and must match the reviewed request HEAD", 2);
+  }
+  if (expected !== pr.headRefOid) {
     writeStatus(args, "FAIL");
     fail(args, `PR HEAD moved from ${expected.slice(0, 7)} to ${pr.headRefOid.slice(0, 7)} \u2014 request a new review`, 2);
   }

package/plugins/sp/scripts/pr-reviewing.ts

@@ -519,8 +519,14 @@ function hasPendingRequest(comments: readonly GhIssueComment[], head: string, lo
 }
 
 function requireExpectedHead(args: ParsedArgs, pr: GhPr): void {
+    // 0771: head pinning only protects when the flag actually carries a SHA — an empty or
+    // missing --head must fail loud instead of silently reviewing whatever HEAD is current.
     const expected = args.flags.get('--head');
-    if (expected && expected !== pr.headRefOid) {
+    if (!expected) {
+        writeStatus(args, 'FAIL');
+        fail(args, '--head <sha> is required and must match the reviewed request HEAD', 2);
+    }
+    if (expected !== pr.headRefOid) {
         writeStatus(args, 'FAIL');
         fail(
             args,

package/plugins/sp/scripts/task-evidence-precheck.ts

@@ -145,7 +145,7 @@ function main(): void {
 
     const dbPath = join(process.cwd(), '.spur', 'spur.db');
     if (!existsSync(dbPath)) {
-        fail(wbs, [`spur database not found at ${dbPath} — run a real history import first`]);
+        fail(wbs, [`local spur database not found at ${dbPath} — run a real history import first`]);
     }
 
     let count: number;

package/plugins/sp/scripts/transition-shim-check.ts

@@ -8,11 +8,11 @@
  * so it is a grep target and a review signal, and a manifest entry in
  * `config/transition-shims.json` records who owns it and when it can be removed.
  *
- * The gate is deliberately two-sided, matching `config/corpus-baseline.json`
- * semantics (corpus-check.ts): a marker with no manifest entry FAILS, and a
- * manifest entry whose marker no longer appears in source FAILS. Without the
- * second half the manifest would rot into a permanent suppression list — the
- * exact invisible-debt pattern this gate exists to end.
+ * The gate is deliberately two-sided: a marker with no manifest entry
+ * FAILS, and a manifest entry whose marker no longer appears in source
+ * FAILS. Without the second half the manifest would rot into a permanent
+ * suppression list — the exact invisible-debt pattern this gate exists to
+ * end.
  *
  * Marker convention (docs/04_DESIGN.md §2.5):
  *   // @transition-shim(<id>) — <one line on what this keeps working>
@@ -134,7 +134,7 @@ function scanMarkers(cwd: string, roots: string[]): Map<string, Set<string>> {
     return found;
 }
 
-/** Load the manifest; a missing file degrades to no entries (corpus-check parity). */
+/** Load the manifest; a missing file degrades to no entries (fail-open). */
 function loadManifest(path: string): { entries: ManifestEntry[]; raw: string | null } {
     if (!existsSync(path)) return { entries: [], raw: null };
     const raw = readFileSync(path, 'utf8');

package/plugins/sp/scripts/verify-answer-lint.ts

@@ -269,6 +269,10 @@ function extractAcIdentities(taskContent: string, featureContent: string | null)
         const leading = label.split(/\s+/)[0] ?? '';
         if (leading && leading !== label) identities.add(leading);
     }
+    for (const m of section.matchAll(/^[ \t]*Scenario:\s*(.+)\s*$/gm)) {
+        const title = (m[1] ?? '').trim();
+        if (title) identities.add(title);
+    }
     if (featureContent !== null) {
         for (const m of featureContent.matchAll(/^[ \t]*Scenario:\s*(.+)\s*$/gm)) {
             const title = (m[1] ?? '').trim();

package/plugins/sp/skills/pr-reviewing/SKILL.md

@@ -164,12 +164,15 @@ superskill script contract.
 8. **Collect** — `<script> collect --since "$requestedAt" --head "$requestHead" --json`. Normalize
    only the requested HEAD and request window; then invoke `status` with the same bounds for
    PR/base/CI/local state. Never turn an absent, stale, or moved-HEAD result into `clean`.
+   `--head` is mandatory on wait/collect/status (0771): an empty or missing pin fails loud
+   instead of silently reviewing whatever HEAD is current.
 
 ## Fix mode
 
 Only in `fix` mode:
 
-1. **Collect before editing.** Invoke direct `collect --json` plus `status --json` and require a
+1. **Collect before editing.** Invoke direct `collect --json --head "$(git rev-parse HEAD)"` plus
+   `status --json --head "$(git rev-parse HEAD)"` and require a
    completed result for the current pushed HEAD. If the result is pending, stale, or unavailable,
    report it and stop without source edits. If it is explicitly clean, report no fixes and stop.
 2. **Validate each finding.** Open the referenced code; trace callers/callees; verify the problem

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

@@ -1,14 +1,14 @@
 ---
 name: spur-cli-self
-description: "spur-cli noun reference for `spur self`: self-management verbs — scaffold (`init`), schema migrations (`migrate`), local web server (`serve`), and status overview (`status`). Each verb mounts the same command builder as its legacy top-level noun, which remains a hidden alias over the identical command."
+description: "spur-cli noun reference for `spur self`: self-management verbs — scaffold (`init`), database maintenance (`maintain`), schema migrations (`migrate`), local web server (`serve`), and status overview (`status`). Each verb mounts the same command builder as its legacy top-level noun, which remains a hidden alias over the identical command."
 see_also:
   - spur-cli
 ---
 
 # spur self - self-management verbs
 
-`spur self` hosts the four self-management verbs. Each verb is the canonical path for a command
-that also remains registered as a legacy top-level **hidden alias** (`spur init`, `spur migrate`,
+`spur self` hosts the self-management verbs. Each verb is the canonical path for a command
+that also remains registered as a legacy top-level **hidden alias** (`spur init`, `spur maintain`, `spur migrate`,
 `spur serve`, `spur status`) so existing scripts, workflow YAML, and habits keep working unchanged.
 Both paths share the same command builder: identical flags, output, and exit codes. The legacy
 top-level forms are omitted from `spur --help`, leaving `self` as the visible surface.
@@ -18,6 +18,7 @@ top-level forms are omitted from `spur --help`, leaving `self` as the visible su
 | Verb | Purpose | Key flags |
 | ---- | ------- | --------- |
 | `init` | Scaffold a new Spur project in the current directory | `--name <name>` `--force` `--minimal` `--json` |
+| `maintain` | Run database maintenance: PRAGMA optimize, WAL truncation, optional VACUUM | `--vacuum` `--json` |
 | `migrate` | Apply CLI-owned schema migrations | `--json` |
 | `serve` | Start the Spur web server (local fallback) | `--port <n>` `--host <addr>` `--no-open` `--cwd <path>` `--json` |
 | `status [path]` | Show project and git status for a Spur project | `--json` |
@@ -43,6 +44,19 @@ Materializes the `.spur/` directory tree with config, docs, rules, and workflow
 (Phase 1.5 / 1.6) run immediately after this verb completes — see **[init.md](init.md)** for the
 probe protocol and rule-glob adaptation procedure.
 
+## `self maintain` - run database maintenance
+
+```bash
+spur self maintain                    # run PRAGMA optimize + wal_checkpoint(TRUNCATE)
+spur self maintain --vacuum           # deep maintenance: VACUUM + optimize + checkpoint
+spur self maintain --json             # machine-readable
+```
+
+Executes SQLite database maintenance operations on `.spur/spur.db`:
+- `PRAGMA optimize;` to refresh query planner statistics in `sqlite_stat1`.
+- `PRAGMA wal_checkpoint(TRUNCATE);` to checkpoint committed WAL frames and truncate WAL to 0 bytes.
+- `--vacuum` runs `VACUUM;` first for page compaction and B-tree defragmentation (requires 2x free disk space).
+
 ## `self migrate` - apply CLI-owned schema migrations
 
 ```bash

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

@@ -51,7 +51,7 @@ re-reading or re-tokenizing the task.
 | `batch-create` | Create many tasks from a validated JSON array | `--file <path>` `--folder` `--json` |
 | `record <wbs>` | Write `Testing` from a verify verdict (deterministic); bare-`## Review` fallback only; optional Solution + transition | `--verdict-file <path>` `--solution-from-diff` `--transition <status>` `--folder` `--json` |
 | `verdict <wbs>` | Derive PASS/PARTIAL/FAIL/UNKNOWN from verify answer text → verdict JSON; see [answer-file shape](tasks/verbs.md#answer-file-shape-what---from-answer-parses) | `--from-answer <path>` `--folder` `--json` |
-| `check [wbs]` | Four-layer validation; the readiness matrix; `--fix` repairs structural findings in place | `--strict` `--as <status>` `--strict-core` `--fix` `--folder` `--json` |
+| `check [wbs]` | Four-layer validation; `--fix` repairs structure; `--corpus` is the explicit unsuppressed audit | `--strict` `--as <status>` `--strict-core` `--fix` `--folder` `--corpus` `--since <ref>` `--json` |
 | `resolve <file-path>` | Map a file path to its owning task WBS | `--strict` `--folder` `--json` |
 | `path <wbs>` | Map a WBS to its absolute task file path (inverse of `resolve`) | `--folder` `--json` |
 | `run-link <wbs>` | Record pipeline run provenance link for task | `--source <src>` `--run-id <id>` `--json` |

package/plugins/sp/skills/spur-cli/references/workflows/authoring-workflows.md

@@ -229,3 +229,26 @@ verifying shape, or stand in a `note` action until the path is proven, then swap
       `agent.run` input referencing a command rather than a raw prompt, guards a single predicate
       ([workflow-fit-and-tuning.md](workflow-fit-and-tuning.md#3-node-simplicity-budget)).
 - [ ] Validates clean AND dry-run reaches the expected terminal state.
+
+## Optional version literal (task 0756)
+
+Both dialects accept an optional root `version` field. The literal is **behavior-neutral** — it
+exists as an identity tag, not a routing key. The contract:
+
+- **Absent** → reported as `unversioned`. The default for all 11 shipped definitions.
+- **Present, non-empty string** → reported as `explicit(<literal>)`. The literal is wrapped in
+  parentheses verbatim — no parsing, no ordering, no compatibility check.
+- **Present, empty string (`version: ""`)** → **rejected** with a diagnostic naming the empty
+  value. The rejection lives in the resolve/preflight seam
+  (`packages/app/src/workflow/workflow-resolver.ts`), not in the dialect JSON schemas: those carry
+  `minLength: 1` for editors and Ajv consumers, but the load path validates against the engine's
+  Zod schema, which has no minimum. Move the check upstream once
+  `@gobing-ai/ts-dual-workflow-engine` ships `z.string().min(1)` on the root version.
+
+The literal folds into the definition digest (`packages/app/src/workflow/composition-baseline.ts`),
+so a version-only edit changes the digest with zero behavior change. `show` and `trace` do **not**
+surface the literal by default — the digest stays the rendered run identity (D8 decision D5).
+
+**No registry, no semver parser, no compatibility engine.** A future-major requirement needs
+objective evidence: a consumer that branches on version, or a real drift incident the digest
+diagnostic could not disambiguate. Neither exists today.

package/plugins/sp/skills/spur-cli/references/workflows/workflow-fit-and-tuning.md

@@ -140,10 +140,10 @@ reports it. Do not invent a second threshold; author to the one that is frozen (
 | Node count | Every node earns its transition round-trip | A node that always runs immediately after another, with no guard between them, is one node |
 
 **When a node breaches the budget, do not reformat to dodge the measure.** Joining five lines with
-`&&` moves the complexity, not the ownership. Pick an owner from the five recorded options in
+`&&` moves the complexity, not the ownership. Pick one of the four remaining owners from
 `docs/design/workflow-shell-ownership.md`: public `spur` verb (consent-gated), application service,
-least-privilege built-in action kind, workflow-relative external extension, or a recorded
-stays-shell exception with its reason in `config/workflow-composition-baseline.json`.
+least-privilege built-in action kind, or workflow-relative external extension. (0775 retired the
+recorded stays-shell exception along with the suppression snapshot.)
 
 **Advisory posture is binding.** Composition findings never block a run, never change a `validate`
 exit status, and are never a reason to hot-edit an executing pipeline. Surface them; fix on operator
@@ -193,8 +193,8 @@ Steps:
 2. **Return each node's work to its owner** — judgment nodes to the command or skill they should
    have been calling; a genuinely useful shell sequence to one script under its owning surface.
 3. **Rewrite the entry surface as the procedure**, in the order the graph ran.
-4. **Delete the YAML and its `config/workflow-composition-baseline.json` entries** in the same
-   change. A baseline entry whose action no longer exists fails the two-sided check.
+4. **Delete the YAML** in the same change. (0775 retired the composition-baseline entries that
+   used to be deleted alongside it; the live definition is the only artifact left.)
 5. **Record the demotion** and its trigger, so the next author does not re-promote it by reflex.
 
 ### optimize — refine an accepted workflow in place

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

@@ -231,10 +231,10 @@ agent prompts where a first-class surface would own it better?" — nothing more
   raw prompt length only sets the reported severity (<200 low / ≤1000 medium / >1000 high).
 
 **How to run it:** it is not a separate command — `spur workflow validate <file> --json` returns
-`composition: {findings[], suppressed}` on the valid path; human mode prints the advisory to stderr
-with exit 0. Actions with a recorded disposition in
-`config/workflow-composition-baseline.json` (resolved by walking up from the workflow file) are
-counted in `suppressed`, not `findings`.
+`composition: {findings[]}` on the valid path; human mode prints the advisory to stderr
+with exit 0. Findings are derived from the workflow definition itself
+(`extractResolvedWorkflowFacts`, guarded by `composition-baseline.test.ts`); 0775 retired the
+suppression snapshot, so every finding is reported — none are suppressed.
 
 **How to read it, and the fix path per defect class:**
 

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

@@ -153,6 +153,23 @@ CLI does.
 
 ## Gotchas
 
+### Bounded execution and recovery (0777)
+
+- During planning/refinement of corpus-scale work, record an execution budget, persisted-artifact
+  paths and requireDiff guidance in the task Design. For classification-only work, declare
+  `mutationPolicy: none`; its task/evidence change is the deliverable, not invented source edits.
+  Preserve partial artifacts at the budget boundary; resume only against the current task contract.
+- Before accepting a child/watcher result, compare its run ID with the dispatched run ID and check
+  current trace state through Spur. If using a run log as evidence, require its mtime to be at least
+  the dispatch time. A mismatch or stale timestamp is not completion evidence. Do not scrape terminals.
+  Bound each watch invocation to 10 minutes or 20 polls, whichever comes first; persist the last
+  confirmed identity/state and report a checkpoint before continuing. A watcher timeout does not
+  cancel the owned run or authorize launching a replacement.
+- Mark superseded scratch with `SUPERSEDED` and a pointer to the authoritative task Design. Never
+  let a scratch instruction override the live task, even when its old run is still readable.
+- Checker-policy changes require one explicit unsuppressed audit (T10); ordinary corpus commit
+  prep checks affected documents and linked evidence (T11), not the corpus. No acceptance snapshots.
+
 1. **Never skip a gate.** A clean `feature check` is the only proof the AC is valid; a
    passing `batch-create` is the only proof the decomposition is well-formed. Skip either and
    you ship corrupted corpus.

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

@@ -887,9 +887,9 @@ time. Before launching a full `spur-check-new`:
    `console.*`), spawn processes via `NodeProcessExecutor` (no `Bun.spawnSync`), get a
    `runtime-boundaries` fs-io exemption for sync reads (mirrors `task.ts`), and a non-command helper
    must not live in `apps/cli/src/commands/` (the noun scan treats every file there as a noun).
-3. **Doc/TSDoc edits shift `file:line` anchors** cited by other tasks — `corpus-check` surfaces them
-   as `L4.anchor-subject-mismatch`. Repoint the shifted citations (via `spur task update --section`)
-   in the same commit, and reconcile new/stale baseline entries before the gate run.
+3. **Doc/TSDoc edits shift `file:line` anchors** cited by other tasks — the per-task gate surfaces
+   them as `L4.anchor-subject-mismatch` (0775: the corpus sweep retired; run `spur task check <wbs>`
+   on touched tasks). Repoint the shifted citations (via `spur task update --section`)
 
 ## AC traceability
 

package/plugins/sp/skills/spur-dev/references/gate-checklists.md

@@ -170,7 +170,7 @@ transition to `done`.
 > The verify skill writes this shape automatically — operators only need it when hand-authoring
 > an answer file or debugging an UNKNOWN verdict.
 
-> **Corpus baseline discipline (`corpus-check`).** `corpus-check` sweeps every task/feature and fails on any structural finding outside `config/corpus-baseline.json`. The baseline is two-sided: an unlisted finding fails, **and** a listed entry that no longer reproduces fails. When introducing or tightening finding rules, reconcile the fallout in the same commit (constitution **T10**).
+> **Finding-rule discipline (ADR-108).** When checker policy changes, run focused tests and one explicit unsuppressed `bun run corpus-check` audit; record/reconcile essential failures without waivers (T10). Ordinary corpus commit prep checks changed tasks/features and their required linked evidence, not the corpus (T11). The baseline and regenerators remain deleted; tests are not a substitute for the explicit policy-change audit.
 >
 > **Transition-shim discipline (`transition-shim-check`, task 0541 / ADR-058).** Wired as an early step of `spur-check` / `spur-check-new` (second, after `link-check` and before `lint`) so a shim violation fails in ~0.3 s rather than after the test run. Two-sided against `config/transition-shims.json`: an `@transition-shim(<id>)` marker with no manifest entry fails as a **new unregistered shim**, **and** a listed entry whose marker is gone from source fails as a **stale entry**. Emptying the manifest is the definition of the agent-role transition being complete. A removal condition must be objectively checkable against the repository. Shapes: `docs/04_DESIGN.md` §2.5.
 
@@ -188,4 +188,3 @@ transition to `done`.
 > failure is not yours. This costs seconds and mutates nothing — do **not** `git stash` to get a
 > clean baseline on a shared working tree. Treat any failure that does *not* name a port/listen/`ps`
 > cause as yours until proven otherwise; the count is a moving baseline, not a constant.
-