@gobing-ai/spur 0.3.68 → 0.3.70

package/config/workflows/basic.yaml

@@ -24,7 +24,7 @@ failureStates:
 vars:
   # `task` is reserved by the engine runtime — use taskLabel for the free-form label.
   taskLabel: "task"
-  agent: "omp"
+  agent: "auto"
   stepTimeoutMs: "1800000"
   # Override per project: `--vars '{"qualityGateCmd":"bun run lint && bun run test"}'`
   qualityGateCmd: "bun run check"

package/config/workflows/docs-pipeline.yaml

@@ -30,7 +30,7 @@ vars:
   wbs: "0000"
   profile: "standard"
   spurBin: "spur"
-  agent: "omp"
+  agent: "auto"
   stepTimeoutMs: "1800000"
   # Proof-state bracket (task 0704, mirroring task-pipeline 0612/0703). `proofDigest` is the
   # canonical capture at verify entry; `proofDigestNow` is the live re-capture compared against

package/config/workflows/feature-dev.yaml

@@ -44,7 +44,7 @@ failureStates:
   - failed
 vars:
   featureId: ""
-  agent: "omp"
+  agent: "auto"
   profile: "standard"
   spurBin: "spur"
   stepTimeoutMs: "1800000"

package/config/workflows/idea-pipeline.yaml

@@ -65,7 +65,7 @@ vars:
   spurBin: "spur"
   # R8 (0366): injected by WorkflowAppService.run(); stamps discovery artifact provenance.
   __runId: ""
-  agent: "omp"
+  agent: "auto"
   planningAgent: ""
   stepTimeoutMs: "1800000"
 

package/config/workflows/task-pipeline.yaml

@@ -54,15 +54,16 @@ vars:
   # runs and `workflow validate` resolve the template. (See AGENTS.md / ADR-026.)
   spurBin: "spur"
   # Agent the pipeline's agent.run steps invoke. Override per run with
-  # `--vars '{"agent":"claude"}'`. Pinned (not left to the AiRunner's <default>
-  # selection) so a broken/misconfigured agent on the box can't silently capture the run.
-  agent: "omp"
-  # Implement-only executor override (R1, task 0454). Resolves to this YAML literal
-  # unless overridden. The `--agent` flag (execution-batch.md §3.2) forwards into BOTH
+  # `--vars '{"agent":"claude"}'`. `auto` is the reserved config-resolving selector:
+  # `agent.default` role -> tier -> cheapest USABLE executor. A named literal here would
+  # pin a box-specific binary into tracked SSOT and escape that usability ladder.
+  agent: "auto"
+  # Implement-only executor override (R1, task 0454). Resolves like `agent` unless
+  # overridden. The `--agent` flag (execution-batch.md §3.2) forwards into BOTH
   # `agent` and `implementAgent`, so a pinned `--agent X` reaches implement too. To
   # pin ONLY implement while other hops keep the default, pass
   # `--vars '{"implementAgent":"omp-zai"}'`.
-  implementAgent: "omp"
+  implementAgent: "auto"
   # Step-level timeout for agentic hops (review / verify / test-fix) in ms.
   # Soft quality-gate shells are unbounded by this var (host shell only).
   # Raised 600s → 1800s (task 0398 R4 / H6 dogfood). Override:
@@ -174,6 +175,10 @@ states:
       # R1 (0453): auto-profile precheck reopens a done feature before task check.
       # Under profile=auto, resolve feature_id, sync (preferred) or update to active.
       # Under non-auto, leave R4 message to guide the operator.
+      # R3 (0723): a real reactivation failure is surfaced, not swallowed —
+      # the default 'fail' onEnter policy halts the sequence and routes the
+      # run to `failed` before implementation. Verbs stay single-shot:
+      # one sync, then one update fallback, never retried in a loop.
       - kind: shell
         options:
           command: >-
@@ -181,17 +186,23 @@ states:
               FID=$($spurBin task show $wbs --json 2>/dev/null |
               jq -r '.feature_id // .frontmatter.feature_id // empty' 2>/dev/null);
               if [ -n "$FID" ]; then
-                $spurBin feature sync "$FID" --force --json 2>/dev/null ||
-                $spurBin feature update "$FID" active 2>/dev/null || true;
+                if ! $spurBin feature sync "$FID" --force 2>/dev/null; then
+                if ! $spurBin feature update "$FID" active 2>/dev/null; then
+                echo "precheck: FAIL - feature reactivation $FID failed;" >&2;
+                echo "precheck: feature sync + feature update both errored" >&2;
+                exit 1;
+                fi;
+                fi;
               fi;
             fi;
             exit 0
-      # R2 (0454): task size precheck — evaluate R-item and Plan-item counts.
-      # Writes PASS/FAIL to .spur/run/<wbs>-precheck-size.status. Always exit 0
-      # (soft check, like doctor). The precheck→implement guard reads the file.
-      # Temporary config-only bypass (0723): keep deterministic size limits but defer
-      # the executor-tier policy to the dedicated task-pipeline upgrade. This avoids
-      # the script's second `spur agent doctor` call while the precheck path is repaired.
+      # R2 (0454, 0723): task size precheck — deterministic count-only
+      # evaluation of R-item and Plan-item counts. No executor-tier policy:
+      # dispatch-time requiresCapabilities at `agent.run` is the
+      # authoritative capability check. Writes PASS/FAIL to
+      # .spur/run/<wbs>-precheck-size.status. Always exit 0 (soft action);
+      # the precheck→implement guard reads the file, so a missing checker
+      # fails closed (writes FAIL, never PASS).
       - kind: shell
         options:
           command: >-
@@ -199,10 +210,31 @@ states:
             mkdir -p .spur/run &&
             if [ -f plugins/sp/scripts/task-size-precheck.ts ]; then
             bun plugins/sp/scripts/task-size-precheck.ts "$wbs"
-            --spur-bin "$spurBin" --max-reqs "$maxImplementReqs" --max-plan-items "$maxImplementPlanItems";
+            --spur-bin "$spurBin" --max-reqs "$maxImplementReqs"
+            --max-plan-items "$maxImplementPlanItems";
             else
-              echo "task-size-precheck skipped — plugins/sp/scripts/task-size-precheck.ts not present in project." >&2 &&
-              echo "PASS" > "$SIZE_FILE";
+              echo "task-size-precheck failed closed — checker script" >&2 &&
+              echo "plugins/sp/scripts/task-size-precheck.ts absent." >&2 &&
+              echo "FAIL" > "$SIZE_FILE";
+            fi &&
+            exit 0
+      # 0726 R2: task evidence precheck — deterministic live-data
+      # evidence-channel proof before implement dispatch. Writes PASS/FAIL to
+      # .spur/run/<wbs>-precheck-evidence.status. Always exit 0 (soft action);
+      # the precheck→implement guard reads the file, so a missing checker
+      # fails closed (writes FAIL, never PASS).
+      - kind: shell
+        options:
+          command: >-
+            EVID_FILE=".spur/run/$wbs-precheck-evidence.status" &&
+            mkdir -p .spur/run &&
+            if [ -f plugins/sp/scripts/task-evidence-precheck.ts ]; then
+            bun plugins/sp/scripts/task-evidence-precheck.ts "$wbs"
+            --spur-bin "$spurBin";
+            else
+              echo "task-evidence-precheck failed closed —" >&2 &&
+              echo "plugins/sp/scripts/task-evidence-precheck.ts absent." >&2 &&
+              echo "FAIL" > "$EVID_FILE";
             fi &&
             exit 0
 
@@ -523,7 +555,17 @@ states:
           priority: ${vars.taskPriority}
           compareExecutorWith: implement
           timeoutMs: ${vars.stepTimeoutMs}
-          answerFile: .spur/run/${vars.wbs}-verify-answer.txt
+          expectFile: .spur/run/${vars.wbs}-verify-answer.txt
+      # 0726 R3: hard lint gate over the verifier-owned answer — shape and
+      # evidence-row identity, before the verdict derivation reads it.
+      # Hard action: a malformed answer halts the sequence here instead of
+      # poisoning the verdict parse downstream.
+      - kind: shell
+        options:
+          command: >-
+            bun plugins/sp/scripts/verify-answer-lint.ts "$wbs"
+            --answer ".spur/run/$wbs-verify-answer.txt"
+            --spur-bin "$spurBin"
       - kind: shell
         options:
           command: "$spurBin task verdict $wbs --from-answer .spur/run/$wbs-verify-answer.txt"
@@ -666,11 +708,11 @@ transitions:
   # ── precheck: size PASS + task check → implement; else → failed ──
   - from: precheck
     to: implement
-    description: Deterministic size and task checks are green — begin implementation.
+    description: Deterministic size, evidence, and task checks are green — begin implementation.
     guard:
       kind: shell
       options:
-        command: 'test "$(cat .spur/run/$wbs-precheck-size.status 2>/dev/null)" = PASS && $spurBin task check $wbs'
+        command: 'test "$(cat .spur/run/$wbs-precheck-size.status 2>/dev/null)" = PASS && test "$(cat .spur/run/$wbs-precheck-evidence.status 2>/dev/null)" = PASS && $spurBin task check $wbs'
   - from: precheck
     to: failed
     description: Size and/or task check failed — stop before implement.

package/config/workflows/wayfinder-resolution.yaml

@@ -27,7 +27,7 @@ vars:
   wbs: "0000"
   profile: "standard"
   spurBin: "spur"
-  agent: "omp"
+  agent: "auto"
   stepTimeoutMs: "1800000"
   approval: "required"
   resolutionMode: "research"

package/config/workflows/wrapup-pipeline.yaml

@@ -49,7 +49,7 @@ vars:
   profile: "standard"
   merge: "false"
   spurBin: "spur"
-  agent: "omp"
+  agent: "auto"
   stepTimeoutMs: "1800000"
   # Corpus-aware quality gate for the feature-transition hop (R1, task 0625).
   # The per-task gate (`spur-check`) deliberately excludes corpus-check — the only

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.68",
+    "version": "0.3.70",
     "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.48",
-        "@gobing-ai/ts-ai-runner": "^0.4.48",
-        "@gobing-ai/ts-dual-workflow-engine": "^0.4.48",
-        "@gobing-ai/ts-infra": "^0.4.48",
-        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.48",
-        "@gobing-ai/ts-rule-engine": "^0.4.48",
-        "@gobing-ai/ts-runtime": "^0.4.48",
-        "@gobing-ai/ts-utils": "^0.4.48",
+        "@gobing-ai/ts-db": "^0.4.49",
+        "@gobing-ai/ts-ai-runner": "^0.4.49",
+        "@gobing-ai/ts-dual-workflow-engine": "^0.4.49",
+        "@gobing-ai/ts-infra": "^0.4.49",
+        "@gobing-ai/ts-llm-jsonl-importer": "^0.4.49",
+        "@gobing-ai/ts-rule-engine": "^0.4.49",
+        "@gobing-ai/ts-runtime": "^0.4.49",
+        "@gobing-ai/ts-utils": "^0.4.49",
         "@types/bun": "1.3.14",
         "@types/figlet": "^1.7.0",
         "@types/node-notifier": "8.0.5",

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.68",
+    "version": "0.3.70",
     "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/surface-drift-inventory.ts

