@gobing-ai/spur 0.3.77 → 0.3.78

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     "plugins": [
         {
             "name": "sp",
-            "version": "0.3.77",
+            "version": "0.3.78",
             "source": "./plugins/sp"
         }
     ]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.77",
+    "version": "0.3.78",
     "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",
@@ -53,14 +53,14 @@
     },
     "devDependencies": {
         "@commander-js/extra-typings": "^14.0.0",
-        "@gobing-ai/ts-db": "^0.4.57",
-        "@gobing-ai/ts-ai-runner": "^0.4.57",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.4.57",
-        "@gobing-ai/ts-infra": "^0.4.57",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.57",
-        "@gobing-ai/ts-rule-engine": "^0.4.57",
-        "@gobing-ai/ts-runtime": "^0.4.57",
-        "@gobing-ai/ts-utils": "^0.4.57",
+        "@gobing-ai/ts-db": "^0.4.60",
+        "@gobing-ai/ts-ai-runner": "^0.4.60",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.60",
+        "@gobing-ai/ts-infra": "^0.4.60",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.60",
+        "@gobing-ai/ts-rule-engine": "^0.4.60",
+        "@gobing-ai/ts-runtime": "^0.4.60",
+        "@gobing-ai/ts-utils": "^0.4.60",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

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

@@ -62,5 +62,6 @@ thread `--depth` into each per-task refine.
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Apply the [shared startup contract](../skills/spur-dev/references/cross-cutting.md#shared-startup-contract-task-0814-r1r3r4r6r7r8) — bootstrap checklist, quick readiness before isolation, workflow inventory before YAML, comprehensive checks at owning boundaries (task 0814 R1/R3/R4/R7/R8).
 - Batch orchestration: `Skill(skill="sp:spur-dev", args="refineall $ARGUMENTS")`
 - Per-task refine (inner): `Skill(skill="sp:spur-dev", args="refine <wbs> $SHARED_FLAGS")`

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

@@ -31,6 +31,7 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Apply the [shared startup contract](../skills/spur-dev/references/cross-cutting.md#shared-startup-contract-task-0814-r1r3r4r6r7r8) — bootstrap checklist, quick readiness before isolation, workflow inventory before YAML, comprehensive checks at their owning boundaries (task 0814 R1/R3/R4/R7/R8).
 - Full pipeline (default `--mode full`): interactive omit/`--agent inline` uses the
   [inline pipeline driver](../skills/spur-dev/references/inline-pipeline-driver.md) via
   `Skill(skill="sp:spur-dev", args="run-inline $ARGUMENTS")`; `--agent auto` or a named executor

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

@@ -82,5 +82,6 @@ full distinction.
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface). Interactive sequential omit/`inline` keeps the orchestrator in the host session through the [inline pipeline driver](../skills/spur-dev/references/inline-pipeline-driver.md); the resolved selector applies uniformly — eligible `agent.run` stages dispatch once to a native subagent with host fallback (0508). `--agent auto`, a name, or parallel mode retains the isolated per-task workflow boundary.
+- Apply the [shared startup contract](../skills/spur-dev/references/cross-cutting.md#shared-startup-contract-task-0814-r1r3r4r6r7r8) — bootstrap checklist, quick readiness before isolation, workflow inventory before YAML, comprehensive checks at owning boundaries (task 0814 R1/R3/R4/R7/R8).
 - Interactive sequential omit/inline: `Skill(skill="sp:spur-dev", args="runall-inline $ARGUMENTS")`.
 - Explicit executor or parallel mode: `Skill(skill="sp:spur-dev", args="runall $ARGUMENTS")` → `sp:super-planner` agent.

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

@@ -68,6 +68,7 @@ Without `--fix all`, shippable is not evaluated (optional note: use `--fix all`
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Apply the [shared startup contract](../skills/spur-dev/references/cross-cutting.md#shared-startup-contract-task-0814-r1r3r4r6r7r8) — bootstrap checklist, quick readiness before isolation, workflow inventory before YAML, comprehensive checks at owning boundaries (task 0814 R1/R3/R4/R7/R8).
 - Batch orchestration: `Skill(skill="sp:spur-dev", args="verifyall $ARGUMENTS")`
 - Per-task verification (inner): `Skill(skill="sp:code-verification", args="verify <wbs> $SHARED_FLAGS")`
 - Shippable gate: once after the batch (same skill § Shippable readiness gate)

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.77",
+    "version": "0.3.78",
     "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/scripts/batch-preflight.mjs

@@ -3,6 +3,119 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // plugins/sp/scripts/batch-preflight.ts
+function quickReadiness(input) {
+  const status = (input.status ?? "").toLowerCase();
+  const operation = input.operation;
+  if (operation !== "run" && operation !== "refine" && operation !== "verify") {
+    return {
+      action: "invalid",
+      code: "IV",
+      reason: `quick-readiness: unknown operation '${operation}' (${input.wbs})`
+    };
+  }
+  if (input.filteredCount !== undefined) {
+    if (input.filteredCount < 0) {
+      return {
+        action: "invalid",
+        code: "IV",
+        reason: `quick-readiness: invalid negative filtered count '${input.filteredCount}' (${input.wbs})`
+      };
+    }
+    if (input.filteredCount === 0) {
+      return {
+        action: "skipped",
+        code: "EMPTY",
+        reason: `quick-readiness: empty status-filtered set — nothing to ${operation} (${input.wbs})`
+      };
+    }
+  }
+  if (status === "cancelled" || status === "done") {
+    if (operation === "verify" && input.force === true) {
+      return {
+        action: "runnable",
+        code: "FORCE",
+        reason: `quick-readiness: verify --force re-verification of ${status} task ${input.wbs}`
+      };
+    }
+    return {
+      action: "skipped",
+      code: status === "done" ? "DONE" : "CANCELLED",
+      reason: `quick-readiness: already ${status} — no ${operation} hop (${input.wbs})`
+    };
+  }
+  if (status === "blocked") {
+    return {
+      action: "blocked",
+      code: "BLK",
+      reason: `quick-readiness: blocked — human/handover first (${input.wbs})`
+    };
+  }
+  if (operation === "run" && input.dependencies && input.dependencies.length > 0) {
+    const unmet = input.dependencies.filter((d) => (input.depStatuses?.[d] ?? "missing").toLowerCase() !== "done");
+    if (unmet.length > 0) {
+      return {
+        action: "blocked",
+        code: "DEP",
+        reason: `quick-readiness: unmet deps — ${unmet.join(", ")} (${input.wbs})`,
+        unmetDeps: unmet
+      };
+    }
+  }
+  const required = input.requiredSections ?? [];
+  const present = input.presentSections ?? [];
+  const gaps = required.filter((s) => {
+    const finding = input.sectionFindings?.[s];
+    return !present.includes(s) || finding !== undefined && finding !== "";
+  });
+  if (operation === "refine") {
+    if (status !== "backlog" && status !== "todo") {
+      return {
+        action: "skipped",
+        code: "NONPLAN",
+        reason: `quick-readiness: refine targets backlog/todo only, not '${status}' (${input.wbs})`
+      };
+    }
+    return {
+      action: "runnable",
+      code: "OK",
+      reason: `quick-readiness: refine ready for ${input.wbs} (${gaps.length} planning gap(s) to fill)`
+    };
+  }
+  if (operation === "verify") {
+    if (status !== "testing" && status !== "wip") {
+      return {
+        action: "invalid",
+        code: "NOVERIFY",
+        reason: `quick-readiness: verify needs testing/wip, not '${status}' (${input.wbs})`
+      };
+    }
+    return {
+      action: "runnable",
+      code: "OK",
+      reason: `quick-readiness: verify ready for ${input.wbs}`
+    };
+  }
+  if (status !== "todo" && status !== "wip" && status !== "testing") {
+    return {
+      action: "invalid",
+      code: "NORUN",
+      reason: `quick-readiness: run needs todo/wip/testing, not '${status}' (${input.wbs})`
+    };
+  }
+  if (gaps.length > 0) {
+    return {
+      action: "needs-refinement",
+      code: "REFINE",
+      reason: `quick-readiness: implementation sections incomplete (${input.wbs})`,
+      gaps
+    };
+  }
+  return {
+    action: "runnable",
+    code: "OK",
+    reason: `quick-readiness: run ready for ${input.wbs}`
+  };
+}
 function preflightTask(input) {
   const status = (input.status ?? "").toLowerCase();
   const deps = input.dependencies ?? [];
@@ -72,6 +185,11 @@ function parsePreflightCliArgs(argv) {
   let recovery = false;
   let help = false;
   let json = false;
+  let operation = null;
+  let force = false;
+  let filteredCount = null;
+  let requiredSections = [];
+  let presentSections = [];
   for (let i = 0;i < argv.length; i++) {
     const a = argv[i];
     if (a === "--help" || a === "-h")
@@ -80,7 +198,21 @@ function parsePreflightCliArgs(argv) {
       json = true;
     else if (a === "--recovery")
       recovery = true;
-    else if (a === "--wbs")
+    else if (a === "--force")
+      force = true;
+    else if (a === "--operation") {
+      const v = argv[++i] ?? "";
+      operation = v === "run" || v === "refine" || v === "verify" ? v : null;
+    } else if (a === "--filtered-count") {
+      const v = Number(argv[++i]);
+      filteredCount = Number.isFinite(v) ? v : null;
+    } else if (a === "--required-sections") {
+      const raw = argv[++i] ?? "";
+      requiredSections = raw.length === 0 ? [] : raw.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a === "--present-sections") {
+      const raw = argv[++i] ?? "";
+      presentSections = raw.length === 0 ? [] : raw.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a === "--wbs")
       wbs = argv[++i] ?? wbs;
     else if (a === "--status")
       status = argv[++i] ?? null;
@@ -96,11 +228,25 @@ function parsePreflightCliArgs(argv) {
       }
     }
   }
-  return { status, deps, depStatuses, wbs, recovery, help, json };
+  return {
+    status,
+    deps,
+    depStatuses,
+    wbs,
+    recovery,
+    help,
+    json,
+    operation,
+    force,
+    filteredCount,
+    requiredSections,
+    presentSections
+  };
 }
 var PREFLIGHT_CLI_USAGE = `Usage:
   bun plugins/sp/scripts/batch-preflight.ts --wbs <wbs> --status <status> \\
     [--deps 0275,0276] [--dep-status 0275:done,0276:todo] [--recovery] [--json]
+  bun plugins/sp/scripts/batch-preflight.ts --operation <run|refine|verify> --wbs <wbs> --status <status>     [--filtered-count <n>] [--required-sections A,B] [--present-sections A,B] [--force] [--json]
 
 Exit: 0 = run (or recovery hint printed); 2 = skip; 1 = usage.`;
 function runPreflightCli(argv) {
@@ -117,6 +263,30 @@ function runPreflightCli(argv) {
 `;
     return { exitCode: 0, stdout: body, stderr: "" };
   }
+  if (args.operation !== null) {
+    const result2 = quickReadiness({
+      wbs: args.wbs,
+      status: args.status,
+      operation: args.operation,
+      dependencies: args.deps,
+      depStatuses: args.depStatuses,
+      ...args.filteredCount !== null ? { filteredCount: args.filteredCount } : {},
+      ...args.requiredSections.length > 0 ? { requiredSections: args.requiredSections } : {},
+      ...args.presentSections.length > 0 ? { presentSections: args.presentSections } : {},
+      ...args.force ? { force: true } : {}
+    });
+    const runnable = result2.action === "runnable" || result2.action === "needs-refinement";
+    if (args.json) {
+      return { exitCode: runnable ? 0 : 2, stdout: `${JSON.stringify(result2, null, 2)}
+`, stderr: "" };
+    }
+    return {
+      exitCode: runnable ? 0 : 2,
+      stdout: `${result2.action}${result2.code ? ` ${result2.code}` : ""}: ${result2.reason}
+`,
+      stderr: ""
+    };
+  }
   const result = preflightTask({
     wbs: args.wbs,
     status: args.status,
@@ -154,6 +324,7 @@ function runPreflightCli(argv) {
 export {
   runPreflightCli,
   recoveryHint,
+  quickReadiness,
   preflightTask,
   parsePreflightCliArgs,
   PREFLIGHT_CLI_USAGE

package/plugins/sp/scripts/batch-preflight.ts

@@ -25,6 +25,182 @@ export type PreflightResult =
     | { action: 'run'; code?: string; reason?: string }
     | { action: 'skip'; code: string; reason: string; unmetDeps?: string[] };
 
+// ── Command-aware quick readiness (task 0814 R2) ──────────────────────────────
+// Read-only admission decision for the requested dev operation. Distinguishes
+// runnable / needs-refinement / blocked / skipped / invalid outcomes without
+// LLM dispatch, full tests/lint, live-data probes, feature mutation, or
+// corpus-wide relational checking. Refinement gaps are work to do, not errors.
+
+export type ReadinessOperation = 'run' | 'refine' | 'verify';
+
+export interface QuickReadinessInput {
+    wbs: string;
+    status: TaskStatus;
+    operation: ReadinessOperation;
+    /** Frontmatter dependencies[] WBS list (run only). */
+    dependencies?: string[];
+    /** Status of each dependency WBS; missing → treated as unmet (run only). */
+    depStatuses?: Record<string, string>;
+    /** Size of the status-filtered candidate set after the selector resolved; 0 = empty set. */
+    filteredCount?: number;
+    /** Required planning sections for this variant+status; empty = not applicable. */
+    requiredSections?: string[];
+    /** Sections that are actually present (non-placeholder) in the task. */
+    presentSections?: string[];
+    /** L1/L2/L3 content-policy findings keyed by section; empty = clean. */
+    sectionFindings?: Record<string, string>;
+    /** Verify only: re-verification semantics (--force) — never a dirty-tree bypass. */
+    force?: boolean;
+}
+
+export type QuickReadinessResult =
+    | { action: 'runnable'; code: string; reason: string }
+    | { action: 'needs-refinement'; code: string; reason: string; gaps: string[] }
+    | { action: 'blocked'; code: string; reason: string; unmetDeps?: string[] }
+    | { action: 'skipped'; code: string; reason: string }
+    | { action: 'invalid'; code: string; reason: string };
+
+/**
+ * Evaluate quick readiness for a requested dev operation (0814 R2). Read-only:
+ * no model, no full tests/lint, no live-data probe, no feature mutation, no
+ * corpus-wide relational check. An empty status-filtered set is `skipped`
+ * (mirrors the zero-task rule), never an error. Refinement gaps under `refine`
+ * are work to do, so they do not block; under `run` they are `needs-refinement`.
+ */
+export function quickReadiness(input: QuickReadinessInput): QuickReadinessResult {
+    const status = (input.status ?? '').toLowerCase();
+    const operation = input.operation;
+
+    if (operation !== 'run' && operation !== 'refine' && operation !== 'verify') {
+        return {
+            action: 'invalid',
+            code: 'IV',
+            reason: `quick-readiness: unknown operation '${operation}' (${input.wbs})`,
+        };
+    }
+
+    if (input.filteredCount !== undefined) {
+        if (input.filteredCount < 0) {
+            return {
+                action: 'invalid',
+                code: 'IV',
+                reason: `quick-readiness: invalid negative filtered count '${input.filteredCount}' (${input.wbs})`,
+            };
+        }
+        if (input.filteredCount === 0) {
+            return {
+                action: 'skipped',
+                code: 'EMPTY',
+                reason: `quick-readiness: empty status-filtered set — nothing to ${operation} (${input.wbs})`,
+            };
+        }
+    }
+
+    if (status === 'cancelled' || status === 'done') {
+        // verify --force re-verification (R2 AC): an already-verified terminal task
+        // is re-checked, not skipped — but force never bypasses a dirty tree or the
+        // owning gates; it only re-admits a terminal task for re-verification.
+        if (operation === 'verify' && input.force === true) {
+            return {
+                action: 'runnable',
+                code: 'FORCE',
+                reason: `quick-readiness: verify --force re-verification of ${status} task ${input.wbs}`,
+            };
+        }
+        return {
+            action: 'skipped',
+            code: status === 'done' ? 'DONE' : 'CANCELLED',
+            reason: `quick-readiness: already ${status} — no ${operation} hop (${input.wbs})`,
+        };
+    }
+
+    if (status === 'blocked') {
+        return {
+            action: 'blocked',
+            code: 'BLK',
+            reason: `quick-readiness: blocked — human/handover first (${input.wbs})`,
+        };
+    }
+
+    // Unmet out-of-set dependency is a block for the operation that needs it.
+    if (operation === 'run' && input.dependencies && input.dependencies.length > 0) {
+        const unmet = input.dependencies.filter((d) => (input.depStatuses?.[d] ?? 'missing').toLowerCase() !== 'done');
+        if (unmet.length > 0) {
+            return {
+                action: 'blocked',
+                code: 'DEP',
+                reason: `quick-readiness: unmet deps — ${unmet.join(', ')} (${input.wbs})`,
+                unmetDeps: unmet,
+            };
+        }
+    }
+
+    const required = input.requiredSections ?? [];
+    const present = input.presentSections ?? [];
+    // A required section is a gap when it is absent from the present-set OR carries a
+    // content-policy finding (the caller-supplied `sectionFindings` from the matrix /
+    // `TaskCheckService.checkContentPolicy`). This lets the function detect a gap itself
+    // rather than depending on the caller to pre-enumerate every missing section.
+    const gaps = required.filter((s) => {
+        const finding = input.sectionFindings?.[s];
+        return !present.includes(s) || (finding !== undefined && finding !== '');
+    });
+
+    // refine: missing/incomplete planning sections are the work, not a failure.
+    if (operation === 'refine') {
+        if (status !== 'backlog' && status !== 'todo') {
+            return {
+                action: 'skipped',
+                code: 'NONPLAN',
+                reason: `quick-readiness: refine targets backlog/todo only, not '${status}' (${input.wbs})`,
+            };
+        }
+        return {
+            action: 'runnable',
+            code: 'OK',
+            reason: `quick-readiness: refine ready for ${input.wbs} (${gaps.length} planning gap(s) to fill)`,
+        };
+    }
+
+    if (operation === 'verify') {
+        if (status !== 'testing' && status !== 'wip') {
+            return {
+                action: 'invalid',
+                code: 'NOVERIFY',
+                reason: `quick-readiness: verify needs testing/wip, not '${status}' (${input.wbs})`,
+            };
+        }
+        return {
+            action: 'runnable',
+            code: 'OK',
+            reason: `quick-readiness: verify ready for ${input.wbs}`,
+        };
+    }
+
+    // run: implementation admission. Eligible statuses are todo/wip/testing;
+    // a backlog task needs the chain's auto-promotion first (step 0).
+    if (status !== 'todo' && status !== 'wip' && status !== 'testing') {
+        return {
+            action: 'invalid',
+            code: 'NORUN',
+            reason: `quick-readiness: run needs todo/wip/testing, not '${status}' (${input.wbs})`,
+        };
+    }
+    if (gaps.length > 0) {
+        return {
+            action: 'needs-refinement',
+            code: 'REFINE',
+            reason: `quick-readiness: implementation sections incomplete (${input.wbs})`,
+            gaps,
+        };
+    }
+    return {
+        action: 'runnable',
+        code: 'OK',
+        reason: `quick-readiness: run ready for ${input.wbs}`,
+    };
+}
+
 /**
  * Evaluate whether the batch should launch task-pipeline.yaml for this WBS.
  * STOP codes align with routing-table TABLE A row ids (A2, A7, A8, A9).
@@ -113,6 +289,16 @@ export interface PreflightCliArgs {
     recovery: boolean;
     help: boolean;
     json: boolean;
+    /** Quick-readiness operation (run|refine|verify); when set, run quickReadiness. */
+    operation: ReadinessOperation | null;
+    /** Verify-only re-verification (R2 AC). */
+    force: boolean;
+    /** Status-filtered candidate set size; 0 = empty set. */
+    filteredCount: number | null;
+    /** Required planning sections (matrix-selected). */
+    requiredSections: string[];
+    /** Sections actually present in the task. */
+    presentSections: string[];
 }
 
 export function parsePreflightCliArgs(argv: string[]): PreflightCliArgs {
@@ -123,13 +309,43 @@ export function parsePreflightCliArgs(argv: string[]): PreflightCliArgs {
     let recovery = false;
     let help = false;
     let json = false;
+    let operation: ReadinessOperation | null = null;
+    let force = false;
+    let filteredCount: number | null = null;
+    let requiredSections: string[] = [];
+    let presentSections: string[] = [];
 
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === '--help' || a === '-h') help = true;
         else if (a === '--json') json = true;
         else if (a === '--recovery') recovery = true;
-        else if (a === '--wbs') wbs = argv[++i] ?? wbs;
+        else if (a === '--force') force = true;
+        else if (a === '--operation') {
+            const v = argv[++i] ?? '';
+            operation = v === 'run' || v === 'refine' || v === 'verify' ? v : null;
+        } else if (a === '--filtered-count') {
+            const v = Number(argv[++i]);
+            filteredCount = Number.isFinite(v) ? v : null;
+        } else if (a === '--required-sections') {
+            const raw = argv[++i] ?? '';
+            requiredSections =
+                raw.length === 0
+                    ? []
+                    : raw
+                          .split(',')
+                          .map((s) => s.trim())
+                          .filter(Boolean);
+        } else if (a === '--present-sections') {
+            const raw = argv[++i] ?? '';
+            presentSections =
+                raw.length === 0
+                    ? []
+                    : raw
+                          .split(',')
+                          .map((s) => s.trim())
+                          .filter(Boolean);
+        } else if (a === '--wbs') wbs = argv[++i] ?? wbs;
         else if (a === '--status') status = argv[++i] ?? null;
         else if (a === '--deps') {
             const raw = argv[++i] ?? '';
@@ -149,12 +365,27 @@ export function parsePreflightCliArgs(argv: string[]): PreflightCliArgs {
             }
         }
     }
-    return { status, deps, depStatuses, wbs, recovery, help, json };
+    return {
+        status,
+        deps,
+        depStatuses,
+        wbs,
+        recovery,
+        help,
+        json,
+        operation,
+        force,
+        filteredCount,
+        requiredSections,
+        presentSections,
+    };
 }
 
 export const PREFLIGHT_CLI_USAGE = `Usage:
   bun plugins/sp/scripts/batch-preflight.ts --wbs <wbs> --status <status> \\
     [--deps 0275,0276] [--dep-status 0275:done,0276:todo] [--recovery] [--json]
+  bun plugins/sp/scripts/batch-preflight.ts --operation <run|refine|verify> --wbs <wbs> --status <status> \
+    [--filtered-count <n>] [--required-sections A,B] [--present-sections A,B] [--force] [--json]
 
 Exit: 0 = run (or recovery hint printed); 2 = skip; 1 = usage.`;
 
@@ -173,6 +404,30 @@ export function runPreflightCli(argv: string[]): { exitCode: number; stdout: str
         return { exitCode: 0, stdout: body, stderr: '' };
     }
 
+    // Quick command-aware readiness (0814 R2) — read-only admission decision.
+    if (args.operation !== null) {
+        const result = quickReadiness({
+            wbs: args.wbs,
+            status: args.status,
+            operation: args.operation,
+            dependencies: args.deps,
+            depStatuses: args.depStatuses,
+            ...(args.filteredCount !== null ? { filteredCount: args.filteredCount } : {}),
+            ...(args.requiredSections.length > 0 ? { requiredSections: args.requiredSections } : {}),
+            ...(args.presentSections.length > 0 ? { presentSections: args.presentSections } : {}),
+            ...(args.force ? { force: true } : {}),
+        });
+        const runnable = result.action === 'runnable' || result.action === 'needs-refinement';
+        if (args.json) {
+            return { exitCode: runnable ? 0 : 2, stdout: `${JSON.stringify(result, null, 2)}\n`, stderr: '' };
+        }
+        return {
+            exitCode: runnable ? 0 : 2,
+            stdout: `${result.action}${result.code ? ` ${result.code}` : ''}: ${result.reason}\n`,
+            stderr: '',
+        };
+    }
+
     const result = preflightTask({
         wbs: args.wbs,
         status: args.status,

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

@@ -288,12 +288,17 @@ function stripAcWrappers(title: string): string {
  * and still fails.
  */
 function normalizeAcTitle(title: string): string {
-    return stripAcWrappers(title)
-        .replace(/^R\d+\s*[:\-—]?\s*/, '')
-        .toLowerCase()
-        .replace(/[ʼ‘’“”]/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
+    return (
+        stripAcWrappers(title)
+            .replace(/^R\d+\s*[:\-—]?\s*/, '')
+            .toLowerCase()
+            // Exact pre-refactor removal set (0809 R5): ASCII apostrophe + the four curly
+            // quotes. Escaped form keeps U+0027 visible next to lookalike curly glyphs;
+            // U+02BC stays a meaningful character, never removable punctuation.
+            .replace(/[\u0027\u2018\u2019\u201c\u201d]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim()
+    );
 }
 
 /**

package/plugins/sp/skills/spur-dev/references/cross-cutting.md

@@ -209,6 +209,39 @@ executor is the current coding agent. Interactive pipelines retain a run log and
 through the inline driver; task pipelines additionally record a task run-link. If process isolation or an independently killable
 stage is required, select the subprocess path (`--agent auto` or `--agent <name>`).
 
+## Shared startup contract (task 0814 R1/R3/R4/R6/R7/R8)
+
+The workflow-backed dev commands (`dev-run`, `dev-runall`, `dev-refineall`, `dev-verifyall`) share one
+startup order. The order is load-bearing and applies on both the inline driver and the subprocess
+path; skill-only operations (refine/verify batches with no nested workflow) display their owned
+procedure and do not fabricate a workflow YAML.
+
+1. **Publish a compact bootstrap checklist immediately** (host-preparation rows, never copied
+   workflow states): `A, Quick readiness` · `B, Prepare Git` · `C, Publish workflow plan` ·
+   `D, Comprehensive checking`.
+2. **Quick deterministic readiness (R2), before isolation.** Evaluate `quickReadiness`
+   (`plugins/sp/scripts/batch-preflight.ts`) with the operation, status, filtered-set size, and the
+   selected matrix required/present sections + content-policy findings. This is an admission decision
+   (runnable / needs-refinement / blocked / skipped / invalid), never an implementation certificate.
+3. **Isolation (R3), only when `--worktree` is valid.** After quick readiness and the required Git
+   safety checks, create/adopt and switch to the execution tree; confirm absolute cwd, branch, base
+   SHA, and ownership. An invalid/empty target, unsupported mode, ambiguous ownership, or stale target
+   stops without creating a tree or discarding work. All subsequent tools, agents, corpus writes, and
+   run artifacts use the confirmed execution tree.
+4. **Publish the workflow inventory (R4), before reading the YAML.** `spur workflow show
+   <resolved-file> --no-logo --format todo --json`; validate with `parseWorkflowInventory` and bind to
+   the run's `__definitionDigest` with `assertInventoryIdentity`. Drift or projection failure stops the
+   run before any comprehensive/model work — never execute with a misleading plan.
+5. **Load execution detail and run comprehensive checks (R7).** Only after the plan is visible (and
+   after isolation when requested) load the full YAML for the active stage and run the owning
+   comprehensive gates at their boundaries. Prefer deterministic checks; invoke semantic model work
+   only for an identified unresolved requirement/design/evidence question and record its reason.
+
+Quick readiness and plan projection dispatch zero models and execute zero workflow actions. Record a
+timestamped event trace under `.spur/run/<run-id>-event-trace.md` (R8) — event ordering,
+time-to-first-visible-checklist, time-to-workflow-inventory, confirmed cwd, invocation counts — and
+record unavailable measurements as `unknown`, never as invented savings.
+
 ## Every write is CLI-gated
 
 Never edit a task or feature file directly. Every mutation goes through: