@gobing-ai/spur 0.3.67 → 0.3.69

package/plugins/sp/README.md

@@ -567,8 +567,9 @@ graph TB
 1. User types `/sp:dev-plan "add task body write API"`.
 2. **Command** (`dev-plan.md`) parses `$ARGUMENTS` and calls
    `Skill(skill="sp:spur-dev", args="plan $ARGUMENTS")`.
-3. **Skill** (`spur-dev/SKILL.md`) drives the planning half: intake → `spur feature create` → AC
-   generation → `spur feature check` gate → decomposition → `spur task batch-create`.
+3. **Skill** (`spur-dev/SKILL.md`) reads `idea-pipeline.yaml` and drives its states in the current
+   session by default: intake → `spur feature create` → AC generation → `spur feature check` gate →
+   decomposition → `spur task batch-create`. Explicit `--agent auto|<name>` uses the async worker.
 4. **CLI** validates each step before writing — feature IDs are race-safe, WBS allocation is atomic,
    `check` is the readiness matrix.
 5. Result: validated feature file + decomposed task batch in `docs/features/` and `docs/tasks/`.
@@ -577,10 +578,9 @@ graph TB
 
 1. User types `/sp:dev-run 0090`.
 2. **Command** delegates to `sp:spur-dev` skill (execution half).
-3. **Skill** reads the task, loads `task-pipeline.yaml`, and runs
-   `spur workflow run` with HITL surfacing.
-4. **CLI** executes the workflow engine (`@gobing-ai/ts-dual-workflow-engine`), pauses at HITL gates,
-   persists run state.
+3. **Skill** reads the task and `task-pipeline.yaml`, then drives its actions and guards in-session.
+4. **CLI** supplies deterministic actions and lifecycle gates; explicit executors use the async
+   workflow worker and persisted run state.
 5. Result: task driven through implement → check → fix → verify lifecycle.
 
 **Task-corpus write protection.**
@@ -606,7 +606,6 @@ pipeline owns one lifecycle phase:
 | `task-pipeline.yaml`        | Single-task execution             | `/sp:dev-run`                     |
 | `idea-pipeline.yaml`        | Idea/planning → feature + tasks   | `/sp:dev-idea`, `/sp:dev-plan`    |
 | `feature-dev.yaml`          | Feature umbrella execution        | `/sp:dev-runall --feature`        |
-| `idea-pipeline.yaml`        | Idea to feature + AC + task batch | `/sp:dev-idea`                    |
 | `wrapup-pipeline.yaml`      | Post-execution wrap-up            | `/sp:dev-wrap`, `/sp:dev-wrapall` |
 | `docs-pipeline.yaml`        | Docs-only task execution          | `/sp:dev-run --mode implement`    |
 | `wayfinder-resolution.yaml` | Wayfinder ticket resolution loop  | `spur workflow run` (free-form)   |

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

@@ -1,7 +1,7 @@
 ---
 description: Turn a vague idea into a feature with AC and a decomposed task batch — discovery, idea-eval, feature-create, AC, feature-check, system-design, decompose, batch-create (Design by default), handoff
 role: planner
-argument-hint: "\"<idea>\" [--auto] [--skip-design] [--approve-taste] [--agent <auto|name>]"
+argument-hint: "\"<idea>\" [--auto] [--skip-design] [--approve-taste] [--agent <inline|auto|name>]"
 allowed-tools: ["Bash", "Read", "Skill", "AskUserQuestion"]
 ---
 
@@ -20,7 +20,7 @@ contract below maps to that workflow's transitions.
 | `--approve-taste` | With `--auto`: set idea_approved + design_approved so idea-eval / design-approval do not pause. | off |
 | `--idea-approved` | Compatibility alias for idea_approved=true (subset of --approve-taste). | off |
 | `--design-approved` | Compatibility alias for design_approved=true (subset of --approve-taste). | off |
-| `--agent` `<auto\|name>` | Who runs the model-bearing ideation. The pipeline's `agent.run` stages are headless — they always dispatch a subprocess. Omission and explicit `--agent inline` resolve identically per task 0687: tier substitution plus one warning naming the substituted executor; `auto` (tier-resolves an executor); a name (pins that executor). | inline |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing ideation. Omission and `inline` drive `idea-pipeline.yaml` in this session with zero external agent/workflow processes; `auto` tier-resolves an executor and a name pins one, both through the async workflow worker. | inline |
 
 For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag-glossary.md).
 
@@ -31,7 +31,7 @@ For shared semantics, see the [flag glossary](../skills/spur-dev/references/flag
   [--auto]              # skip objective HITL only (feature-check, batch-create)
   [--skip-design]       # design package off (system-design + task Design)
   [--approve-taste]     # with --auto: skip idea-eval + design-approval pauses
-  [--agent <auto|name>]          # who runs the model-bearing ideation (default: agent.default)
+  [--agent <inline|auto|name>]   # inline is the current session; auto/name are async workers
 ```
 
 There is **no** `--design` force flag. Design is default-on; only `--skip-design` opts out.
@@ -42,6 +42,8 @@ vars as subsets of `--approve-taste` (`idea_approved` / `design_approved`). Pref
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Omitted/`inline`: drive `idea-pipeline.yaml` through the [inline pipeline driver](../skills/spur-dev/references/inline-pipeline-driver.md). Do not launch `spur workflow run`, `spur agent run`, or a native subagent unless the operator explicitly requests delegation.
+- `auto`/name: launch `spur workflow run idea-pipeline.yaml --async`, observe with one `workflow trace --follow`, and only report cancellation as stopped when `workflow cancel --json` returns `killed: true`.
 - `Skill(skill="sp:spur-dev", args="idea $ARGUMENTS")`
 - Stage contract (discovery → idea-eval → feature-create → AC → feature-check → system-design →
   decompose → batch-create → handoff): `plugins/sp/skills/spur-dev/references/dev-operations.md` § idea.

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

@@ -16,7 +16,7 @@ Wraps the **sp:spur-dev** skill.
 | `"<description>"` | Feature description to plan. | required |
 | `--feature` `<id>` | Attach to an existing feature. | omitted |
 | `--parent` `<feature-id>` | Create under a parent feature. | omitted |
-| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing planning. The planning pipeline's `agent.run` stages are headless — they always dispatch a subprocess. `inline` — also what omission resolves to since task 0687 — substitutes tier resolution there with one warning naming the resolved executor; `auto` (tier-resolves an executor); a name (pins that executor). | inline |
+| `--agent` `<inline\|auto\|name>` | Who runs the model-bearing planning. Omission and `inline` drive `idea-pipeline.yaml` in this session with zero external agent/workflow processes; `auto` tier-resolves an executor and a name pins one, both through the async workflow worker. | inline |
 | `--skip-design` | Omit the system-design hop. | off |
 | `--auto` | Skip objective HITL gates. | off |
 | `--approve-taste` | With --auto: skip design-approval pause. | off |
@@ -43,5 +43,7 @@ for taste gates). Alias: `--design-approved` (prefer `--approve-taste`).
 ## Implementation
 
 - Apply the [inline-default execution-surface contract](../skills/spur-dev/references/cross-cutting.md#inline-default-execution-surface).
+- Omitted/`inline`: drive `idea-pipeline.yaml` through the [inline pipeline driver](../skills/spur-dev/references/inline-pipeline-driver.md). Do not launch `spur workflow run`, `spur agent run`, or a native subagent unless the operator explicitly requests delegation.
+- `auto`/name: launch `spur workflow run idea-pipeline.yaml --async`, observe with one `workflow trace --follow`, and only report cancellation as stopped when `workflow cancel --json` returns `killed: true`.
 - `Skill(skill="sp:spur-dev", args="plan $ARGUMENTS")`
 - Full Design package + batch `design` field contract: `plugins/sp/skills/spur-dev/references/dev-operations.md` § plan and `planning-workflow.md` Step 5.5.

package/plugins/sp/commands/dev-review-session.md

@@ -12,7 +12,8 @@ default it is report-only: current conversation plus read-only repository eviden
 the session context is preserved — no workflow launch, history import, task creation, or
 remediation. With `--triage`, it first triages the findings, then applies direct fixes (pure
 documentation work and one-to-two-line fixes) inline and files everything remaining as exactly one
-new task for further fixing.
+new task for further fixing. The result includes a non-overlapping time breakdown with durations in
+`M:SS` or `H:MM:SS` form and `n/a` for unavailable measurements.
 
 ## Argument Flags
 

package/plugins/sp/hooks/context-post-tool.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+
 /**
  * context-post-tool — PostToolUse hook for indexed-context
  * (matcher: Bash|Grep|Glob|Read|Write|Edit — task 0248).
@@ -19,8 +20,9 @@
  * `superskill hook run sp context-post-tool`.
  */
 
-import { appendFileSync, existsSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { appendFileSync, existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
 
 /** Tools recorded by this hook (must match hooks.json PostToolUse matcher). */
 export const ALLOWED_TOOLS = new Set(['Bash', 'Grep', 'Glob', 'Read', 'Write', 'Edit']);
@@ -282,6 +284,15 @@ export function recordToolUseEvent(
     const session = sessionMeta.session ?? '';
     if (!session) return null;
 
+    // Freshness stamp (task 0711 R4): the indexed-context producer is the agent
+    // following the skill's update guidance; the observable producer moment in
+    // code is a Write/Edit landing on a `.spur/context/*.md` file. Each such
+    // write refreshes `.freshness.json` so staleness checks can compare the
+    // sidecar's source commit against HEAD until the next regeneration.
+    if ((toolName === 'Write' || toolName === 'Edit') && isContextIndexFile(contextDir, filePath)) {
+        stampContextFreshness(contextDir, currentHeadCommit(), now());
+    }
+
     const tokens = resolveTokenEstimate(toolName, payload.tool_input, payload.tool_response);
     const ts = now().toISOString();
     const type = mapToolType(toolName);
@@ -309,6 +320,94 @@ export function recordToolUseEvent(
     return event;
 }
 
+// ─── Context freshness sidecar (task 0711 R4) ───────────────────────────
+
+export interface ContextFreshness {
+    schema_version: number;
+    source_commit: string;
+    generated_at: string;
+}
+
+export const CONTEXT_FRESHNESS_SCHEMA_VERSION = 1;
+
+/** True when `filePath` is a regenerated context index inside `contextDir` (not the sidecars). */
+export function isContextIndexFile(contextDir: string, filePath: string): boolean {
+    const resolvedDir = resolve(contextDir);
+    const resolvedFile = resolve(filePath);
+    if (!resolvedFile.startsWith(resolvedDir + sep)) return false;
+    const name = resolvedFile.slice(resolvedDir.length + 1);
+    return name.endsWith('.md');
+}
+
+/** Current HEAD, best-effort — null when git is unavailable or the dir is not a work tree. */
+export function currentHeadCommit(): string | null {
+    try {
+        const out = execSync('git rev-parse HEAD', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const commit = out.trim();
+        return commit.length > 0 ? commit : null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Write/refresh `.spur/context/.freshness.json`. Best-effort: any I/O failure
+ * leaves the previous sidecar (or none) in place — the hook contract is
+ * fail-open, never blocking.
+ */
+export function stampContextFreshness(contextDir: string, sourceCommit: string | null, at: Date): void {
+    if (!sourceCommit) return;
+    const body: ContextFreshness = {
+        schema_version: CONTEXT_FRESHNESS_SCHEMA_VERSION,
+        source_commit: sourceCommit,
+        generated_at: at.toISOString(),
+    };
+    try {
+        writeFileSync(join(contextDir, '.freshness.json'), JSON.stringify(body));
+    } catch {
+        /* fail-open */
+    }
+}
+
+export interface ContextFreshnessCheck {
+    stale: boolean;
+    reason?: string;
+}
+
+/**
+ * Compare a freshness sidecar against the current HEAD (task 0711 R4). A
+ * missing/unparsable sidecar is stale (`never stamped`); a commit mismatch is
+ * stale until the producer regenerates the index.
+ */
+export function checkContextFreshness(raw: string | null, headCommit: string | null): ContextFreshnessCheck {
+    if (raw === null) return { stale: true, reason: 'never stamped' };
+    let body: ContextFreshness;
+    try {
+        body = JSON.parse(raw) as ContextFreshness;
+    } catch {
+        return { stale: true, reason: 'malformed sidecar' };
+    }
+    if (body.schema_version !== CONTEXT_FRESHNESS_SCHEMA_VERSION) {
+        return { stale: true, reason: `schema_version ${String(body.schema_version)}` };
+    }
+    if (typeof body.source_commit !== 'string' || body.source_commit === '') {
+        return { stale: true, reason: 'missing source_commit' };
+    }
+    if (headCommit !== null && body.source_commit !== headCommit) {
+        return { stale: true, reason: 'source commit changed since generation' };
+    }
+    return { stale: false };
+}
+
+/** Read the freshness sidecar, or null when absent/unreadable. */
+export function readContextFreshness(contextDir: string): string | null {
+    try {
+        return readFileSync(join(contextDir, '.freshness.json'), 'utf-8');
+    } catch {
+        return null;
+    }
+}
+
 // Entrypoint — thin wrapper; logic lives in {@link recordToolUseEvent} for unit coverage.
 if (import.meta.main) {
     void (async () => {

package/plugins/sp/hooks/context-session-start.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+
 /**
  * context-session-start — SessionStart hook for indexed-context.
  *
@@ -11,10 +12,11 @@
  * Self-contained by design (task 0232/0246).
  */
 
+import { execSync } from 'node:child_process';
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-
 import { resolveAgentHint, resolveModelHint } from './agent-hint';
+import { checkContextFreshness } from './context-post-tool';
 
 export { resolveAgentHint, resolveModelHint } from './agent-hint';
 
@@ -161,6 +163,25 @@ export function recordSessionStart(
     if (agent) startEvent.agent = agent;
     if (model) startEvent.model = model;
 
+    // Freshness check (task 0711 R4): report whether the context indexes were
+    // regenerated at the current HEAD. Best-effort, fail-open — git failures
+    // yield head=null, which marks stale only via the sidecar's own defects.
+    let headCommit: string | null = null;
+    try {
+        const out = execSync('git rev-parse HEAD', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const trimmed = out.trim();
+        headCommit = trimmed.length > 0 ? trimmed : null;
+    } catch {
+        headCommit = null;
+    }
+    let freshnessRaw: string | null = null;
+    try {
+        freshnessRaw = readFileSync(join(dir, '.freshness.json'), 'utf-8');
+    } catch {
+        freshnessRaw = null;
+    }
+    startEvent.contextFreshness = checkContextFreshness(freshnessRaw, headCommit);
+
     const ledgerPath = join(dir, 'token-ledger.jsonl');
     try {
         appendFileSync(ledgerPath, `${JSON.stringify(startEvent)}\n`);

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.67",
+    "version": "0.3.69",
     "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/stage-registry-adapter.ts

@@ -24,7 +24,8 @@
  *   bun plugins/sp/scripts/stage-registry-adapter.ts --help
  */
 
-import { readFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 // ─── Inline type definitions (mirrors packages/domain/src/stage-registry/) ─
@@ -203,6 +204,107 @@ export interface TaskSignal {
     feature_id?: string | null;
     hasCheckpoint?: boolean;
 }
+
+/**
+ * Result of routing-checkpoint inspection (task 0711 R3).
+ *
+ * `usable` feeds `TaskSignal.hasCheckpoint`: only a checkpoint that parses as
+ * the canonical frontmatter contract, matches the task (owner identity), is
+ * non-terminal, and is not commit-drifted may route A4 (wip + checkpoint →
+ * continue). Anything else is reported with its reason and IGNORED — routing
+ * falls through to the non-checkpoint row (A5); it is never silently trusted.
+ *
+ * Lean inline mirror of `packages/app/src/workflow/checkpoint-contract.ts`
+ * (the plugin installs into foreign repos and cannot import workspace
+ * packages — same discipline as the domain-type mirrors above); the parity
+ * test pins the two together.
+ */
+export interface RoutingCheckpointInspection {
+    usable: boolean;
+    reason?: string;
+}
+
+export interface RoutingCheckpointOptions {
+    /** Current repository HEAD; when provided, a mismatched/absent `source_commit` is drift. */
+    headCommit?: string;
+    /** Existence probe for referenced artifacts; default `existsSync`. */
+    artifactExists?: (path: string) => boolean;
+}
+
+/**
+ * Inspect `.spur/memory/sessions/<wbs>-checkpoint.md` for resume routing
+ * (task 0711 R3). A missing file yields `{ usable: false, reason: 'absent' }`
+ * — the normal case, indistinguishable for routing from a rejected one.
+ */
+export function inspectRoutingCheckpoint(
+    sessionsDir: string,
+    wbs: string,
+    opts: RoutingCheckpointOptions = {},
+): RoutingCheckpointInspection {
+    let raw: string;
+    try {
+        raw = readFileSync(join(sessionsDir, `${wbs}-checkpoint.md`), 'utf-8');
+    } catch {
+        return { usable: false, reason: 'absent' };
+    }
+    if (!raw.startsWith('---')) return { usable: false, reason: 'malformed: missing frontmatter' };
+    const end = raw.indexOf('\n---', 3);
+    if (end < 0) return { usable: false, reason: 'malformed: unterminated frontmatter' };
+
+    const scalars = new Map<string, string>();
+    const artifacts: string[] = [];
+    let inArtifacts = false;
+    for (const rawLine of raw.slice(4, end).split('\n')) {
+        const line = rawLine.trim();
+        if (line.startsWith('- ')) {
+            if (inArtifacts) artifacts.push(line.slice(2).trim().replace(/^"|"$/g, ''));
+            continue;
+        }
+        inArtifacts = false;
+        const sep = line.indexOf(':');
+        if (sep <= 0) continue;
+        const key = line.slice(0, sep).trim();
+        const value = line
+            .slice(sep + 1)
+            .trim()
+            .replace(/^"|"$/g, '');
+        if (key === 'artifacts') {
+            inArtifacts = true;
+            if (value !== '') {
+                artifacts.push(
+                    ...value
+                        .split(',')
+                        .map((p) => p.trim().replace(/^"|"$/g, ''))
+                        .filter((p) => p !== ''),
+                );
+            }
+            continue;
+        }
+        scalars.set(key, value);
+    }
+
+    if (scalars.get('schema_version') !== '1') return { usable: false, reason: 'malformed: schema_version' };
+    if (scalars.get('task_wbs') !== wbs) {
+        return { usable: false, reason: `owner-mismatch: task_wbs=${scalars.get('task_wbs')} != ${wbs}` };
+    }
+    const status = scalars.get('status') ?? '';
+    if (['done', 'failed', 'cancelled', 'skipped'].includes(status)) {
+        return { usable: false, reason: `terminal: status=${status}` };
+    }
+    const head = opts.headCommit;
+    if (head !== undefined) {
+        const commit = scalars.get('source_commit') ?? '';
+        if (commit === '' || commit !== head) {
+            return { usable: false, reason: `commit-drift: checkpoint@${commit.slice(0, 12) || 'none'} != HEAD` };
+        }
+    }
+    const probe = opts.artifactExists ?? existsSync;
+    for (const artifact of artifacts) {
+        const p = artifact.trim().replace(/^"|"$/g, '');
+        if (p !== '' && !probe(p)) return { usable: false, reason: `missing-artifact: ${p}` };
+    }
+    return { usable: true };
+}
 export interface FeatureSignal {
     id: string;
     status: FeatureStatus;
@@ -894,6 +996,8 @@ const TABLE_C: TableCRow[] = [
     },
     {
         // C4 — rule findings: requires spur rule run
+        // SAFETY: sentinel, not a string — this row never dispatches; null is the
+        // intentional HITL-stop placeholder that formatStageResult renders as no-command.
         redirectDispatch: null as unknown as string, // HITL stop
         rowId: 'C4',
         probeRows: ['A3', 'A5', 'A6'],
@@ -1315,6 +1419,17 @@ export function formatStageResult(result: StageResolution): string[] {
     return lines;
 }
 
+/** Current repository HEAD, best-effort — null outside a work tree or without git. */
+function currentHeadCommit(): string | null {
+    try {
+        const out = execSync('git rev-parse HEAD', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const commit = out.trim();
+        return commit.length > 0 ? commit : null;
+    } catch {
+        return null;
+    }
+}
+
 export function runCli(argv: string[], opts?: { resolve?: (input: ResolutionInput) => StageResolution }): CliResult {
     const parsed = parseCliArgs(argv);
     const resolve = opts?.resolve ?? resolveStage;
@@ -1337,6 +1452,30 @@ export function runCli(argv: string[], opts?: { resolve?: (input: ResolutionInpu
         };
     }
 
+    // Routing checkpoint (0711 R3): a canonical checkpoint at
+    // .spur/memory/sessions/<wbs>-checkpoint.md that survives inspection (owner,
+    // non-terminal, at HEAD, artifacts present) enables the A4 resume row for wip
+    // tasks; anything else is REPORTED and ignored — routing falls through to the
+    // non-checkpoint row. Best-effort and fail-open: git/fs failures leave the
+    // checkpoint unconsidered.
+    let checkpointNote: string | undefined;
+    let hasCheckpoint: boolean | undefined;
+    if (parsed.wbs) {
+        try {
+            const inspection = inspectRoutingCheckpoint(
+                join(process.cwd(), '.spur', 'memory', 'sessions'),
+                parsed.wbs,
+                { headCommit: currentHeadCommit() ?? undefined },
+            );
+            hasCheckpoint = inspection.usable;
+            if (!inspection.usable && inspection.reason !== 'absent') {
+                checkpointNote = `note: routing checkpoint ignored — ${inspection.reason}`;
+            }
+        } catch {
+            hasCheckpoint = undefined;
+        }
+    }
+
     // Build resolution input from CLI args (note: no live corpus access in CLI mode)
     const input: ResolutionInput = {
         target: parsed.wbs ?? parsed.feature ?? '',
@@ -1345,13 +1484,16 @@ export function runCli(argv: string[], opts?: { resolve?: (input: ResolutionInpu
         once: parsed.once,
         auto: parsed.auto,
         fullMode: parsed.full,
-        task: parsed.wbs ? { wbs: parsed.wbs, status: parsed.taskStatus ?? 'unknown', dependencies: [] } : undefined,
+        task: parsed.wbs
+            ? { wbs: parsed.wbs, status: parsed.taskStatus ?? 'unknown', dependencies: [], hasCheckpoint }
+            : undefined,
         feature: parsed.feature ? { id: parsed.feature, status: 'active', tasks: [] } : undefined,
     };
 
     try {
         const result = resolve(input);
         const lines = formatStageResult(result);
+        if (checkpointNote) lines.push(checkpointNote);
         return { exitCode: result.reasonKind === 'dispatch' ? 0 : 2, stdout: `${lines.join('\n')}\n`, stderr: '' };
     } catch (e) {
         return { exitCode: 1, stdout: '', stderr: `error: ${(e as Error).message}` };

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.