@@ -473,11 +473,7 @@ export function executeScripts(root: string = PLUGIN_ROOT): void {
         writeFileSync(
             fake,
             `#!/bin/sh
-if [ "$1" = task ] && [ "$2" = show ]; then
-    printf '%s' '{"content":"### Requirements\\n- [ ] R1. x\\n### Plan\\n- [ ] p1"}'
-else
-    printf '%s' '{"agents":[{"capabilityTier":"standard"}]}'
-fi
+printf '%s' '{"content":"### Requirements\\n- [ ] R1. x\\n### Plan\\n- [ ] p1"}'
 `,
         );
         chmodSync(fake, 0o755);
@@ -485,7 +481,7 @@ fi
         try {
             execFileSync(
                 process.execPath,
-                [join(root, 'scripts', 'task-size-precheck.ts'), '0487', '--spur-bin', fake, '--executor', 'standard'],
+                [join(root, 'scripts', 'task-size-precheck.ts'), '0487', '--spur-bin', fake],
                 { cwd: dir, encoding: 'utf8', timeout: 30_000, stdio: 'pipe' },
             );
             const content = readFileSync(statusPath, 'utf8');
@@ -687,15 +683,6 @@ export function probeJsonShapes(run: CliRunner = runCli): void {
             { file: 'plugins/sp/scripts/surface-drift-inventory.ts', line: 1 },
         );
     }
-    const doctor = jsonEnvelopeShapes['spur agent doctor omp'];
-    const capOk = (doctor?.keys ?? []).some((k) => k.endsWith('.capabilityTier'));
-    record(
-        'agent doctor <name> --json -> agents[0].capabilityTier (asserted by task-size-precheck.ts:130)',
-        'json-exec(field-presence)',
-        capOk ? 'ok' : 'mismatch',
-        capOk ? 'field present in live envelope' : 'field ABSENT from live envelope',
-        { file: 'plugins/sp/scripts/task-size-precheck.ts', line: 130 },
-    );
     // Curated prose flag-claims: assertions phrased as prose ("no explicit `--flag`") that the
     // generic backtick-span extractor cannot scope to a command. Extend this list when a prose
     // claim is found; each entry is verified against the live help capture.

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env bun
+/**
+ * task-evidence-precheck — deterministic evidence-channel precheck (R2, task 0726).
+ *
+ * Parses the task content for an exact `evidence-channel:` declaration and proves the
+ * declared live-data channel exists in the local spur database before implementation
+ * begins. Currently exactly one channel is allowlisted:
+ *
+ *   evidence-channel: history_tool_call.args_raw[pi]
+ *
+ * …satisfied only when the fixed query
+ *
+ *   SELECT COUNT(*) FROM history_tool_call WHERE args_raw IS NOT NULL AND source = 'pi'
+ *
+ * returns a positive count on `<cwd>/.spur/spur.db` — i.e. a live non-dry-run pi import
+ * has already preserved tool-call `args_raw` (0722 R1). Unknown declarations, a missing
+ * database, a missing table, and a zero count all fail closed.
+ *
+ * A task without any `evidence-channel:` declaration passes without opening SQLite —
+ * the check only gates tasks that declare a live-data evidence channel.
+ *
+ * Always exits 0 (soft action). Both precheck→implement guards in task-pipeline.yaml
+ * read the status file; a missing or failing checker writes FAIL, so readiness fails
+ * closed.
+ *
+ * Ships with the plugin to arbitrary projects; node-builtin + bun:sqlite only —
+ * no workspace imports.
+ *
+ * Usage:
+ *   bun plugins/sp/scripts/task-evidence-precheck.ts <wbs> [--spur-bin <path>]
+ *
+ * Env: SPUR_BIN
+ */
+
+import { Database } from 'bun:sqlite';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** Exact task-content declaration that activates the live-evidence gate (0726 R2). */
+const DECLARATION_PREFIX = 'evidence-channel:';
+
+/** The only allowlisted live-data channel (0726 R2). */
+const EVIDENCE_CHANNEL = 'history_tool_call.args_raw[pi]';
+
+/** Declaration text as it must appear in the task body. */
+const DECLARATION = `${DECLARATION_PREFIX} ${EVIDENCE_CHANNEL}`;
+
+/** The only live-data query this precheck is allowed to run — fixed, never task-authored. */
+const EVIDENCE_QUERY = "SELECT COUNT(*) AS n FROM history_tool_call WHERE args_raw IS NOT NULL AND source = 'pi'";
+
+// ─── CLI (same spur-bin chain as task-size-precheck.ts) ─────────────────────
+
+function usage(): never {
+    console.error('Usage: bun plugins/sp/scripts/task-evidence-precheck.ts <wbs> [--spur-bin <path>]');
+    process.exit(1);
+}
+
+function defaultSpurBin(): string {
+    if (process.env.SPUR_BIN) return process.env.SPUR_BIN;
+    const local = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
+    if (existsSync(local)) return `bun ${local}`;
+    return 'spur';
+}
+
+function parseArgs(argv: string[]): { wbs: string; spurBin: string } {
+    let spurBin = defaultSpurBin();
+    let wbs = '';
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === '--spur-bin') {
+            spurBin = argv[i + 1] ?? defaultSpurBin();
+            i += 2;
+        } else if (!arg.startsWith('--')) {
+            wbs = arg;
+            i++;
+        } else {
+            i++;
+        }
+    }
+    if (!wbs) usage();
+    return { wbs, spurBin };
+}
+
+/**
+ * Split a multi-token `spurBin` (`<runtime> <mainModule>`) the same way
+ * `runSpurJson` does in feature-sync-bounded.ts — execFileSync's first arg is
+ * one executable path, not a shell command line.
+ */
+function runSpur(spurBin: string, args: string[]): string {
+    const [file = 'spur', ...lead] = spurBin.split(/\s+/).filter(Boolean);
+    return execFileSync(file, [...lead, ...args], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+}
+
+function writeStatus(wbs: string, status: 'PASS' | 'FAIL'): void {
+    const statusDir = join(process.cwd(), '.spur', 'run');
+    if (!existsSync(statusDir)) mkdirSync(statusDir, { recursive: true });
+    writeFileSync(join(statusDir, `${wbs}-precheck-evidence.status`), `${status}\n`);
+}
+
+function fail(wbs: string, reasons: string[]): void {
+    writeStatus(wbs, 'FAIL');
+    console.error(`task-evidence-precheck: FAIL`);
+    for (const r of reasons) {
+        console.error(`  ${r}`);
+    }
+    process.exit(0);
+}
+
+function main(): void {
+    const { wbs, spurBin } = parseArgs(process.argv.slice(2));
+
+    let taskContent: string;
+    try {
+        const result = runSpur(spurBin, ['task', 'show', wbs, '--json']);
+        const task = JSON.parse(result);
+        taskContent = task.content ?? task.body ?? '';
+    } catch {
+        fail(wbs, [`could not fetch task ${wbs} via ${spurBin} — evidence channel unverifiable`]);
+    }
+
+    // Collect every declaration token. A repeated exact declaration still gates the
+    // single fixed query; any non-allowlisted token is an unknown declaration.
+    const declarations: string[] = [];
+    for (const match of taskContent.matchAll(/evidence-channel:\s*(\S+)/g)) {
+        declarations.push(match[1] ?? '');
+    }
+    const unknown = declarations.filter((d) => d !== EVIDENCE_CHANNEL);
+    if (unknown.length > 0) {
+        fail(wbs, [
+            `unknown evidence-channel declaration(s): ${unknown.join(', ')}`,
+            `allowlisted declaration: ${DECLARATION}`,
+        ]);
+    }
+    if (declarations.length === 0) {
+        writeStatus(wbs, 'PASS');
+        console.error(`task-evidence-precheck: PASS — no evidence-channel declaration; live-data gate not active`);
+        process.exit(0);
+    }
+
+    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`]);
+    }
+
+    let count: number;
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        try {
+            const row = db.query(EVIDENCE_QUERY).get() as { n: number } | undefined;
+            count = row?.n ?? 0;
+        } finally {
+            db.close();
+        }
+    } catch (e) {
+        fail(wbs, [
+            `evidence query failed on ${dbPath}: ${e instanceof Error ? e.message : String(e)}`,
+            'history_tool_call table missing or unreadable — run a real history import first',
+        ]);
+    }
+
+    if (!(count > 0)) {
+        fail(wbs, [
+            `0 live pi rows with args_raw (query: ${EVIDENCE_QUERY})`,
+            'run a non-dry-run pi history import with a safe importer before implementing',
+        ]);
+    }
+
+    writeStatus(wbs, 'PASS');
+    console.error(
+        `task-evidence-precheck: PASS — ${count} live pi history_tool_call row(s) with args_raw (declaration: ${DECLARATION})`,
+    );
+    process.exit(0);
+}
+
+main();

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

@@ -1,24 +1,23 @@
 #!/usr/bin/env bun
 /**
- * task-size-precheck — pipeline size precheck guard (R2, task 0454) plus the
- * size-vs-executor-capability gate (R3, task 0487).
+ * task-size-precheck — pipeline size precheck guard (R2, task 0454; count-only
+ * since task 0723).
  *
  * Shells `spur task show <wbs> --json`, evaluates R-item count and Plan
- * checklist count against limits, writes PASS/FAIL to status file. With
- * `--executor`, also shells `spur agent doctor <exec> --json` and blocks a large
- * task routed to a sub-`capable-1` executor.
+ * checklist count against limits, writes PASS/FAIL to status file. No executor
+ * or doctor involvement: executor liveness/routing/capabilities are attested
+ * fail-closed at the `agent.run` dispatch boundary, not predicted here.
  *
- * Always exits 0 (soft check, like doctor). The precheck→implement guard in
- * task-pipeline.yaml reads the status file.
+ * Always exits 0 (soft action). The precheck→implement guard in
+ * task-pipeline.yaml reads the status file; a missing or failing checker writes
+ * FAIL, so readiness fails closed.
  *
  * Ships with the plugin to arbitrary projects, so it stays node-builtin-only —
- * no workspace imports. The capability tier therefore comes from the CLI rather
- * than from `getExecutorTier` directly; `spur agent doctor --json` exposes it as
- * `capabilityTier` precisely so the inference regex is not duplicated here.
+ * no workspace imports.
  *
  * Usage:
  *   bun plugins/sp/scripts/task-size-precheck.ts <wbs> [--spur-bin <path>]
- *     [--max-reqs <n>] [--max-plan-items <n>] [--executor <name>]
+ *     [--max-reqs <n>] [--max-plan-items <n>]
  *
  * Env: SPUR_BIN, MAX_IMPLEMENT_REQS, MAX_IMPLEMENT_PLAN_ITEMS
  */
@@ -27,7 +26,6 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { STAGE_FLOOR_TIER, TIER_ORDER } from './stage-registry-adapter';
 
 // ─── Regex (sync with packages/app/src/services/task-size-precheck.ts) ───────
 
@@ -37,32 +35,11 @@ const R_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(\*\*)?R\d+\./m;
 /** Matches checklist items under the Plan section. */
 const CHECKLIST_ITEM_RE = /^\s*-\s*\[[ xX]\]/m;
 
-/**
- * Large-task thresholds for the capability gate (R3, task 0487) — the DEFAULT
- * caps, not the overridable `--max-*` limits. Raising the caps says "I accept a
- * big task"; it does not make a flash-tier model able to finish one inside
- * `implementTimeoutMs`.
- */
-const LARGE_TASK_REQS = 5;
-const LARGE_TASK_PLAN_ITEMS = 8;
-
-/**
- * Capability tiers strong enough for a large task (R3, task 0487). The floor is
- * the `review` stage's Layer-1 tier — `reviewer` per `references/roles.md`,
- * read via the stage-registry adapter (0538 R4: no tier literal here; roles.md
- * is the pointer). Tiers at or above the floor pass. An unreachable roles.md
- * degrades to the pre-reconcile band — fail-closed for a safety gate.
- */
-const CAPABLE_TIERS: ReadonlySet<string> = (() => {
-    const floor = STAGE_FLOOR_TIER.get('review') ?? 'capable-1';
-    return new Set(TIER_ORDER.slice(Math.max(0, TIER_ORDER.indexOf(floor))));
-})();
-
 // ─── CLI ─────────────────────────────────────────────────────────────────────
 
 function usage(): never {
     console.error(
-        'Usage: bun plugins/sp/scripts/task-size-precheck.ts <wbs> [--spur-bin <path>] [--max-reqs <n>] [--max-plan-items <n>] [--executor <name>]',
+        'Usage: bun plugins/sp/scripts/task-size-precheck.ts <wbs> [--spur-bin <path>] [--max-reqs <n>] [--max-plan-items <n>]',
     );
     process.exit(1);
 }
@@ -87,13 +64,14 @@ function parseArgs(argv: string[]): {
     spurBin: string;
     maxReqs: number;
     maxPlanItems: number;
-    executor: string;
 } {
     let spurBin = defaultSpurBin();
     let wbs = '';
-    let maxReqs = Number(process.env.MAX_IMPLEMENT_REQS) || 5;
-    let maxPlanItems = Number(process.env.MAX_IMPLEMENT_PLAN_ITEMS) || 8;
-    let executor = '';
+    // Doubled deterministic ceiling (0723 operator decision): 10 R-items / 16
+    // Plan items — keep in sync with DEFAULT_TASK_SIZE_LIMITS in
+    // packages/app/src/services/task-size-precheck.ts (asserted by test).
+    let maxReqs = Number(process.env.MAX_IMPLEMENT_REQS) || 10;
+    let maxPlanItems = Number(process.env.MAX_IMPLEMENT_PLAN_ITEMS) || 16;
 
     let i = 0;
     while (i < argv.length) {
@@ -102,13 +80,10 @@ function parseArgs(argv: string[]): {
             spurBin = argv[i + 1] ?? defaultSpurBin();
             i += 2;
         } else if (arg === '--max-reqs') {
-            maxReqs = Number(argv[i + 1]) || 5;
+            maxReqs = Number(argv[i + 1]) || 10;
             i += 2;
         } else if (arg === '--max-plan-items') {
-            maxPlanItems = Number(argv[i + 1]) || 8;
-            i += 2;
-        } else if (arg === '--executor') {
-            executor = argv[i + 1] ?? '';
+            maxPlanItems = Number(argv[i + 1]) || 16;
             i += 2;
         } else if (!arg.startsWith('--')) {
             wbs = arg;
@@ -119,7 +94,7 @@ function parseArgs(argv: string[]): {
     }
 
     if (!wbs) usage();
-    return { wbs, spurBin, maxReqs, maxPlanItems, executor };
+    return { wbs, spurBin, maxReqs, maxPlanItems };
 }
 
 /**
@@ -135,29 +110,8 @@ function runSpur(spurBin: string, args: string[]): string {
     });
 }
 
-/**
- * Capability tier of `executor` per `spur agent doctor <exec> --json`.
- * Unknown executor, unreadable doctor output, or an undeclared-and-uninferrable
- * tier all read as `standard` — conservative: a false block is one flag away,
- * a false pass costs a 30-minute timed-out implement.
- */
-function resolveCapabilityTier(spurBin: string, executor: string): { tier: string; resolvedName: string } {
-    try {
-        const out = runSpur(spurBin, ['agent', 'doctor', executor, '--json']);
-        const row = JSON.parse(out)?.agents?.[0];
-        const tier = row?.capabilityTier;
-        // R1 (0622 F2/F4 residue): `doctor <role>` resolves the role to its cheapest
-        // eligible executor (`coder` → `omp`); surface the resolved executor name in
-        // the block message, not the role the caller passed in.
-        const resolvedName = typeof row?.agent === 'string' && row.agent.length > 0 ? row.agent : executor;
-        return { tier: typeof tier === 'string' && tier ? tier : 'standard', resolvedName };
-    } catch {
-        return { tier: 'standard', resolvedName: executor };
-    }
-}
-
 function main(): void {
-    const { wbs, spurBin, maxReqs, maxPlanItems, executor } = parseArgs(process.argv.slice(2));
+    const { wbs, spurBin, maxReqs, maxPlanItems } = parseArgs(process.argv.slice(2));
 
     // Fetch task content via spur
     let taskContent: string;
@@ -166,7 +120,7 @@ function main(): void {
         const task = JSON.parse(result);
         taskContent = task.content ?? task.body ?? '';
     } catch {
-        // If spur fails, write FAIL and exit 0 (soft, like doctor)
+        // If spur fails, write FAIL and exit 0 — the status file carries the verdict
         const statusDir = join(process.cwd(), '.spur', 'run');
         if (!existsSync(statusDir)) mkdirSync(statusDir, { recursive: true });
         writeFileSync(join(statusDir, `${wbs}-precheck-size.status`), 'FAIL\n');
@@ -187,18 +141,6 @@ function main(): void {
     const planItemCount = planBody.match(new RegExp(CHECKLIST_ITEM_RE.source, 'gm'))?.length ?? 0;
 
     const reasons: string[] = [];
-    // R3 (0487): a large task on a sub-capable executor blocks even when the caller
-    // raised the caps — the caps are an acceptance of size, not a capability grant.
-    if (executor && (reqCount > LARGE_TASK_REQS || planItemCount > LARGE_TASK_PLAN_ITEMS)) {
-        const { tier, resolvedName } = resolveCapabilityTier(spurBin, executor);
-        if (!CAPABLE_TIERS.has(tier)) {
-            reasons.push(
-                `Task size (${reqCount} R-items / ${planItemCount} Plan items) requires a capable executor, ` +
-                    `but ${resolvedName} is tier ${tier}. ` +
-                    `Pass \`--agent <capable>\` or \`--vars '{"implementAgent":"<capable>"}'\`, or split the task.`,
-            );
-        }
-    }
     if (reqCount > maxReqs) {
         reasons.push(
             `Task has ${reqCount} R-items (max ${maxReqs}). ` +