@cleocode/core 2026.10.27 → 2026.11.1-canary.10

package/dist/orchestration/spawn-prompt.js

@@ -41,11 +41,13 @@ import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getProviderAskTool } from '@cleocode/caamp';
+import { subjectSlug } from '../docs/doc-name-rule.js';
 import { normalizeSlug } from '../docs/slug-normalize.js';
 import { provisionIsolatedShell } from '../sdk/isolation.js';
 import { resolveSkillLocation, resolveSkillPath } from '../skills/skill-paths.js';
 import { buildLeanChangeBlock } from './lean-change.js';
 import { buildBudgetedPsycheMemoryBlock, relevanceContextFromTask, } from './psyche-memory-budget.js';
+import { buildProjectWorkerPolicyBlock } from './worker-policy.js';
 /**
  * Locate `packages/core/templates/CLEO-INJECTION.md` at runtime.
  *
@@ -134,6 +136,17 @@ export const SPAWN_CLONE_EXCLUDE_PATTERNS = ['.gitnexus'];
  * @task T1614
  */
 export const INLINE_TEXT_SIZE_LIMIT_BYTES = 32 * 1024; // 32 KB
+/**
+ * Default budget, in characters, for the prose of a task's attached documents
+ * inlined into a spawn prompt (T14190). Linked history (review findings,
+ * earlier refusals, outcomes) grew one prompt past 100k characters; past this
+ * budget each further document is named by its exact ref (name and SHA-256)
+ * with the command that fetches it. `orchestration.spawnDocBudgetChars` in the
+ * project config overrides it.
+ *
+ * @task T14190
+ */
+export const DEFAULT_SPAWN_DOC_BUDGET_CHARS = 16_000;
 /** Default tier when none specified. */
 export const DEFAULT_SPAWN_TIER = 1;
 /** All known protocol phases (for iteration in tests). */
