peaks-loop 4.0.34 → 4.0.36

package/dist/cli/commands/memory-commands.js

@@ -1,20 +1,67 @@
 import { findProjectRoot } from '../../services/config/config-safety.js';
 import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
 import { loadMemoryIndex, searchMemory } from '../../services/memory/memory-search-service.js';
+import { executeMemoryReindex, VALID_PROJECT_MEMORY_KINDS } from '../../services/memory/project-memory-service.js';
+import { boundedNames, fitSummaryToBytes } from '../../services/context/summary-view.js';
+import { executeMemoryIngest } from '../../services/memory/memory-ingest-service.js';
+import { executeMemoryRotate } from '../../services/memory/memory-rotate-service.js';
 import { pickFromList } from '../../services/fuzzy-matching/fzf-pick-service.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { getErrorMessage, printResult } from '../cli-helpers.js';
 import { join } from 'node:path';
-const VALID_KINDS = [
-    'project',
-    'rule',
-    'decision',
-    'reference',
-    'feedback',
-    'convention',
-    'module',
-    'lesson',
-];
+const VALID_KINDS = VALID_PROJECT_MEMORY_KINDS;
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
+ * `memory reindex`. The full report's arrays stay on disk / in the default
+ * envelope; this replaces them with `{count, names}` views (≤ 2 KB).
+ */
+export function buildMemoryReindexSummary(report) {
+    const view = {
+        view: 'summary',
+        apply: report.apply,
+        projectRoot: report.projectRoot,
+        memoryDir: report.memoryDir,
+        indexPath: report.indexPath,
+        memoryMdPath: report.memoryMdPath,
+        scannedFiles: report.scannedFiles,
+        indexed: report.indexed,
+        indexedByKind: report.indexedByKind,
+        unclassified: boundedNames(report.unclassified.map((u) => `${u.name}${u.rawKind === null ? '' : ` (${u.rawKind})`}`)),
+        nameConflicts: boundedNames(report.nameConflicts.map((c) => c.name)),
+        orphanIndex: boundedNames(report.orphanIndex.map((o) => o.name)),
+        orphanDisk: boundedNames(report.orphanDisk.map((p) => p.split(/[\\/]/).pop() ?? p)),
+        memoryMd: report.memoryMd,
+        writtenFiles: boundedNames(report.writtenFiles.map((p) => p.split(/[\\/]/).pop() ?? p)),
+    };
+    return fitSummaryToBytes(view);
+}
+/**
+ * Slice B: bounded view of `memory list`. `count` is the true total; `names`
+ * carries `name (kind)` labels for the first N entries.
+ */
+export function buildMemoryListSummary(data) {
+    const label = (e) => `${e.name} (${e.kind})`;
+    const view = {
+        view: 'summary',
+        indexPath: data.snapshot.indexPath,
+        version: data.snapshot.version,
+        updatedAt: data.snapshot.updatedAt,
+        total: data.entries.length,
+        kindFilter: data.kindFilter ?? null,
+        entries: boundedNames(data.entries.map(label)),
+    };
+    if (data.pickedOutputPath !== null) {
+        view.picked = boundedNames(data.pickedEntries.map(label));
+        view.pickedOutputPath = data.pickedOutputPath;
+        view.fzfVersion = data.fzfVersion;
+    }
+    return fitSummaryToBytes(view);
+}
+function resolveMemoryProjectRoot(project) {
+    return project !== undefined
+        ? resolveCanonicalProjectRoot(project)
+        : (findProjectRoot(process.cwd()) ?? process.cwd());
+}
 export async function runMemoryList(io, options) {
     const projectRoot = options.project !== undefined
         ? resolveCanonicalProjectRoot(options.project)
@@ -64,15 +111,28 @@ export async function runMemoryList(io, options) {
         if (entries.length === 0) {
             nextActions.push('No entries match; run `peaks memory extract` to build the index from memory/*.md files.');
         }
-        printResult(io, ok('memory.list', {
-            indexPath: snapshot.indexPath,
-            version: snapshot.version,
-            updatedAt: snapshot.updatedAt,
-            total: entries.length,
-            kindFilter: kindFilter ?? null,
-            entries,
-            ...(options.pick === true ? { picked: pickedEntries, pickedOutputPath, fzfVersion } : {})
-        }, warnings, nextActions), options.json);
+        // Slice B: `--summary` swaps the full entry array for a bounded
+        // `{count, names}` view. The default (no flag) envelope is byte-identical
+        // to before — the flag is strictly opt-in.
+        const data = options.summary === true
+            ? buildMemoryListSummary({
+                snapshot,
+                entries,
+                kindFilter,
+                pickedEntries,
+                pickedOutputPath,
+                fzfVersion,
+            })
+            : {
+                indexPath: snapshot.indexPath,
+                version: snapshot.version,
+                updatedAt: snapshot.updatedAt,
+                total: entries.length,
+                kindFilter: kindFilter ?? null,
+                entries,
+                ...(options.pick === true ? { picked: pickedEntries, pickedOutputPath, fzfVersion } : {})
+            };
+        printResult(io, ok('memory.list', data, warnings, nextActions), options.json);
     }
     catch (error) {
         const message = getErrorMessage(error);
@@ -124,3 +184,119 @@ export async function runMemorySearch(io, options) {
         process.exitCode = 1;
     }
 }
+/**
+ * `peaks memory reindex` — rebuild `.peaks/memory/index.json` from disk and
+ * regenerate `MEMORY.md`. Dry-run by default; `--apply` writes.
+ */
+export async function runMemoryReindex(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.reindex', 'INVALID_MEMORY_REINDEX_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview the drift report, or pass --apply to rebuild']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryReindex({ projectRoot, apply: options.apply === true });
+        const nextActions = [];
+        if (options.apply !== true) {
+            nextActions.push('Preview only — re-run with --apply to rebuild index.json and regenerate MEMORY.md.');
+        }
+        if (report.unclassified.length > 0) {
+            nextActions.push(`${report.unclassified.length} file(s) have no resolvable kind; add \`metadata.type\` (or \`kind:\`) to index them.`);
+        }
+        if (report.orphanIndex.length > 0) {
+            nextActions.push(`${report.orphanIndex.length} previous index entry(ies) point at missing files; they are dropped from the rebuilt index.`);
+        }
+        if (report.nameConflicts.length > 0) {
+            nextActions.push(`${report.nameConflicts.length} name collision(s) across files; both entries are kept — rename one file to disambiguate.`);
+        }
+        // Slice B: `--summary` keeps the scalar drift counts + names-of-first-N;
+        // the full report (with every unclassified/orphan path) stays available
+        // by omitting the flag. Default shape is unchanged.
+        const data = options.summary === true
+            ? buildMemoryReindexSummary(report)
+            : report;
+        printResult(io, ok('memory.reindex', data, [], nextActions), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_REINDEX_FAILED';
+        printResult(io, fail('memory.reindex', code, message, { projectRoot }, ['Check that the project has a readable .peaks/memory directory']), options.json);
+        process.exitCode = 1;
+    }
+}
+/**
+ * `peaks memory rotate` — tier-driven retention for `.peaks/memory/`.
+ * Implements the sediment pruning policy (tier 1: archive, never delete).
+ * Dry-run by default; `--apply` moves tier-C candidates into `archived/`.
+ */
+export async function runMemoryRotate(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.rotate', 'INVALID_MEMORY_ROTATE_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview the rotation plan, or pass --apply to archive tier-C candidates']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryRotate({ projectRoot, apply: options.apply === true });
+        const nextActions = [];
+        if (report.refused) {
+            nextActions.push(`Refused to apply: ${report.refusalReasons.join('; ')}`);
+        }
+        else if (options.apply !== true) {
+            nextActions.push('Preview only — re-run with --apply to move the tier-C candidates into archived/.');
+        }
+        if (report.excluded.length > 0) {
+            nextActions.push(`${report.excluded.length} candidate(s) excluded by a safety gate (see \`excluded\`).`);
+        }
+        const deleteCandidates = report.candidates.filter((candidate) => candidate.action === 'delete-candidate');
+        if (deleteCandidates.length > 0) {
+            nextActions.push(`${deleteCandidates.length} tier-D file(s) are delete-candidates only; peaks never deletes them — remove by hand if you are sure.`);
+        }
+        printResult(io, ok('memory.rotate', report, report.warnings, nextActions), options.json);
+        if (report.refused)
+            process.exitCode = 1;
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_ROTATE_FAILED';
+        printResult(io, fail('memory.rotate', code, message, { projectRoot }, ['Check that the project has a readable .peaks/memory directory']), options.json);
+        process.exitCode = 1;
+    }
+}
+/**
+ * `peaks memory ingest` — import memories written by the IDE-side agent into
+ * `.peaks/memory/`. The IDE-side source is read-only; dry-run by default.
+ */
+export async function runMemoryIngest(io, options) {
+    const projectRoot = resolveMemoryProjectRoot(options.project);
+    if (options.dryRun === true && options.apply === true) {
+        printResult(io, fail('memory.ingest', 'INVALID_MEMORY_INGEST_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview imports, or pass --apply to write them into .peaks/memory']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const report = executeMemoryIngest({
+            projectRoot,
+            ...(options.sourceDir !== undefined ? { sourceDir: options.sourceDir } : {}),
+            apply: options.apply === true
+        });
+        const nextActions = [];
+        if (options.apply !== true && report.imported.length > 0) {
+            nextActions.push('Preview only — re-run with --apply to write these memories into .peaks/memory.');
+        }
+        if (report.conflicts.length > 0) {
+            nextActions.push(`${report.conflicts.length} conflict(s) left both copies in place; resolve them by hand.`);
+        }
+        if (report.needsClassification.length > 0) {
+            nextActions.push(`${report.needsClassification.length} file(s) could not be classified; add \`metadata.type\` to the source before re-running.`);
+        }
+        printResult(io, ok('memory.ingest', report, report.warnings, nextActions), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        const code = error.code ?? 'MEMORY_INGEST_FAILED';
+        printResult(io, fail('memory.ingest', code, message, { projectRoot }, ['Check the --source-dir path and that .peaks/memory is writable']), options.json);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/request-commands.d.ts

@@ -1,3 +1,11 @@
 import { Command } from 'commander';
+import { type RequestArtifactSummary } from '../../services/artifacts/request-artifact-service.js';
 import { type ProgramIO } from '../cli-helpers.js';
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
+ * `request list`. `count` is the true total; `names` carries
+ * `role/requestId (state)` labels for the first N entries. The full `items`
+ * array (with paths + timestamps) is one flag away — omit `--summary`.
+ */
+export declare function buildRequestListSummary(items: readonly RequestArtifactSummary[]): Record<string, unknown>;
 export declare function registerRequestCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/request-commands.js

@@ -1,5 +1,6 @@
 import { InvalidArgumentError } from 'commander';
 import { createRequestArtifact, listRequestArtifacts, showRequestArtifact, transitionRequestArtifact, PrerequisitesNotSatisfiedError, LintGateError, TypeSanityViolationError, FileSizeViolationError, VALID_REQUEST_TYPES } from '../../services/artifacts/request-artifact-service.js';
+import { boundedNames, fitSummaryToBytes } from '../../services/context/summary-view.js';
 import { applyPerArtifactFormat, inferArtifactName, parseRequestType, parseRole, parseStateForRole, resolveDefaultFormat, VALID_ROLES, } from './request-format-helpers.js';
 import { ConfirmationRequiredError } from '../../services/mode/mode-enforcement.js';
 import { recordBypass, isBypassLimitReached, MAX_BYPASSES_PER_SESSION } from '../../services/mode/bypass-tracker.js';
@@ -9,6 +10,20 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { triggerBestPracticeScan } from '../../services/prd/best-practice-auto-trigger.js';
 import { refreshCodegraphAfterSlice, } from '../../services/codegraph/codegraph-autorefresh.js';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
+ * `request list`. `count` is the true total; `names` carries
+ * `role/requestId (state)` labels for the first N entries. The full `items`
+ * array (with paths + timestamps) is one flag away — omit `--summary`.
+ */
+export function buildRequestListSummary(items) {
+    const view = {
+        view: 'summary',
+        count: items.length,
+        items: boundedNames(items.map((i) => `${i.role}/${i.requestId} (${i.state})`)),
+    };
+    return fitSummaryToBytes(view);
+}
 export function registerRequestCommands(program, io) {
     const request = program.command('request').description('Manage per-request Peaks role artifacts (PRD / UI / RD / QA)');
     addJsonOption(request
@@ -87,7 +102,8 @@ export function registerRequestCommands(program, io) {
         .description('List per-request artifacts under a project workspace')
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <session>', 'limit to a specific session id')
-        .option('--role <role>', `limit to a single role (${VALID_ROLES.join(' | ')})`, parseRole)).action(async (options) => {
+        .option('--role <role>', `limit to a single role (${VALID_ROLES.join(' | ')})`, parseRole)
+        .option('--summary', 'emit counts + names-of-first-N only (≤ 2 KB) instead of the full item array; the default envelope is unchanged')).action(async (options) => {
         try {
             const listOptions = { projectRoot: options.project };
             if (options.sessionId !== undefined) {
@@ -97,7 +113,12 @@ export function registerRequestCommands(program, io) {
                 listOptions.role = options.role;
             }
             const items = await listRequestArtifacts(listOptions);
-            printResult(io, ok('request.list', { count: items.length, items }), options.json);
+            // Slice B: `--summary` is opt-in; the default `{count, items}` shape is
+            // byte-identical to before.
+            const data = options.summary === true
+                ? buildRequestListSummary(items)
+                : { count: items.length, items };
+            printResult(io, ok('request.list', data), options.json);
         }
         catch (error) {
             printResult(io, fail('request.list', 'REQUEST_LIST_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check project path before retrying']), options.json);

package/dist/cli/commands/sub-agent-commands.js

@@ -1,6 +1,7 @@
 import { registerDispatchCommand } from './dispatch-commands.js';
 import { registerHeartbeatCommand } from './heartbeat-commands.js';
 import { registerShareCommand, registerSharedReadCommand, registerAwaitCommand, registerFinalizeCommand } from './share-commands.js';
+import { registerWavePlanCommand } from './wave-plan-commands.js';
 // Re-export `validateRole` for backward compat — the integration test
 // suite and any external callers still import it from this entry file.
 // The canonical implementation now lives in `sub-agent-shared.ts`.
@@ -17,4 +18,5 @@ export function registerSubAgentCommands(program, io) {
     registerSharedReadCommand(subAgent, io);
     registerAwaitCommand(subAgent, io);
     registerFinalizeCommand(subAgent, io); // D21
+    registerWavePlanCommand(subAgent, io); // §3 file-overlap wave planner
 }

package/dist/cli/commands/wave-plan-commands.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `peaks sub-agent wave-plan` — slice 2026-09-10-dispatch-token-and-swarm §3.
+ *
+ * Nested under the existing `sub-agent` verb (no new top-level verb, per the
+ * project-level rule that users never learn a new CLI surface; the LLM runs
+ * this on their behalf).
+ *
+ * Input: slice descriptors `{ slices: [{ id, files: [...] }] }` from a JSON
+ * file (`--slices <file>`) or inline (`--slices-json '<json>'`).
+ *
+ * Output: a machine-readable wave plan where every wave's slices have
+ * pairwise-disjoint file sets, plus the per-slice deferral reason naming the
+ * colliding file. The orchestrator uses this to fan out a level in parallel
+ * WITHOUT serializing on a shared file — the deferred slices simply run in
+ * the next wave.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export interface WavePlanOptions {
+    slices?: string;
+    slicesJson?: string;
+    json?: boolean;
+}
+export declare function registerWavePlanCommand(parent: Command, io: ProgramIO): void;

package/dist/cli/commands/wave-plan-commands.js

@@ -0,0 +1,93 @@
+import { readFileSync } from 'node:fs';
+import { getErrorMessage, ok, fail } from 'peaks-loop-shared/result';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { planFileOverlapWaves } from '../../services/dispatch/file-overlap-wave-planner.js';
+export function registerWavePlanCommand(parent, io) {
+    addJsonOption(parent
+        .command('wave-plan')
+        .description('§3 file-overlap-aware scheduling: read slice descriptors ' +
+        '({slices:[{id,files:[]}]}) and emit a wave plan where every wave is ' +
+        'pairwise file-disjoint. Overlapping slices are deferred to later ' +
+        'waves with the colliding file named. Machine-readable envelope; the ' +
+        'LLM runs this, users never type it.')
+        .option('--slices <file>', 'path to a JSON file: { "slices": [{ "id": "s1", "files": ["src/a.ts"] }] }')
+        .option('--slices-json <json>', 'inline JSON with the same shape as --slices')).action((options) => {
+        const asJson = options.json === true;
+        const source = typeof options.slicesJson === 'string' && options.slicesJson.length > 0
+            ? { text: options.slicesJson }
+            : typeof options.slices === 'string' && options.slices.length > 0
+                ? readSlicesFile(options.slices)
+                : null;
+        if (source === null) {
+            printResult(io, fail('sub-agent.wave-plan', 'MISSING_INPUT', 'pass --slices <file> or --slices-json <json>', { ok: false, waves: [] }, ['Provide slice descriptors as { "slices": [{ "id": "s1", "files": ["src/a.ts"] }] }.']), asJson);
+            process.exitCode = 1;
+            return;
+        }
+        if (source.error !== undefined) {
+            printResult(io, fail('sub-agent.wave-plan', 'INVALID_INPUT', source.error, { ok: false, waves: [] }, ['Check the JSON shape: { "slices": [{ "id": string, "files": string[] }] }.']), asJson);
+            process.exitCode = 1;
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(source.text);
+        }
+        catch (err) {
+            printResult(io, fail('sub-agent.wave-plan', 'INVALID_JSON', `input is not valid JSON: ${getErrorMessage(err)}`, { ok: false, waves: [] }, ['Fix the JSON syntax and re-run.']), asJson);
+            process.exitCode = 1;
+            return;
+        }
+        const descriptors = coerceDescriptors(parsed);
+        if (descriptors === null) {
+            printResult(io, fail('sub-agent.wave-plan', 'INVALID_SHAPE', 'expected { "slices": [{ "id": string, "files": string[] }] }', { ok: false, waves: [] }, ['Each entry needs a non-empty string id and an array of file paths.']), asJson);
+            process.exitCode = 1;
+            return;
+        }
+        const plan = planFileOverlapWaves(descriptors);
+        const warnings = plan.duplicateIds.length > 0
+            ? [`DUPLICATE_SLICE_IDS: ${plan.duplicateIds.join(', ')} (first descriptor wins; the rest were not scheduled)`]
+            : [];
+        printResult(io, ok('sub-agent.wave-plan', {
+            envelopeVersion: '2.1.0',
+            ok: true,
+            sliceCount: plan.sliceCount,
+            waveCount: plan.waves.length,
+            waves: plan.waves,
+            duplicateIds: plan.duplicateIds,
+            maxParallelism: plan.waves.reduce((max, w) => Math.max(max, w.slices.length), 0)
+        }, warnings, [
+            plan.waves.length <= 1
+                ? 'All slices are file-disjoint: dispatch them in a single wave.'
+                : `Dispatch wave 0 first, then each later wave after its predecessors finish; the deferred[] entries name the blocking file.`
+        ]), asJson);
+    });
+}
+function readSlicesFile(path) {
+    try {
+        return { text: readFileSync(path, 'utf8') };
+    }
+    catch (err) {
+        return { text: '', error: `cannot read --slices file ${path}: ${getErrorMessage(err)}` };
+    }
+}
+function coerceDescriptors(parsed) {
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const raw = parsed.slices;
+    if (!Array.isArray(raw))
+        return null;
+    const out = [];
+    for (const item of raw) {
+        if (item === null || typeof item !== 'object' || Array.isArray(item))
+            return null;
+        const id = item.id;
+        const files = item.files;
+        if (typeof id !== 'string' || id.length === 0)
+            return null;
+        if (files !== undefined && (!Array.isArray(files) || files.some((f) => typeof f !== 'string'))) {
+            return null;
+        }
+        out.push({ id, files: files ?? [] });
+    }
+    return out;
+}

package/dist/services/context/build-dispatch-system-prompt.d.ts

@@ -68,6 +68,22 @@ export interface DispatchPromptInput {
      *   and before the memory/task content.
      */
     freshContextBlock?: string | null;
+    /**
+     * Slice 2026-09-10-dispatch-token-and-swarm §4: session capsule
+     * published by the orchestrator through `peaks sub-agent share`.
+     *
+     * - `undefined` / `null` → no capsule pointer, no precedence line
+     *   (byte-identical legacy prompt).
+     * - `{ batchId, key, bytes }` → a `shared-read` pointer plus the
+     *   mandatory precedence line: the capsule is ADVISORY BACKGROUND only
+     *   and the task spec wins on conflict. Nothing the sub-agent must act
+     *   on may live only in the capsule.
+     */
+    capsule?: {
+        readonly batchId: string;
+        readonly key: string;
+        readonly bytes: number;
+    } | null;
 }
 /**
  * Slice 2026-07-29-worktree-l1: Layer 1 of the 3-layer worktree governance
@@ -91,7 +107,7 @@ export interface DispatchPromptInput {
  * fallback path is `peaks worktree auth grant --rid <id> --reason <text>
  * --ttl <5m>` (already shipped). Update the prose once `spawn` lands.
  */
-export declare const L1_WORKTREE_GOVERNANCE_BLOCK = "## Superpowers chain refusal (L1 worktree governance \u2014 locked 2026-07-29)\n\nYou MUST NOT follow the superpowers chain for worktree decisions:\n\n- superpowers:brainstorming \u2192 superpowers:writing-plans \u2192\n  superpowers:subagent-driven-development \u2192 superpowers:using-git-worktrees\n\nThis chain ends with `git worktree add` (superpowers:using-git-worktrees SKILL.md line 96). It bypasses peaks-loop's L2 hook gate and L3 IDE `permissions.deny`. Even when L3 denies the terminal Skill, the chain has already taught you to use raw `git worktree add`, so L3 is not sufficient.\n\nFor worktree operations, use ONLY:\n\n- `peaks worktree spawn --rid <rid> --ttl <duration> --purpose <text>` (after rid-L2-extended ships)\n- until then: `peaks worktree auth grant --rid <id> --reason <text> --ttl <5m>`\n\nThe superpowers skills remain available as REFERENCE material for brainstorming / planning techniques, but MUST NOT be used as a workflow. peaks-rd's own PRD/RD artifacts (`.peaks/_runtime/<sessionId>/rd/requests/<rid>.md`) are authoritative.\n\nIf the upstream superpowers chain suggests raw `git worktree add`:\n\n1. STOP\n2. Re-author the plan as a peaks-rd artifact\n3. Continue with `peaks worktree spawn` (or the auth-grant fallback)\n";
+export declare const L1_WORKTREE_GOVERNANCE_BLOCK = "## Superpowers chain refusal (L1 worktree governance \u2014 locked 2026-07-29)\n\nYou MUST NOT follow the superpowers chain for worktree decisions:\n\n- superpowers:brainstorming \u2192 superpowers:writing-plans \u2192\n  superpowers:subagent-driven-development \u2192 superpowers:using-git-worktrees\n\nThat chain ends with `git worktree add` (superpowers:using-git-worktrees SKILL.md line 96), which bypasses peaks-loop's L2 hook gate and L3 IDE `permissions.deny`. L3 denial is NOT sufficient \u2014 by then the chain has already taught raw `git worktree add`.\n\nFor worktree operations, use ONLY:\n\n- `peaks worktree spawn --rid <rid> --ttl <duration> --purpose <text>` (after rid-L2-extended ships)\n- until then: `peaks worktree auth grant --rid <id> --reason <text> --ttl <5m>`\n\nSuperpowers skills remain REFERENCE material for brainstorming / planning techniques, but MUST NOT be used as a workflow. peaks-rd's own PRD/RD artifacts (`.peaks/_runtime/<sessionId>/rd/requests/<rid>.md`) are authoritative.\n\nIf the upstream superpowers chain suggests raw `git worktree add`:\n\n1. STOP\n2. Re-author the plan as a peaks-rd artifact\n3. Continue with `peaks worktree spawn` (or the auth-grant fallback)\n";
 /**
  * Slice 2026-08-01-subagent-merge-and-e2e (Task 8): the dispatch
  * system prompt gains three lifecycle rules. The sub-agent must:
@@ -117,17 +133,38 @@ export declare const L1_WORKTREE_GOVERNANCE_BLOCK = "## Superpowers chain refusa
  * start, maximizing Anthropic prompt-cache prefix reuse (stable-first
  * ordering).
  */
-export declare const LIFECYCLE_RULES = "## Sub-agent lifecycle rules (locked 2026-08-01)\n\n- If you start a long-lived local service (vite dev, mock API, docker container, etc.), register it with `peaks sub-agent shutdown register --pid <pid> --name <label>` before you exit. The parent session will best-effort-kill it before merge-back.\n- Do NOT run E2E. The parent session runs Playwright verification once after merge-back (Task 10). Your E2E work is duplicate effort.\n- Do NOT call `git merge`, `git pull`, `git rebase`, or `peaks worktree release`. The parent session owns the merge-back step.\n";
+export declare const LIFECYCLE_RULES = "## Sub-agent lifecycle rules (locked 2026-08-01)\n\n- If you start a long-lived local service (vite dev, mock API, docker container, etc.), register it with `peaks sub-agent shutdown register --pid <pid> --name <label>` before you exit; the parent session best-effort-kills it before merge-back.\n- Do NOT run E2E. The parent session runs Playwright verification once after merge-back (Task 10); your E2E work is duplicate effort.\n- Do NOT call `git merge`, `git pull`, `git rebase`, or `peaks worktree release`. The parent session owns the merge-back step.\n";
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice C): cap the sub-agent's
+ * FINAL report.
+ *
+ * Why (measured, session 2026-09-07-session-245530): 20 sub-agent final
+ * reports cost ≈ 60 KB ≈ 15K tokens of the ORCHESTRATOR's window in one
+ * session — the reports, not the dispatch boilerplate, were the second-largest
+ * consumer. The sub-agent already writes a full artifact to disk; the report
+ * only needs to be the index into it.
+ *
+ * QUALITY GUARD (binding): the cap removes no information. Everything the
+ * parent needs to ACT on stays in the report; everything longer lives in the
+ * artifact the parent can `Read`. The five mandatory fields below are exactly
+ * the ones the orchestrator must have to decide the next gate.
+ */
+export declare const REPORT_CAP_BLOCK = "## Final report cap (mandatory)\n\nYour FINAL report to the parent MUST be \u2264 40 lines and \u2264 2 KB. Write any longer detail into the artifact file you already own \u2014 the parent can `Read` that file for the full detail, so nothing is lost. The report itself MUST still carry: changed files (one line each), the exact commands you ran, pass/fail counts, tsc status, and any blocker. Do NOT paste file contents, full tool output, or logs into the report.\n";
 /**
- * Compose the system-prompt body that the dispatch site prepends to
- * `formatTestToolDetection()\n\n`.
+ * Compose the system-prompt body for a sub-agent dispatch.
+ *
+ * 2026-09-10-dispatch-block-d (Option D): the composer owns the Test Tool
+ * Detection injection — ONE unified block for every role, prepended first.
+ * Callers MUST NOT prepend `formatTestToolDetection()` themselves or the
+ * block is injected twice.
  *
  * Byte-identical degradation contract (slice 2026-07-22-orchestrator-memory-preflight
- * controller brief): when the memory block is unavailable, the caller does
- * `formatTestToolDetection()\n\n${taskBody}` — i.e. the final prompt is exactly
- * `${formatTestToolDetection()}\n\n${taskBody}`. Today's pre-change behavior
- * produced the same string from `src/cli/commands/dispatch-commands.ts:220`,
- * so the unavailable branch MUST return `taskBody` (NOT a `# title\n\n` wrap).
+ * controller brief): when the memory block is unavailable, the composed body is
+ * exactly `formatTestToolDetection() + "\n\n" + L1 + "\n" + LIFECYCLE +
+ * "\n" + REPORT_CAP + "\n" + contextBlock + taskBody`, so the unavailable
+ * branch MUST return `taskBody` unwrapped (NOT a `# title\n\n` wrap).
+ * (REPORT_CAP joined the stable prefix in slice
+ * 2026-09-10-context-audit-and-discipline, Slice C.)
  * The contract holds for callers that do not pass `codegraphBlock` (all
  * non-RD roles). Slice 2026-09-03-codegraph-preread deliberately inserts a
  * codegraph structure block (or its fail-soft unavailable note) for RD
@@ -151,3 +188,23 @@ export declare function buildDispatchSystemPrompt(input: DispatchPromptInput): s
  * byte-stable and trivially testable.
  */
 export declare const CODEGRAPH_UNAVAILABLE_BLOCK = "## Codegraph structure\n\ncodegraph unavailable \u2014 proceeding on project-scan only.\n";
+/** Binding phrases every dispatch prompt must contain, for every role. */
+export declare const BINDING_RULE_TOKENS: readonly string[];
+/**
+ * The runner-direct-path tokens: the refusal example, the two direct paths
+ * the block names (`peaks test --json` to introspect; PB-5, the repo-defined
+ * `test` / `test:*` scripts that are NOT gated), and the two pieces of
+ * quality guidance that must survive any compression — never assume a
+ * runner without asking the user as a last resort, and prefer
+ * `peaks test <file>` because it resolves the local binary Windows-aware.
+ *
+ * 2026-09-10-dispatch-block-d (Option D): there is no role split any more,
+ * so this set is asserted IDENTICALLY for every role. The runner EXAMPLES
+ * were removed as part of the unification — they were never rules.
+ */
+export declare const TEST_RUNNER_RULE_TOKENS: readonly string[];
+/**
+ * Return the subset of `tokens` that `text` does NOT contain. Pure; used by
+ * the rule-presence guard and usable by any future prompt self-check.
+ */
+export declare function missingRuleTokens(text: string, tokens: readonly string[]): readonly string[];