@gobing-ai/spur 0.3.81 → 0.3.82

package/plugins/sp/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "sp",
-    "version": "0.3.81",
+    "version": "0.3.82",
     "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/inline-run-setup.ts

@@ -29,6 +29,10 @@
  *
  * Usage:
  *   bun plugins/sp/scripts/inline-run-setup.ts --run-id <id> --file <definition> [--spur-bin <path>]
+ *   bun plugins/sp/scripts/inline-run-setup.ts --fingerprint --task-file <path> [--feature-file <path>] [--spur-bin <path>]
+ *
+ * The `--fingerprint` mode prints the engine's proof-input digest for the given spec files and
+ * creates nothing (task 0862 R5).
  *
  * Env: SPUR_BIN
  */
@@ -56,7 +60,10 @@ function usage(): never {
     console.error(
         'Usage: bun plugins/sp/scripts/inline-run-setup.ts --run-id <id> --file <definition> [--spur-bin <path>]',
     );
-    process.exit(1);
+    console.error(
+        '       bun plugins/sp/scripts/inline-run-setup.ts --fingerprint --task-file <path> [--feature-file <path>] [--spur-bin <path>]',
+    );
+    process.exit(2);
 }
 
 /**
@@ -122,16 +129,77 @@ function writeOutcome(runId: string, outcome: SetupOutcome): void {
     writeFileSync(join(runDir, `${runId}-inline-setup.json`), `${JSON.stringify(outcome, null, 4)}\n`);
 }
 
+/**
+ * `--fingerprint` mode (task 0862 R5): print the engine's proof-input digest for a task file
+ * (plus optional feature file) instead of creating a run, so the inline driver can capture the
+ * fresh digest bound `run.artifact` registration checks against.
+ *
+ * The digest itself comes from the exported app functions — never reimplemented here — and the
+ * options mirror `ProofFingerprintActionRunner` (cwd, spec contents, fileSystem; no `--expect`).
+ * Returns the process exit code: 0 printed, 1 read/resolve failure.
+ */
+async function printFingerprint(taskFile: string, featureFile: string, spurBin: string): Promise<number> {
+    const { entry, repoRoot, chain } = resolveAppEntry(spurBin);
+    if (entry === null || repoRoot === null) {
+        console.error(
+            `inline-run-setup: FAIL — no monorepo checkout of spur is reachable via ${chain}. ` +
+                'The proof-input digest must be computed by the app service; a bundle-only install cannot do it.',
+        );
+        return 1;
+    }
+    const app = (await import(entry)) as {
+        computeProofInputFingerprint: (options: Record<string, unknown>) => Promise<string>;
+        readProofInputContents: (
+            fileSystem: unknown,
+            workdir: string,
+            options: { taskFile?: unknown; featureFile?: unknown },
+        ) => Promise<{ ok: true; taskContent?: string; featureContent?: string } | { ok: false; error: string }>;
+    };
+
+    const workdir = process.cwd();
+    // `undefined` fs takes readProofInputContents' node-filesystem default — the same default its
+    // sibling createGitAlternateTree applies, and the same Node FS the CLI's runner injects.
+    const inputs = await app.readProofInputContents(undefined, workdir, {
+        taskFile,
+        ...(featureFile.trim() !== '' ? { featureFile } : {}),
+    });
+    if (!inputs.ok) {
+        console.error(`inline-run-setup: FAIL — ${inputs.error}`);
+        return 1;
+    }
+
+    const digest = await app.computeProofInputFingerprint({
+        cwd: workdir,
+        ...(inputs.taskContent !== undefined ? { taskContent: inputs.taskContent } : {}),
+        ...(inputs.featureContent !== undefined ? { featureContent: inputs.featureContent } : {}),
+    });
+    process.stdout.write(`${digest}\n`);
+    return 0;
+}
+
 async function main(): Promise<void> {
     let runId = '';
     let file = '';
+    let fingerprint = false;
+    let taskFile = '';
+    let featureFile = '';
     let spurBin = process.env.SPUR_BIN ?? '';
     const argv = process.argv.slice(2);
     for (let i = 0; i < argv.length; i++) {
         if (argv[i] === '--run-id') runId = argv[++i] ?? '';
         else if (argv[i] === '--file') file = argv[++i] ?? '';
+        else if (argv[i] === '--fingerprint') fingerprint = true;
+        else if (argv[i] === '--task-file') taskFile = argv[++i] ?? '';
+        else if (argv[i] === '--feature-file') featureFile = argv[++i] ?? '';
         else if (argv[i] === '--spur-bin') spurBin = argv[++i] ?? spurBin;
     }
+
+    // Two mutually exclusive modes share this entry point: create/attach a run (run-id + file), or
+    // print the proof digest for the inline driver (task 0862 R5). Mixing them is a usage error.
+    if (fingerprint) {
+        if (runId !== '' || file !== '' || taskFile.trim() === '') usage();
+        process.exit(await printFingerprint(taskFile, featureFile, spurBin));
+    }
     if (runId.trim() === '' || file.trim() === '') usage();
     if (!SAFE_RUN_ID_RE.test(runId)) refuseUnsafeRunId(runId);
 

package/plugins/sp/scripts/quality-gate.mjs

@@ -23,6 +23,7 @@ var RETRY_DELAY_MS_DEFAULT = 1e4;
 var RETRY_DELAY_MS_ENV = "SPUR_QUALITY_GATE_RETRY_DELAY_MS";
 var LOCKED_PATTERN = /SQLiteError: database is locked|SQLite database .*is busy|SQLITE_BUSY/;
 var FINDINGS_PATTERN = /[A-Za-z0-9_./-]+\.[A-Za-z]+:[0-9]+/g;
+var COVERAGE_ROW_PATTERN = /^\s*(\S+\.[A-Za-z]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*(\S*)/;
 function isTransientLock(attemptOutput) {
   return LOCKED_PATTERN.test(attemptOutput);
 }
@@ -46,6 +47,38 @@ function retryMessage(attempt) {
   return `quality gate: database is locked; retrying (${attempt}/${MAX_GATE_ATTEMPTS}) in 10s
 `;
 }
+function parseCoverageThreshold(bunfigText) {
+  const block = bunfigText.match(/coverageThreshold\s*=\s*\{([^}]*)\}/);
+  if (!block)
+    return null;
+  const threshold = {};
+  for (const axis of ["functions", "lines"]) {
+    const raw = block[1]?.match(new RegExp(`\\b${axis}\\s*=\\s*([\\d.]+)`))?.[1];
+    const value = raw === undefined ? Number.NaN : Number.parseFloat(raw);
+    if (Number.isFinite(value))
+      threshold[axis] = value;
+  }
+  return threshold.functions === undefined && threshold.lines === undefined ? null : threshold;
+}
+function scanCoverageShortfalls(logText, threshold) {
+  const shortfalls = new Map;
+  for (const line of logText.split(`
+`)) {
+    const row = line.match(COVERAGE_ROW_PATTERN);
+    if (!row)
+      continue;
+    const [, path, funcs, lines, uncovered] = row;
+    if (!path || path === "All files" || shortfalls.has(path))
+      continue;
+    const belowFunctions = threshold.functions !== undefined && Number.parseFloat(funcs ?? "") < threshold.functions * 100;
+    const belowLines = threshold.lines !== undefined && Number.parseFloat(lines ?? "") < threshold.lines * 100;
+    if (!belowFunctions && !belowLines)
+      continue;
+    const firstUncovered = uncovered?.match(/\d+/)?.[0] ?? "1";
+    shortfalls.set(path, `quality gate: coverage shortfall ${path}:${firstUncovered} funcs=${funcs} lines=${lines}`);
+  }
+  return [...shortfalls.values()];
+}
 function retryDelayMs(env) {
   const raw = Number.parseInt(env[RETRY_DELAY_MS_ENV] ?? "", 10);
   return Number.isFinite(raw) && raw >= 0 ? raw : RETRY_DELAY_MS_DEFAULT;
@@ -111,6 +144,21 @@ function runQualityGate(mode, env, options = {}) {
       gateSleep(delayMs);
     }
   }
+  if (gateRc !== 0) {
+    const gateLog = existsSync(abs(logFile)) ? readFileSync(abs(logFile), "utf8") : "";
+    if (/^\s*0 fail\b/m.test(gateLog) && !/^\s*[1-9]\d*\s+fail\b/m.test(gateLog)) {
+      const bunfigPath = cwd ? join(cwd, "bunfig.toml") : "bunfig.toml";
+      const threshold = existsSync(bunfigPath) ? parseCoverageThreshold(readFileSync(bunfigPath, "utf8")) : null;
+      if (threshold) {
+        for (const shortfall of scanCoverageShortfalls(gateLog, threshold)) {
+          process.stdout.write(`${shortfall}
+`);
+          appendFileSync(abs(logFile), `${shortfall}
+`);
+        }
+      }
+    }
+  }
   if (gateRc === 0) {
     const bytes = existsSync(abs(logFile)) ? statSync(abs(logFile)).size : 0;
     const attemptsLabel = gateAttempt > 0 ? String(gateAttempt) : "";
@@ -149,9 +197,11 @@ function main(argv, env = process.env) {
 }
 export {
   tailLines,
+  scanCoverageShortfalls,
   runShellCommand,
   runQualityGate,
   retryMessage,
+  parseCoverageThreshold,
   main,
   isTransientLock,
   extractFindings,
@@ -161,5 +211,6 @@ export {
   MAX_GATE_ATTEMPTS,
   MAX_FINDINGS,
   LOCKED_PATTERN,
-  FINDINGS_PATTERN
+  FINDINGS_PATTERN,
+  COVERAGE_ROW_PATTERN
 };

package/plugins/sp/scripts/quality-gate.ts

@@ -53,6 +53,12 @@ export const LOCKED_PATTERN = /SQLiteError: database is locked|SQLite database .
 /** `file.ext:line` anchor extraction, mirroring the former grep -oE. */
 export const FINDINGS_PATTERN = /[A-Za-z0-9_./-]+\.[A-Za-z]+:[0-9]+/g;
 
+/**
+ * bun's coverage table row: `File | % Funcs | % Lines | Uncovered Line #s` (0862 R2).
+ * Group 4 (uncovered line numbers) may be empty — a fully covered file has no entry.
+ */
+export const COVERAGE_ROW_PATTERN = /^\s*(\S+\.[A-Za-z]+)\s*\|\s*([\d.]+)\s*\|\s*([\d.]+)\s*\|\s*(\S*)/;
+
 export interface QualityGateEnv {
     wbs: string;
     qualityGateCmd?: string;
@@ -102,6 +108,53 @@ export function retryMessage(attempt: number): string {
     return `quality gate: database is locked; retrying (${attempt}/${MAX_GATE_ATTEMPTS}) in 10s\n`;
 }
 
+/** Per-axis coverage floor from `bunfig.toml`; a missing key leaves that axis unchecked. */
+export interface CoverageThreshold {
+    functions?: number;
+    lines?: number;
+}
+
+/**
+ * Parse `coverageThreshold = { lines = 0.9, functions = 0.9 }` out of bunfig text.
+ * `null` when the setting is absent — the caller then skips the shortfall scan entirely.
+ */
+export function parseCoverageThreshold(bunfigText: string): CoverageThreshold | null {
+    const block = bunfigText.match(/coverageThreshold\s*=\s*\{([^}]*)\}/);
+    if (!block) return null;
+    const threshold: CoverageThreshold = {};
+    for (const axis of ['functions', 'lines'] as const) {
+        const raw = block[1]?.match(new RegExp(`\\b${axis}\\s*=\\s*([\\d.]+)`))?.[1];
+        const value = raw === undefined ? Number.NaN : Number.parseFloat(raw);
+        if (Number.isFinite(value)) threshold[axis] = value;
+    }
+    return threshold.functions === undefined && threshold.lines === undefined ? null : threshold;
+}
+
+/**
+ * One `quality gate: coverage shortfall <path>:<line> funcs=<f> lines=<l>` line per distinct table
+ * row below either axis (thresholds are fractions, table numbers are percentages). `line` is the
+ * first number of the uncovered column, else `1`.
+ */
+export function scanCoverageShortfalls(logText: string, threshold: CoverageThreshold): string[] {
+    const shortfalls = new Map<string, string>();
+    for (const line of logText.split('\n')) {
+        const row = line.match(COVERAGE_ROW_PATTERN);
+        if (!row) continue;
+        const [, path, funcs, lines, uncovered] = row;
+        if (!path || path === 'All files' || shortfalls.has(path)) continue;
+        const belowFunctions =
+            threshold.functions !== undefined && Number.parseFloat(funcs ?? '') < threshold.functions * 100;
+        const belowLines = threshold.lines !== undefined && Number.parseFloat(lines ?? '') < threshold.lines * 100;
+        if (!belowFunctions && !belowLines) continue;
+        const firstUncovered = uncovered?.match(/\d+/)?.[0] ?? '1';
+        shortfalls.set(
+            path,
+            `quality gate: coverage shortfall ${path}:${firstUncovered} funcs=${funcs} lines=${lines}`,
+        );
+    }
+    return [...shortfalls.values()];
+}
+
 function retryDelayMs(env: QualityGateEnv): number {
     const raw = Number.parseInt(env[RETRY_DELAY_MS_ENV] ?? '', 10);
     return Number.isFinite(raw) && raw >= 0 ? raw : RETRY_DELAY_MS_DEFAULT;
@@ -178,6 +231,23 @@ export function runQualityGate(
         }
     }
 
+    // Coverage-only failures carry no `file.ext:line` anchor, so findings extraction would hand the
+    // fix hop an empty file. Name one shortfall line per under-threshold row instead (0862 R2) —
+    // real test failures, an absent threshold and the exit-0 contract are untouched.
+    if (gateRc !== 0) {
+        const gateLog = existsSync(abs(logFile)) ? readFileSync(abs(logFile), 'utf8') : '';
+        if (/^\s*0 fail\b/m.test(gateLog) && !/^\s*[1-9]\d*\s+fail\b/m.test(gateLog)) {
+            const bunfigPath = cwd ? join(cwd, 'bunfig.toml') : 'bunfig.toml';
+            const threshold = existsSync(bunfigPath) ? parseCoverageThreshold(readFileSync(bunfigPath, 'utf8')) : null;
+            if (threshold) {
+                for (const shortfall of scanCoverageShortfalls(gateLog, threshold)) {
+                    process.stdout.write(`${shortfall}\n`); // tee: stdout and the log
+                    appendFileSync(abs(logFile), `${shortfall}\n`);
+                }
+            }
+        }
+    }
+
     if (gateRc === 0) {
         const bytes = existsSync(abs(logFile)) ? statSync(abs(logFile)).size : 0;
         const attemptsLabel = gateAttempt > 0 ? String(gateAttempt) : '';

package/plugins/sp/scripts/surface-drift-inventory.ts

@@ -235,7 +235,6 @@ export function nounOfReference(file: string): string | null {
         workflows: 'workflow',
         agent: 'agent',
         message: 'message',
-        team: 'team',
         init: 'init',
         serve: 'serve',
     };
@@ -641,7 +640,6 @@ const JSON_PROBES: string[][] = [
     ['workflow', 'list', '--json'],
     ['workflow', 'validate', 'basic.yaml', '--json'],
     ['status', '--json'],
-    ['team', 'status', '--json'],
     ['projects', 'list', '--json'],
 ];
 

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

@@ -27,13 +27,50 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-// ─── Regex (sync with packages/app/src/services/task-size-precheck.ts) ───────
+// ─── Counting (sync with packages/app/src/services/task-size-precheck.ts) ────
 
-/** Matches `- [ ] **R1.**` or `- [x] R1.` etc. Requires period after digits. */
-const R_ITEM_RE = /^\s*-\s*\[[ xX]\]\s*(\*\*)?R\d+\./m;
+/**
+ * Requirement item: list marker required, then an optional checkbox, then the R-number in the
+ * house `- **R1** — <text>` or legacy `- [ ] R1. <text>` form. A bare `R1 <text>` line is prose.
+ */
+const R_ITEM_RE_SOURCE = '^\\s*[-*]\\s+(?:\\[[ xX]\\]\\s*)?[*_]{0,2}R(\\d+)\\.?[*_]{0,2}(?:\\s|$)';
+
+/** Top-level numbered Plan step (`1. <text>`). */
+const NUMBERED_PLAN_ITEM_RE_SOURCE = '^\\d+\\.\\s';
+
+/** Checklist Plan item (`- [ ] <text>`, `- [x] <text>`). */
+const CHECKLIST_ITEM_RE_SOURCE = '^\\s*[-*]\\s+\\[[ xX]\\]';
+
+/**
+ * Body of a `##`/`###` section (heading line excluded), up to the next `##`/`###` heading.
+ * `null` when the heading is absent — callers decide the fallback.
+ */
+function sectionBody(content: string, headingPattern: string): string | null {
+    const heading = content.match(new RegExp(headingPattern, 'm'));
+    if (!heading) return null;
+    const rest = content.slice((heading.index ?? 0) + heading[0].length);
+    const nextHeading = rest.match(/^#{2,3}\s+/m);
+    return nextHeading ? rest.slice(0, nextHeading.index ?? 0) : rest;
+}
+
+/** Distinct R-items in `## Requirements` (whole content when the heading is absent). */
+function countRItems(taskContent: string): number {
+    const body = sectionBody(taskContent, '^#{2,3}\\s+Requirements\\s*$') ?? taskContent;
+    const numbers = new Set<string>();
+    for (const match of body.matchAll(new RegExp(R_ITEM_RE_SOURCE, 'gm'))) {
+        numbers.add(match[1] ?? '');
+    }
+    return numbers.size;
+}
 
-/** Matches checklist items under the Plan section. */
-const CHECKLIST_ITEM_RE = /^\s*-\s*\[[ xX]\]/m;
+/** Plan items: top-level numbered steps plus checklist items under `## Plan`. */
+function countPlanItems(taskContent: string): number {
+    const body = sectionBody(taskContent, '^#{2,3}\\s+Plan\\s*$');
+    if (body === null) return 0;
+    const numbered = body.match(new RegExp(NUMBERED_PLAN_ITEM_RE_SOURCE, 'gm'))?.length ?? 0;
+    const checklist = body.match(new RegExp(CHECKLIST_ITEM_RE_SOURCE, 'gm'))?.length ?? 0;
+    return numbered + checklist;
+}
 
 // ─── CLI ─────────────────────────────────────────────────────────────────────
 
@@ -128,17 +165,8 @@ function main(): void {
         process.exit(0);
     }
 
-    const reqCount = taskContent.match(new RegExp(R_ITEM_RE.source, 'gm'))?.length ?? 0;
-
-    const planMatch = taskContent.match(/^#{2,3}\s+Plan\s*$/m);
-    const planBody = planMatch
-        ? (() => {
-              const rest = taskContent.slice((planMatch.index ?? 0) + planMatch[0].length);
-              const nextSection = rest.match(/^#{2,3}\s+/m);
-              return nextSection ? rest.slice(0, nextSection.index ?? 0) : rest;
-          })()
-        : '';
-    const planItemCount = planBody.match(new RegExp(CHECKLIST_ITEM_RE.source, 'gm'))?.length ?? 0;
+    const reqCount = countRItems(taskContent);
+    const planItemCount = countPlanItems(taskContent);
 
     const reasons: string[] = [];
     if (reqCount > maxReqs) {

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

@@ -298,6 +298,11 @@ function normalizeAcTitle(title: string): string {
             // U+02BC stays a meaningful character, never removable punctuation.
             .replace(/[\u0027\u2018\u2019\u201c\u201d]/g, '')
             .replace(/\s+/g, ' ')
+            // A declared bold head keeps its sentence-final period (`- **AC1: … form.**`) while an
+            // answer row normally cites it without one. Both the declared spelling and the queried
+            // row normalize through here, so dropping it is symmetric — it can only merge titles
+            // that already differ by nothing but trailing periods.
+            .replace(/\s*\.+$/, '')
             .trim()
     );
 }
@@ -332,6 +337,16 @@ function buildAcIdentityIndex(taskContent: string, featureContent: string | null
         const leading = label.split(/\s+/)[0] ?? '';
         if (leading && leading !== label) declareIdentity(leading);
     }
+    // Bold head of a single-line criterion bullet (task 0862 R4): the bold span and its
+    // head before the first ` — ` / `:` are declared ids, so `- **AC2 — Title.** Given …`
+    // answers to both `AC2` and the full bold title.
+    for (const m of section.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*(.+?)\*\*/gm)) {
+        const inner = (m[1] ?? '').trim();
+        if (!inner) continue;
+        declareIdentity(inner);
+        const head = inner.split(/\s+[—–]\s+|:/)[0]?.trim() ?? '';
+        if (head && head !== inner) declareIdentity(head);
+    }
     // Bold-trajectory form (task 0817 R3): answers may cite an AC by a bare
     // `**AC id**` paragraph (house style for long/complex ids). Only whole-line
     // bold spans count — the line-anchored lazy regex rejects lines with two
@@ -492,7 +507,8 @@ function main(): void {
             else
                 add(
                     `line ${row.line}: AC ID "${row.id.slice(0, 60)}" matches no task AC checklist label or scenario title ` +
-                        '(accepted forms: exact title, bare title, `Scenario:` prefix, bracket tags, declared AC-N alias)',
+                        "(accepted forms: exact title, bare title, a criterion bullet's bold head or full bold span, " +
+                        '`Scenario:` prefix, bracket tags, declared AC-N alias)',
                 );
         } else if (canonicalKey !== null && seenAc.has(canonicalKey)) {
             const first = seenAc.get(canonicalKey) ?? '';

package/plugins/sp/skills/code-review/references/review-lenses.md

@@ -18,6 +18,9 @@ Five dimensions for structured code review. Each lens has diagnostic questions;
 - Are edge cases handled (empty, null, boundary, error)?
 - Are invariants preserved across the changed functions?
 - Is there a test that fails if the behavior is wrong?
+- A changed route response shape or client parser is covered both ways: a server-side key-shape
+  assertion and a test that runs a real payload through the real parser (a dropped key like `teamId`
+  must fail something). Missing either → P2.
 
 **Severity guide:** Logic errors that produce wrong output → P1. Missing edge case that could cause wrong output → P2. Unclear control flow that might hide bugs → P3.
 

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

@@ -1,6 +1,6 @@
 ---
 name: spur-cli
-description: "Reference and operate the complete `spur` CLI surface: task, feature, rule, workflow, builder, agent, message, team, self, history, and projects. Use for verb or flag lookup, machine-readable output and exit contracts, or CLI-gated corpus writes. Triggers: \"spur task\", \"spur history\", \"spur projects\", \"create a task\", \"task check\", and any Spur CLI convention. Not for planning or execution lifecycle orchestration (`sp:spur-dev`)."
+description: "Reference and operate the complete `spur` CLI surface: task, feature, rule, workflow, builder, agent, message, self, history, and projects. Use for verb or flag lookup, machine-readable output and exit contracts, or CLI-gated corpus writes. Triggers: \"spur task\", \"spur history\", \"spur projects\", \"create a task\", \"task check\", and any Spur CLI convention. Not for planning or execution lifecycle orchestration (`sp:spur-dev`)."
 license: Apache-2.0
 metadata:
   author: spur
@@ -17,7 +17,6 @@ metadata:
     - builder
     - agent
     - message
-    - team
     - self
     - history
     - projects
@@ -45,9 +44,8 @@ Pick the noun, read its reference. Each Tier A and Tier B reference owns that no
 | **Tier A** | **rule** | Constraint quality gate: run presets, author rules, fine-tune, validate rule files/presets, extend engine | [references/rules.md](references/rules.md) |
 | **Tier A** | **workflow** | Dual-mode workflow runtime: author state-machine / transition-flow workflows, validate, run, read traces | [references/workflows.md](references/workflows.md) |
 | **Tier A** | **builder** | Release plumbing: bump a package (or the `workspace:`-pinned set) with `bump-ver`, delete release tags with `drop-tags`, commit + tag + optional push | [references/builder.md](references/builder.md) |
-| **Tier B** | **agent** | Coding-agent execution surface: run prompts via detected/named agents, manage team agent specs, persistent self-draining loop, readiness check | [references/agent.md](references/agent.md) |
+| **Tier B** | **agent** | Coding-agent execution surface: run prompts via detected/named agents, list agent specs, start/stop supervised processes, readiness check | [references/agent.md](references/agent.md) |
 | **Tier B** | **message** | Durable inter-agent messaging: send, inbox, reply, watch | [references/message.md](references/message.md) |
-| **Tier B** | **team** | Team coordination and supervision: assign, status, up/down rosters, start/stop supervised processes | [references/team.md](references/team.md) |
 | **Tier B** | **self** | Self-management verbs: scaffold (`init`), schema migrations (`migrate`), local web server (`serve`), status overview (`status`); `self init` runs post-scaffold validation probes & layout classification | [references/self.md](references/self.md) |
 | **Tier B** | **history** | Import agent histories, aggregate forensic artifacts, render reports, and run the checkpoint-resumed daily pipeline | [references/history.md](references/history.md) |
 | **Tier B** | **projects** | Manage the local multi-project registry and start/stop project servers | [references/projects.md](references/projects.md) |
@@ -138,13 +136,11 @@ and spreading it; full contract in `docs/04_DESIGN.md` §1.0.1.
 
 ## See also
 
-- **[references/agent.md](references/agent.md)** - coding-agent execution surface (`run`, `loop`,
-  spec management). Cross-references the
+- **[references/agent.md](references/agent.md)** - coding-agent execution surface (`run`, `wait`,
+  `list --specs`, `start`/`stop`). Cross-references the
   [dispatch-surface rule](../parallel-execution/references/dispatch-surface.md).
 - **[references/message.md](references/message.md)** - durable inter-agent messaging (`send`,
   `inbox`, `reply`, `watch`).
-- **[references/team.md](references/team.md)** - team coordination and supervision (`assign`,
-  `status`, `up`/`down`, `start`/`stop`).
 - **[references/self.md](references/self.md)** - `spur self init|migrate|serve|status` CLI verbs
   (the four legacy top-level nouns remain hidden aliases). `self init` runs post-scaffold init
   validation (Phase 1.5/1.6 probes).