@@ -457,16 +470,25 @@ function buildWorkerConstraintsBlock(constraints, taskId) {
  * the agent can read them without additional CLI calls. Binary or large
  * attachments are listed with their name, size, and a `cleo docs fetch` pointer.
  *
+ * Inlined prose is capped at `budgetChars` (T14190): a text attachment that
+ * would push the inlined total past it is named by its exact ref (name and
+ * SHA-256) with its fetch command instead, and the section closes with a list
+ * of every document left out and how to read it.
+ *
  * @param taskId      - Task identifier (for CLI command examples).
  * @param attachments - Resolved attachment records from `blobList`.
+ * @param budgetChars - Most characters of attachment prose to inline.
  * @returns Markdown section string. Returns empty string when `attachments` is
  *          empty — callers omit the section entirely in that case.
  *
  * @task T1614 — spawn auto-attaches docs to subagent task
+ * @task T14190
  */
-function buildDocsBlock(taskId, attachments) {
+function buildDocsBlock(taskId, attachments, budgetChars = DEFAULT_SPAWN_DOC_BUDGET_CHARS) {
     if (attachments.length === 0)
         return '';
+    let inlined = 0;
+    const withheld = [];
     const lines = [
         '## Task Documents',
         '',
@@ -482,7 +504,11 @@ function buildDocsBlock(taskId, attachments) {
     for (const att of attachments) {
         const sizeKb = (att.sizeBytes / 1024).toFixed(1);
         const mimeLabel = att.mimeType ? ` (${att.mimeType})` : '';
-        if (att.textContent !== undefined) {
+        const fits = att.textContent !== undefined && inlined + att.textContent.length <= budgetChars;
+        if (att.textContent !== undefined && !fits)
+            withheld.push(att);
+        if (att.textContent !== undefined && fits) {
+            inlined += att.textContent.length;
             // Inline the text content between fenced blocks.
             const fence = att.name.endsWith('.json') ? '```json' : '```';
             lines.push(`### ${att.name}${mimeLabel} — ${sizeKb} KB`);
@@ -498,12 +524,26 @@ function buildDocsBlock(taskId, attachments) {
             lines.push('');
             lines.push(`SHA-256: \`${att.sha256}\``);
             lines.push('');
+            if (att.textContent !== undefined) {
+                lines.push(`Not inlined: the spawn prompt's ${budgetChars}-character budget for document prose is spent.`);
+                lines.push('');
+            }
             lines.push('```bash');
             lines.push(`cleo docs fetch ${att.sha256.slice(0, 8)}`);
             lines.push('```');
             lines.push('');
         }
     }
+    if (withheld.length > 0) {
+        lines.push(`${withheld.length} document${withheld.length === 1 ? ' was' : 's were'} left out to keep this ` +
+            `prompt within ${budgetChars} characters of document prose; read ${withheld.length === 1 ? 'it' : 'each'} ` +
+            'by its exact ref when the task needs it:');
+        lines.push('');
+        for (const att of withheld) {
+            lines.push(`- ${att.name} — sha256 \`${att.sha256}\` — \`cleo docs fetch ${att.sha256.slice(0, 8)}\``);
+        }
+        lines.push('');
+    }
     return lines.join('\n');
 }
 /** Build the header block — identity banner + tier + protocol. Kept short so
@@ -637,16 +677,13 @@ function buildStageGuidance(protocol, outputDir) {
             '**Objective**: Write code that satisfies every acceptance criterion.',
             '',
             'Deliverables:',
-            '- Source changes under `packages/<pkg>/src/`',
-            '- Tests under `packages/<pkg>/src/**/__tests__/*.test.ts` (vitest)',
-            '- TSDoc comments on every exported function/class/type',
+            "- Source and test changes in the project's own layout, following its conventions (read the project's AGENTS.md)",
+            '- Documentation on every exported symbol, in the language the project uses',
             '- Commit atomically (one feature/fix per commit) with conventional commit messages',
             '',
             'Quality Bar:',
-            '- NEVER `any` or `unknown` shortcuts — see `@~/.agents/AGENTS.md` code-quality rules',
-            '- Import types from `@cleocode/contracts` — never inline/mock',
-            '- `pnpm biome check --write .` must show no warnings',
-            '- `pnpm run build` must succeed (full dep graph)',
+            "- The project's code-quality rules (its AGENTS.md) hold for every line you write",
+            "- The project's lint, typecheck and build pass (see Quality Gates)",
             '- Zero new test failures — prove it with affected or targeted runs, never a manual full suite (see Quality Gates)',
             '',
             '**FISE-2 (T9231 / ADR-070)**: If `CLEO_AGENT_ROLE=lead`, you MUST use `delegate_task`',
@@ -671,9 +708,9 @@ function buildStageGuidance(protocol, outputDir) {
             '**Objective**: Prove behavior via tests. Zero-regression mandate.',
             '',
             'Deliverables:',
-            '- Unit tests for every new code path (vitest `describe`/`it` blocks)',
-            '- Integration tests under `packages/<pkg>/src/**/__tests__/*.test.ts`',
-            `- Vitest JSON output captured at \`${outputDir}/<taskId>-vitest.json\``,
+            "- Unit tests for every new code path, in the project's test framework and layout",
+            '- Integration tests where the project keeps them',
+            `- The test runner's JSON report captured at \`${outputDir}/<taskId>-tests.json\``,
             '- Evidence atom: `ci:<pr>` once the PR merged (with `evidence.ciSatisfies`); otherwise `tool:test-affected` (affected packages; needs `testing.affectedCommand`), `test-run:<json>` (pre-recorded structured output of a targeted run), or `tool:test` (executes resolved testing.command; with an affected command configured, only for root-config changes)',
         ].join('\n'),
         release: [
@@ -682,10 +719,9 @@ function buildStageGuidance(protocol, outputDir) {
             '**Objective**: Version, changelog, tag, publish. No partial releases.',
             '',
             'Deliverables:',
-            '- Bump monorepo + package versions (CalVer YYYY.MM.patch)',
-            '- CHANGELOG.md entry under the new version',
-            '- Tag via `git tag v<version>` and push with `--tags`',
-            '- CI must be GREEN before `npm publish` — use `cleo release plan` + `cleo release open` (the canonical 4-verb pipeline)',
+            "- Bump versions in the project's own scheme",
+            '- Changelog entry under the new version, where the project keeps one',
+            '- CI must be GREEN before anything publishes — use `cleo release plan` + `cleo release open` (the canonical pipeline)',
             '- Do NOT force-push or bypass hooks',
         ].join('\n'),
         contribution: [
@@ -701,52 +737,29 @@ function buildStageGuidance(protocol, outputDir) {
     };
     return guidance[protocol] ?? guidance['implementation'] ?? '';
 }
-/** Build the evidence-based gate block (T832 / ADR-051). */
+/**
+ * Build the closure block (T14303): PR work closes through the PR's
+ * `Closes:`/`Refs:` line, a non-author verdict per criterion and the merge
+ * sweep (ADR-099); only no-PR work records gates by hand, following
+ * `cleo done <id> --plan` (ADR-051).
+ */
 function buildEvidenceGateBlock(taskId) {
     return [
-        '## Evidence-Based Gate Ritual (MANDATORY · ADR-051 · T832)',
+        '## Closing the Task (ADR-099 · evidence ADR-051)',
         '',
-        'Every gate write MUST carry programmatic evidence. CLEO validates evidence against git, the filesystem, and the toolchain. `cleo verify --all` without `--evidence` is REJECTED with `E_EVIDENCE_MISSING`.',
+        '### PR work (the normal path)',
         '',
-        '### Step 1 — capture evidence per gate',
+        `1. Commit on your branch, push it, and open a PR whose body has \`Closes: ${taskId} AC1,AC2\` naming every criterion it delivers (\`Refs: ${taskId} AC…\` for a partial delivery).`,
+        `2. A reviewer who is not an author records a verdict per criterion on the PR head (\`cleo review packet <pr> --task ${taskId}\`, then \`cleo review verdict\`). Never review your own work.`,
+        '3. When the PR merges on green CI, the merge sweep records the evidence and closes the task. No step follows the merge.',
         '',
-        '```bash',
-        '# implemented — commit + file list',
-        `cleo verify ${taskId} --gate implemented \\`,
-        '  --evidence "commit:$(git rev-parse HEAD);files:<comma-separated-paths>"',
-        '',
-        '# Plan first: picks affected → ci → full and shows each tool cache state',
-        `cleo done ${taskId} --plan`,
-        '',
-        '# testsPassed — PR merged AND project sets evidence.ciSatisfies: CI on the merge commit, no local run',
-        `cleo verify ${taskId} --gate testsPassed --evidence "ci:<pr>"`,
-        '#  otherwise, with testing.affectedCommand configured: affected packages',
-        `cleo verify ${taskId} --gate testsPassed --evidence "tool:test-affected"`,
-        '#  without it: a targeted vitest json of the changed test files (or tool:test)',
-        `cleo verify ${taskId} --gate testsPassed --evidence "test-run:/tmp/vitest-out.json"`,
-        '',
-        '// `tool:<name>` executes the resolved command (from project-context.json or language defaults); `test-run:<json>` records a pre-existing scoped run. Never run the suite by hand and then again via `tool:test`; with `testing.affectedCommand` configured, a full `tool:test` is only for root-config changes.',
-        '',
-        '# qaPassed — `ci:<pr>` under the same conditions; otherwise biome + tsc exit 0',
-        `cleo verify ${taskId} --gate qaPassed --evidence "tool:biome;tool:tsc"`,
-        '',
-        '# documented — docs path',
-        `cleo verify ${taskId} --gate documented --evidence "files:docs/<path>.md"`,
-        '',
-        '# cleanupDone — summary note',
-        `cleo verify ${taskId} --gate cleanupDone --evidence "note:<summary>"`,
-        '',
-        '# securityPassed — scan or waiver',
-        `cleo verify ${taskId} --gate securityPassed --evidence "tool:security-scan"`,
-        '#  OR',
-        `cleo verify ${taskId} --gate securityPassed --evidence "note:no network surface"`,
-        '```',
-        '',
-        '### Step 2 — then complete',
+        '### No-PR work',
         '',
         '```bash',
-        `cleo memory observe "<concise learning>" --title "<title>"`,
+        `cleo done ${taskId} --plan   # names the evidence each gate needs`,
+        `cleo verify ${taskId} --gate <gate> --evidence "<atoms>;satisfies:${taskId}#AC1"   # each gate it names`,
         `cleo complete ${taskId}`,
+        'cleo memory observe "<concise learning>" --title "<title>"',
         '```',
         '',
         'On `complete`, CLEO re-validates every hard atom (commit reachable, file sha256, test-run hash). Tampering → `E_EVIDENCE_STALE` — re-run verify with updated evidence.',
@@ -754,12 +767,6 @@ function buildEvidenceGateBlock(taskId) {
         '**Forbidden**: `cleo complete --force` (REMOVED per ADR-051). `cleo verify --all` without `--evidence` (REJECTED). `note:` as the only atom on `implemented` or `testsPassed` (INSUFFICIENT).',
     ].join('\n');
 }
-// T10485 closure: buildChangesetLintGateBlock removed.
-// Original T10448 standalone section was deprecated by T10452 which inlined
-// the check into buildQualityGateBlock (see `node scripts/lint-changesets.mjs`
-// line in the Quality Gates block). A subsequent merge collision in T9937
-// briefly restored this function as an orphan unused declaration. Removed
-// here per T10452's design intent — the single inlined version is the SSoT.
 /**
  * The one governed path for heavy work (T13134), in every spawn prompt and on
  * every agent surface (CLEO-INJECTION.md, ct-cleo). The P0 of 2026-10-03
@@ -769,21 +776,77 @@ function buildEvidenceGateBlock(taskId) {
  * the markers on every surface.
  */
 export const GOVERNED_HEAVY_WORK_LINE = 'Heavy work (tests, typechecks, builds): one command at a time through `cleo run --wait --class <test|build|full-build> -- <command>` (the heavy-command hook rewrites it for you where installed; exit 75 means it was not admitted before the wait ran out: wait and retry). Never wrap `cleo run` or `cleo verify` in another queue or wrapper script, never put one inside them (the two lock systems deadlock), and never raise heap or worker counts (`NODE_OPTIONS=--max-old-space-size=…`, `--maxWorkers`): CLEO sizes them.';
-/** Build the quality-gate block — biome + build + scoped test evidence + changeset hygiene. */
-function buildQualityGateBlock() {
+/**
+ * Read a project's own commands from `.cleo/project-context.json` (T14303):
+ * the spawn prompt names them, never another project's.
+ *
+ * @param projectRoot - The project root.
+ * @returns The declared commands; absent ones are left out.
+ * @task T14303
+ */
+export function readProjectCommands(projectRoot) {
+    // The spawned project's own file; an ambient CLEO_DIR names another project.
+    let ctx = null;
+    try {
+        const parsed = JSON.parse(readFileSync(join(projectRoot, '.cleo', 'project-context.json'), 'utf-8'));
+        ctx =
+            typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        ctx = null;
+    }
+    const pick = (section, key) => {
+        const block = ctx?.[section];
+        const value = typeof block === 'object' && block !== null
+            ? block[key]
+            : undefined;
+        return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+    };
+    const test = pick('testing', 'command');
+    const affectedTest = pick('testing', 'affectedCommand');
+    const build = pick('build', 'command');
+    return {
+        ...(test ? { test } : {}),
+        ...(affectedTest ? { affectedTest } : {}),
+        ...(build ? { build } : {}),
+    };
+}
+/**
+ * Build the quality-gate block from the project's own commands (T14303):
+ * its build, its lint and typecheck through `tool:` atoms, and its test
+ * command; nothing another project declares.
+ */
+function buildQualityGateBlock(taskId, commands, policy) {
+    const ciOnly = policy?.verification?.full === 'ci';
+    const testLine = commands.test
+        ? `This project's test command is \`${commands.test}\`${commands.affectedTest ? ` and its affected-only command is \`${commands.affectedTest}\`` : ''} (\`.cleo/project-context.json\`).`
+        : `This project declares no \`testing.command\` in \`.cleo/project-context.json\`; \`cleo done ${taskId} --plan\` names what to run.`;
     return [
-        '## Quality Gates (run before every `cleo complete`)',
+        '## Quality Gates (before you open the PR, or before `cleo complete` for no-PR work)',
         '',
         '```bash',
-        'cleo run --wait --class build -- pnpm biome ci .       # full repo, strict — same as CI',
-        'cleo run --wait --class full-build -- pnpm run build   # full dep graph build',
-        'node scripts/lint-changesets.mjs  # validate .changeset/*.md entries (T10448)',
+        ...(!ciOnly && commands.build
+            ? [`cleo run --wait --class full-build -- ${commands.build}   # the project's build`]
+            : []),
+        ...(!ciOnly
+            ? [
+                `cleo verify ${taskId} --gate qaPassed --evidence "tool:lint;tool:typecheck"   # the project's own lint and typecheck`,
+            ]
+            : []),
         'git diff --stat HEAD   # verify the diff matches the story',
         '```',
         '',
         GOVERNED_HEAVY_WORK_LINE,
         '',
-        'Tests (zero new failures vs main): while iterating, run only the failing or changed test files. Record evidence once (`cleo done <id> --plan` picks for you): `ci:<pr>` when the PR merged and the project sets `evidence.ciSatisfies`; otherwise `tool:test-affected` when `testing.affectedCommand` is configured, else a targeted `test-run:<json>` or `tool:test`. Never run the full suite manually; with `testing.affectedCommand` configured, a full `tool:test` is only for root-config changes.',
+        ...(ciOnly
+            ? [
+                `Full verification runs in required CI: ${commands.build ? `build (\`${commands.build}\`), ` : ''}full tests${commands.test ? ` (\`${commands.test}\`)` : ''}, whole-project lint and typecheck. Do not run these locally.`,
+                `Local checks use \`cleo run --wait --class test -- <scoped-test-command>\`. ${policy?.verification?.local === 'single-file' ? 'Run one changed or failing test file per invocation; do not substitute an affected suite.' : 'Run affected tests only.'}${commands.affectedTest ? ` Use this project's \`testing.affectedCommand\` (\`${commands.affectedTest}\`), resolving its declared placeholders according to the project runner; ${policy?.verification?.local === 'single-file' ? 'the resolved command must select exactly one test file' : 'select only affected tests'}.` : " Select the project runner's file-scoped command before running it."} Formatting/lint may target changed files only.`,
+                `Evidence is still required: \`cleo done ${taskId} --plan\` names every gate. Merged green CI may satisfy \`testsPassed\` and \`qaPassed\` via \`ci:<pr>\` only when the project enables \`evidence.ciSatisfies\`; otherwise retain applicable scoped evidence and leave unproven gates open. CI placement never waives a gate or authorizes a contradictory local full run.`,
+            ]
+            : [
+                `Tests (zero new failures vs the default branch): ${testLine} While iterating, run only the failing or changed test files. Record evidence once (\`cleo done ${taskId} --plan\` picks for you): \`ci:<pr>\` when the PR merged and the project sets \`evidence.ciSatisfies\`; otherwise \`tool:test-affected\` when \`testing.affectedCommand\` is configured, else a targeted \`test-run:<json>\` or \`tool:test\`. Never run the full suite manually; with \`testing.affectedCommand\` configured, a full \`tool:test\` is only for root-config changes.`,
+            ]),
         '',
         'If ANY gate fails, fix it before completing. Do not bypass. Do not `--no-verify`. Do not amend published commits.',
     ].join('\n');
@@ -840,8 +903,12 @@ export function resolveSpawnReturnContract(protocol) {
         : SPAWN_RETURN_CONTRACTS.implementation;
 }
 /**
- * Build the return-format contract — the compressed cavecrew-style block the
- * subagent returns (T12521). Validators also accept the legacy one-liner
+ * Build the return-format contract — the worker report the subagent returns:
+ * one conclusion, the blocker, and proof lines, at most 100 words (T14361;
+ * compressed head line from T12521). The lead hands it to
+ * `cleo done --report`, which refuses it without proof (`checkWorkerReport`
+ * in `orchestrate/worker-report.ts`). Validators also accept the T12521
+ * `commits:`/`gates:` lines and the legacy one-liner
  * `<Type> <status>. Manifest appended to pipeline_manifest.` (see
  * `parseReturnMessage` in `validation/protocol-common.ts`).
  */
@@ -850,16 +917,16 @@ function buildReturnFormatBlock(protocol, askProviderId) {
     return [
         '## Return Format Contract (MANDATORY)',
         '',
-        'Return EXACTLY this block. No findings, no diffs, no prose.',
+        'Return ONLY this block, ≤100 words; no findings or diffs (detail → PR body).',
         '',
         '```',
         `${type} <complete|partial|blocked>. manifest:<entryId>`,
-        'commits: <sha7,sha7|none>',
-        'gates: <gate>=<pass|fail|skip> ...',
-        'blocker: <≤12 words|none>',
+        'conclusion: <result>',
+        'blocker: <none|why>',
+        'proof: <cmd> => exit <n>|<PR|sha|file>',
         '```',
         '',
-        'blocker: none when complete; required when partial/blocked. Findings → manifest, task record, commits.',
+        'blocker: none when complete; required when partial/blocked. No proof: line → `cleo done --report` refuses it.',
         buildHitlLine(type, askProviderId),
     ].join('\n');
 }
@@ -916,25 +983,33 @@ function buildFilePathsBlock(outputDir, testRunsDir) {
         `| Test-run captures | \`${testRunsDir}\` |`,
     ].join('\n');
 }
-/** Build the session-linkage block — thread orchestrator session id to subagent. */
-function buildSessionBlock(sessionId) {
+/** Bind every worker command to its preallocated session and existing claim. */
+function buildSessionBlock(sessionId, agentId, coordinatorSessionId, role = 'worker') {
     if (!sessionId) {
         return [
             '## Session Linkage',
             '',
-            'No active orchestrator session was found at spawn time. Before running any mutation, start one with:',
-            '',
-            '```bash',
-            'cleo session start --scope global --name "<descriptive name>"',
-            '```',
+            'No allocated worker session was supplied. Return blocked to the coordinator before any mutation; do not start a session or claim the task.',
         ].join('\n');
     }
+    const commandBinding = Object.entries({
+        CLEO_SESSION_ID: sessionId,
+        CLEO_AGENT_ID: agentId,
+        CLEO_AGENT_ROLE: role,
+    })
+        .map(([key, value]) => `${key}='${value.replaceAll("'", "'\\''")}'`)
+        .join(' ');
     return [
         '## Session Linkage',
         '',
-        `- **Orchestrator Session**: \`${sessionId}\``,
-        '- Log every mutation (task start/complete, memory observe, verify) against THIS session. Do not start a new one unless explicitly told.',
-        '- If the session has ended by the time you run, the orchestrator will hand you a new one via `cleo orchestrate handoff`.',
+        `- **Worker Session**: \`${sessionId}\``,
+        ...(coordinatorSessionId
+            ? [`- **Coordinator Session (reference only)**: \`${coordinatorSessionId}\``]
+            : []),
+        '- The task is already claimed under your allocated worker session and agent identity. Do not start another session, re-claim the task, or force-claim it.',
+        '- These allocated-worker instructions take precedence over generic session-start or task-start recipes in embedded skills.',
+        `- **Command binding**: begin every Bash call with \`export ${commandBinding}\`. This also applies without a worktree; keep the Worktree Setup Step 1 prefix when present.`,
+        '- If your session or claim has expired or belongs to someone else, return blocked to the coordinator for handoff; never replace it yourself.',
     ].join('\n');
 }
 /** Build the tier 0 protocol pointer — one-liner pointing at the canonical template. */
@@ -1009,7 +1084,7 @@ function buildTier1InjectionPointer() {
     return [
         '## CLEO Protocol (tier 1 — dedup pointer)',
         '',
-        '> Protocol: CLEO-INJECTION.md already loaded via AGENTS.md harness (v2.6.0). See https://github.com/kryptobaseddev/cleocode/blob/main/packages/cleo/AGENTS.md',
+        '> Protocol: CLEO-INJECTION.md already loaded via the AGENTS.md harness. Details: the `ct-cleo` skill, or `cleo briefing inject --section <name>`.',
     ].join('\n');
 }
 /**
@@ -1119,6 +1194,18 @@ function buildAgentCoordinationBlock(taskId, leadMailbox) {
         'Task state, evidence and results stay in CLEO (`cleo update`, `cleo verify`, `cleo manifest append`); a message never replaces them.',
     ].join('\n');
 }
+/**
+ * Build the one-line lead report address for tier-0 prompts under
+ * `orchestrate.leadWorker.v1`, where the Agent Coordination section is absent.
+ *
+ * @param taskId - Task the worker reports on.
+ * @param leadMailbox - AgentMBX mailbox of the spawning lead.
+ * @returns A single Markdown line.
+ * @task T14429
+ */
+function buildTier0LeadReportLine(taskId, leadMailbox) {
+    return `**Report to your lead:** \`mbx_send\` to \`${leadMailbox}\` (without the MCP server: \`agentmbx send --as <you> --to ${leadMailbox} --subject "${taskId}" -m "<report>"\`) a report of at most 100 words: conclusion, blocker, proof.`;
+}
 /** Build the anti-pattern reference. */
 function buildAntiPatternBlock() {
     return [
@@ -1182,6 +1269,13 @@ export function buildSpawnPrompt(input) {
     const taskId = input.task.id;
     const epicId = input.task.parentId ?? '';
     const protocol = input.protocol;
+    const protocolResolution = input.protocolResolution ?? {
+        protocol,
+        source: 'explicit',
+        conflicts: [],
+    };
+    const sessionId = input.workerSession?.sessionId ?? input.sessionId;
+    const agentId = input.workerSession?.agentId ?? input.agentId ?? `agent-${taskId.toLowerCase()}`;
     // Absolute paths resolved against the orchestrator's project root.
     //
     // ADR-027 §6.2 / T1096: manifestPath was removed. The `pipeline_manifest`
@@ -1200,10 +1294,11 @@ export function buildSpawnPrompt(input) {
         OUTPUT_DIR: outputDir,
         TEST_RUNS_DIR: testRunsDir,
         PROJECT_ROOT: input.projectRoot,
-        SESSION_ID: input.sessionId ?? '',
+        SESSION_ID: sessionId ?? '',
         PROTOCOL: protocol,
         TIER: String(tier),
-        TOPIC_SLUG: slugify(input.task.title),
+        // T14129: agents record docs under this slug, so it follows the doc naming rule.
+        TOPIC_SLUG: subjectSlug(input.task.title),
         WORKTREE_PATH: worktreePath,
         WORKTREE_BRANCH: worktreeBranch,
     };
@@ -1225,7 +1320,7 @@ export function buildSpawnPrompt(input) {
     // 1. Header              — short banner (id / protocol / tier)
     // 2. Task Identity       — id, title, description, size, AC
     // 3. Return Format       — contract the subagent must honor on exit
-    // 4. Session Linkage     — orchestrator session id
+    // 4. Session Linkage     — allocated worker identity, coordinator reference
     // 5. Worktree Setup      — pre-provisioned path + context-isolation (T1140)
     // 6. File Paths          — absolute paths
     // 7. Stage Guidance      — phase-specific directives
@@ -1236,7 +1331,19 @@ export function buildSpawnPrompt(input) {
     const askProviderId = input.askProviderId ?? (input.harnessHint === 'claude-code' ? 'claude-code' : undefined);
     authoredSections.push(buildReturnFormatBlock(protocol, askProviderId));
     authoredSections.push(buildManifestProtocolBlock(taskId, protocol));
-    authoredSections.push(buildSessionBlock(input.sessionId));
+    authoredSections.push(buildSessionBlock(sessionId, agentId, input.coordinatorSessionId, input.workerSession?.role));
+    authoredSections.push([
+        `**Protocol authority**: \`${protocolResolution.source}\` selected \`${protocol}\`.`,
+        ...(protocolResolution.pipelineStageSource
+            ? [`Stored stage provenance: \`${protocolResolution.pipelineStageSource}\`.`]
+            : []),
+        ...protocolResolution.conflicts.map((conflict) => `- Protocol disagreement: ${conflict}`),
+        ...(protocolResolution.conflicts.length > 0
+            ? [
+                'An intentional assignment can resolve this with explicit `--protocol`; no classifier decides owner intent.',
+            ]
+            : []),
+    ].join('\n'));
     // Worktree Setup (T1140) — only emitted when the engine provisioned one.
     // Omitted when --no-worktree was passed or worktree creation failed.
     if (worktreePath) {
@@ -1245,8 +1352,8 @@ export function buildSpawnPrompt(input) {
         // to the deterministic handle (mirrors `deriveAgentHandle`) so a prompt
         // built without an explicit handle still attributes to a stable agent.
         authoredSections.push(buildWorktreeSetupBlock(worktreePath, worktreeBranch, taskId, {
-            sessionId: input.sessionId,
-            agentId: input.agentId ?? `agent-${taskId.toLowerCase()}`,
+            sessionId,
+            agentId,
         }));
     }
     // Spawn-clone exclude filter (T9226) — emitted when the engine applied
@@ -1270,6 +1377,10 @@ export function buildSpawnPrompt(input) {
     if (tier >= 1) {
         authoredSections.push(buildAgentCoordinationBlock(taskId, input.leadMailbox));
     }
+    else if (input.leadWorkerV1 === true && input.leadMailbox) {
+        // T14429 — tier 0 stays minimal, but a lead/worker worker needs its address.
+        authoredSections.push(buildTier0LeadReportLine(taskId, input.leadMailbox));
+    }
     if (tier >= 1 && input.dashboardSummary) {
         authoredSections.push(buildDashboardContextBlock(input.dashboardSummary));
     }
@@ -1285,17 +1396,14 @@ export function buildSpawnPrompt(input) {
     // Text-based attachments ≤ INLINE_TEXT_SIZE_LIMIT_BYTES are inlined; others get a fetch pointer.
     // Omitted entirely when no attachments exist so the prompt stays lean.
     if (input.docAttachments && input.docAttachments.length > 0) {
-        const docsBlock = buildDocsBlock(taskId, input.docAttachments);
+        const docsBlock = buildDocsBlock(taskId, input.docAttachments, input.docBudgetChars);
         if (docsBlock) {
             authoredSections.push(docsBlock);
         }
     }
     authoredSections.push(buildStageGuidance(protocol, outputDir));
     authoredSections.push(buildEvidenceGateBlock(taskId));
-    // T10448 partial — buildChangesetLintGateBlock() was referenced but never
-    // implemented/exported. Restored as a follow-up; for now skip cleanly so the
-    // tsc build does not block releases. Tracked: T10448.
-    authoredSections.push(buildQualityGateBlock());
+    authoredSections.push(buildQualityGateBlock(taskId, readProjectCommands(input.projectRoot), input.workerPolicy));
     const leanBlock = buildLeanChangeBlock(input.leanLevel ?? 'full');
     if (leanBlock !== null)
         authoredSections.push(leanBlock);
@@ -1341,6 +1449,9 @@ export function buildSpawnPrompt(input) {
     }
     const authored = authoredSections.join('\n\n');
     const { resolved, unresolved } = resolvePromptTokens(authored, tokens);
+    if (input.workerPolicy) {
+        embeddedSections.push(buildProjectWorkerPolicyBlock(input.workerPolicy));
+    }
     const embedded = embeddedSections.join('\n\n');
     const finalPrompt = embedded ? `${resolved}\n\n${embedded}` : resolved;
     return {