peaks-loop 4.0.35 → 4.0.36

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 4.0.36 — 2026-09-10 (派发提示词瘦身 + 波次调度 + 编排器上下文审计)
+
+**Highlights**:
+
+1. **派发提示词瘦身（不牺牲规则）** — 每次派发的提示词里约 52% 是 CLI 注入的重复 boilerplate。本轮压缩 L1/生命周期/上下文探测段，并把 test-tool 块统一为一份（去掉 vitest/jest/mocha 举例，保留全部操作性规则，补上只存在于完整块里的 PB-5 例外规则）。7 个角色现在**字节完全一致**：rd/qa/qa-business/sc/prd **3897 → 3191 B（−18.1%）**。绑定规则 **21/21**、runner 规则 **5/5** 全角色断言。
+   - 契约指针实验**已回退**——它每次多 165 B 却不减任何内容，净亏。
+
+2. **文件重叠感知的波次调度** — 新 planner 按切面文件集计算波次：同一波内文件两两不重叠，重叠的推迟到后续波并**注明被哪个文件挡住**；附加式接入 `--from-dag`（`firstLevelWaves`），不改原调度语义。
+
+3. **编排器上下文审计 + 纪律** — 新增 `peaks code context-audit`：读会话 transcript 按 (工具, 命令) 汇总上下文消耗 Top-N。本仓库实测 **779 KB / 586 组**，且 Top-5 仅占 ~15%——**是长尾，不是单一元凶**。
+   - `--summary` 用于 memory reindex/list、doctor、request list：envelope **9.4–59 KB → 1.7–1.9 KB**（−79% ~ −97%），默认 `--json` 形状字节不变。
+   - SKILL.md 绑定规则：单次工具输出 >2 KB 禁止直接灌入编排器上下文。
+   - 子代理最终报告封顶 **≤40 行 / 2 KB**（5 个必填字段，细节写 artifact），已纳入 `BINDING_RULE_TOKENS`。
+
+**验证**：build clean、tsc clean、全量 141 files / 1270 passed（1 skipped）。
+
 ## 4.0.35 — 2026-09-10 (记忆系统 overhaul — 写入合一 / 索引重建 / 按任务调取 / 漂移健康检查 / rotate)
 
 **Highlights**:

package/dist/cli/commands/code-runtime-commands.d.ts

@@ -1,10 +1,13 @@
 /**
  * Slice rid-024 — runtime probes: post-compact-detect / auto-compact /
- * context-now / gate-step-08 / emit-handoff.
+ * context-now / context-audit / gate-step-08 / emit-handoff.
  *
  * Extracted from code-commands.ts (rid-024 split).
- * Owns: 5 sub-commands that read or mutate runtime state.
+ * Owns: 6 sub-commands that read or mutate runtime state.
  * Owns the `readActiveSid` helper (only used by these runtime probes).
+ *
+ * Slice 2026-09-10-context-audit-and-discipline added `context-audit`
+ * (what fills the window, grouped by tool + short input key).
  */
 import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';

package/dist/cli/commands/code-runtime-commands.js

@@ -1,15 +1,19 @@
 /**
  * Slice rid-024 — runtime probes: post-compact-detect / auto-compact /
- * context-now / gate-step-08 / emit-handoff.
+ * context-now / context-audit / gate-step-08 / emit-handoff.
  *
  * Extracted from code-commands.ts (rid-024 split).
- * Owns: 5 sub-commands that read or mutate runtime state.
+ * Owns: 6 sub-commands that read or mutate runtime state.
  * Owns the `readActiveSid` helper (only used by these runtime probes).
+ *
+ * Slice 2026-09-10-context-audit-and-discipline added `context-audit`
+ * (what fills the window, grouped by tool + short input key).
  */
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 import { detectPostCompactResume, formatPostCompactResumeLogLine } from '../../services/code/post-compact-detector.js';
 import { runAutoCompact } from '../../services/code/auto-compact-orchestrator.js';
+import { auditContext } from '../../services/context/context-audit.js';
 import { evaluateStep08, STEP_08_BACKUP_REGEX } from '../../services/code/step-08-gate.js';
 import { evaluateEmitHandoff, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/code/emit-handoff.js';
 import { readJobShapeDecision, JobShapeDecisionError } from '../../services/code/job-shape-decision.js';
@@ -254,6 +258,57 @@ export function registerCodeRuntimeCommands(code, io) {
             process.exitCode = 1;
         }
     });
+    // Slice 2026-09-10-context-audit-and-discipline (Slice A): visibility into
+    // WHAT fills the orchestrator window. `context-now` returns a ratio; this
+    // returns the grouped byte breakdown of tool results from the live
+    // transcript. Read-only + fail-soft: an unavailable transcript reports
+    // `available:false` with a reason and NEVER sets a non-zero exit code.
+    addJsonOption(code
+        .command('context-audit')
+        .description('Slice 2026-09-10 Slice A: report what fills the current session\'s ' +
+        'context window, grouped by tool + short input key (command line / ' +
+        'path tail / pattern), sorted by bytes. Locates the CURRENT session\'s ' +
+        'IDE transcript through the active adapter\'s ' +
+        '`compact.resolveTranscriptPath` (vendor-neutral); emits total bytes, ' +
+        'entry count, and the top-N groups ' +
+        '(`{tool, key, bytes, pctOfTotal, count}`). Read-only and fail-soft — ' +
+        'a missing/oversized/corrupt transcript returns `available:false` ' +
+        'with a reason and never blocks. Never dumps tool result content.')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--top <n>', 'number of top entries to emit (default 15, max 100)', (value) => Number(value))
+        .option('--transcript <path>', 'override the transcript jsonl path (test seam)')).action((opts) => {
+        try {
+            // `resolveOuterSessionId` checks the env signal FIRST, so the peaks
+            // session id is only a fallback lookup key — mirror context-now's
+            // 'unknown' default so an unbound presence still resolves via env.
+            const sessionId = opts.sessionId ?? readActiveSid(opts.project) ?? 'unknown';
+            const outerSessionId = resolveOuterSessionId(opts.project, sessionId);
+            const result = auditContext({
+                outerSessionId: outerSessionId ?? null,
+                ...(opts.top !== undefined ? { topN: opts.top } : {}),
+                ...(opts.transcript !== undefined ? { transcriptPath: opts.transcript } : {}),
+            });
+            // Fail-soft contract: unavailability is DATA, not an error. The exit
+            // code stays 0 so a `context-audit` call can never block a workflow.
+            const nextActions = result.available
+                ? [`${result.entryCount} tool result(s) across ${result.groupCount} group(s); showing top ${result.entries.length}.`]
+                : [`context-audit unavailable: ${result.reason ?? 'unknown'} — continue without it (read-only probe).`];
+            printResult(io, ok('code.context-audit', { ...result }, [], nextActions), opts.json);
+        }
+        catch (err) {
+            printResult(io, ok('code.context-audit', {
+                available: false,
+                reason: `audit-failed: ${getErrorMessage(err)}`,
+                transcriptPath: null,
+                totalBytes: 0,
+                entryCount: 0,
+                groupCount: 0,
+                topN: 0,
+                entries: []
+            }, [], ['context-audit is a read-only probe; continue without it.']), opts.json);
+        }
+    });
     // v3.1.2 Step 0.8 — Mechanical PreToolUse gate.
     // Wire-installed by `peaks workspace init` (extends the existing hook
     // installer). Exit code is the load-bearing contract:

package/dist/cli/commands/core/doctor-command.d.ts

@@ -1,5 +1,13 @@
 import type { Command } from 'commander';
 import { type ProgramIO } from '../../cli-helpers.js';
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
+ * the doctor envelope. The `checks` array (one object per check, each with a
+ * full message) and the stale-binding instance list collapse to counts +
+ * names-of-first-N; the summary counters and log section are scalars and are
+ * kept verbatim. ≤ 2 KB by construction.
+ */
+export declare function buildDoctorSummary(data: Record<string, unknown>): Record<string, unknown>;
 export type BindingSource = 'canonical' | 'legacy';
 export type DoctorLogsSection = {
     logDir: string;

package/dist/cli/commands/core/doctor-command.js

@@ -4,6 +4,7 @@ import { findProjectRoot } from '../../../services/config/config-safety.js';
 import { loadSkillRegistry } from '../../../services/skills/skill-registry.js';
 import { planStatusLineInstall } from '../../../services/skills/statusline-settings-service.js';
 import { addJsonOption, printResult } from '../../cli-helpers.js';
+import { boundedNames, fitSummaryToBytes } from '../../../services/context/summary-view.js';
 import { fail, ok } from 'peaks-loop-shared/result';
 // slice-3b Option C: the doctor subpackage owns the check pipeline but
 // does NOT import cross-domain utils from the main package (avoids
@@ -38,6 +39,43 @@ function statusLineAlreadyInstalledForScope(scope, projectRoot) {
         return false;
     }
 }
+/**
+ * Slice 2026-09-10-context-audit-and-discipline (Slice B): bounded view of
+ * the doctor envelope. The `checks` array (one object per check, each with a
+ * full message) and the stale-binding instance list collapse to counts +
+ * names-of-first-N; the summary counters and log section are scalars and are
+ * kept verbatim. ≤ 2 KB by construction.
+ */
+export function buildDoctorSummary(data) {
+    const checks = Array.isArray(data.checks) ? data.checks : [];
+    const label = (c) => {
+        const id = typeof c.id === 'string' ? c.id : 'unknown';
+        if (c.ok === true)
+            return `ok ${id}`;
+        return `${c.severity === 'warning' ? 'warn' : 'FAIL'} ${id}`;
+    };
+    const failed = checks.filter((c) => c.ok === false);
+    const stale = typeof data.staleBinding === 'object' && data.staleBinding !== null
+        ? data.staleBinding
+        : null;
+    const view = {
+        view: 'summary',
+        summary: data.summary,
+        checks: boundedNames(checks.map(label)),
+        failed: boundedNames(failed.map((c) => `${typeof c.id === 'string' ? c.id : 'unknown'}: ${typeof c.message === 'string' ? c.message : ''}`)),
+    };
+    if (stale !== null) {
+        view.staleBinding = {
+            ttlMs: stale.ttlMs,
+            staleCount: stale.staleCount,
+            droppedCount: stale.droppedCount,
+            droppedSids: boundedNames(Array.isArray(stale.droppedSids) ? stale.droppedSids.map((s) => String(s)) : []),
+        };
+    }
+    if (data.logs !== undefined)
+        view.logs = data.logs;
+    return fitSummaryToBytes(view);
+}
 function doctorStatusLineInstalledProbe() {
     const projectRoot = findProjectRoot(process.cwd());
     // Check both scopes: a user may have installed the statusLine globally, which
@@ -136,7 +174,8 @@ export function registerDoctorCommand(program, io) {
         // scan) addressable for non-current projects. The doctor was
         // hardcoded to findProjectRoot(process.cwd()) which is the
         // wrong default for users inspecting a sibling project.
-        .option('--project <path>', 'target project root (defaults to git root or cwd)')).action(async (options) => {
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')
+        .option('--summary', 'JSON envelope only: emit check counts + names-of-first-N (≤ 2 KB) instead of the full checks/stale-binding arrays; the default envelope is unchanged')).action(async (options) => {
         // v2.18.2 cycle 2 (Q2 arbitration): --rebuild-binding and
         // --cleanup-stale BOTH mutate the binding file. Running them
         // together is ambiguous (rebuild rewrites callerIds; cleanup
@@ -209,9 +248,12 @@ export function registerDoctorCommand(program, io) {
             droppedCount: droppedStale.length,
             droppedSids: droppedStale
         };
-        const data = logsSection === null
+        const fullData = logsSection === null
             ? { ...report, staleBinding: staleBindingSection }
             : { ...report, logs: logsSection, staleBinding: staleBindingSection };
+        // Slice B: `--summary` is opt-in and affects the JSON envelope only (the
+        // human-readable path below already prints one line per check).
+        const data = options.summary === true ? buildDoctorSummary(fullData) : fullData;
         // Slice 2026-08-05-statusline-sid-only-marker-and-multi-binary-drift-guard
         // repair cycle: `report.summary.ok` already factors in the
         // severity-aware aggregation in `buildReport` (warnings do NOT

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

@@ -53,6 +53,7 @@ export function registerMemoryCommand(program, io) {
         .option('--kind <kind>', `filter by memory kind (one of: ${KIND_HELP})`)
         .option('--pick', 'spawn fzf for interactive multi-select (requires fzf >= 0.38); writes picked.json')
         .option('--fzf-bin <path>', 'override fzf binary path (default: fzf on PATH)', 'fzf')
+        .option('--summary', 'emit counts + names-of-first-N only (≤ 2 KB) instead of the full entry array; the default envelope is unchanged')
         .option('--project <path>', 'target project root (defaults to git root or cwd)')).action((options) => {
         void import('../memory-commands.js').then(({ runMemoryList }) => {
             void runMemoryList(io, {
@@ -60,6 +61,7 @@ export function registerMemoryCommand(program, io) {
                 ...(options.pick === true ? { pick: true } : {}),
                 ...(options.fzfBin ? { fzfBin: options.fzfBin } : {}),
                 ...(options.project !== undefined ? { project: options.project } : {}),
+                ...(options.summary === true ? { summary: true } : {}),
                 ...(options.json !== undefined ? { json: options.json } : {}),
             });
         }).catch((error) => {
@@ -79,12 +81,14 @@ export function registerMemoryCommand(program, io) {
         .description('Rebuild .peaks/memory/index.json from every memory file on disk and regenerate MEMORY.md; reports unclassified files and orphans both ways. Dry-run by default; pass --apply to write.')
         .option('--project <path>', 'target project root (defaults to git root or cwd)')
         .option('--dry-run', 'report drift without writing (default)')
-        .option('--apply', 'rebuild index.json and regenerate MEMORY.md')).action((options) => {
+        .option('--apply', 'rebuild index.json and regenerate MEMORY.md')
+        .option('--summary', 'emit drift counts + names-of-first-N only (≤ 2 KB) instead of the full arrays; the default envelope is unchanged')).action((options) => {
         void import('../memory-commands.js').then(({ runMemoryReindex }) => {
             void runMemoryReindex(io, {
                 ...(options.project !== undefined ? { project: options.project } : {}),
                 ...(options.dryRun === true ? { dryRun: true } : {}),
                 ...(options.apply === true ? { apply: true } : {}),
+                ...(options.summary === true ? { summary: true } : {}),
                 ...(options.json !== undefined ? { json: options.json } : {}),
             });
         }).catch((error) => {

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

@@ -35,9 +35,10 @@ import { DEFAULT_PREFERENCES } from '../../services/preferences/preferences-type
 import { writeLogEntry } from '../../services/log/logger.js';
 import { PROMPT_LIMIT_BYTES, RECOMMENDED_ROLES, validateRole } from './sub-agent-shared.js';
 import { runDispatchFromDag } from './dispatch-from-dag.js';
-import { TEST_TOOL_DETECTION_BLOCK, formatTestToolDetection } from '../../services/dispatch/test-tool-detection.js';
+import { TEST_TOOL_DETECTION_BLOCK } from '../../services/dispatch/test-tool-detection.js';
 import { MemoryPreflightService, deriveMemoryQuery } from '../../services/context/memory-preflight-service.js';
 import { buildDispatchSystemPrompt } from '../../services/context/build-dispatch-system-prompt.js';
+import { readSessionCapsule } from '../../services/dispatch/session-capsule.js';
 import { computeUiLibraryDispatchBlock } from '../../services/standards/ui-library-dispatch-block.js';
 import { readFreshContextBlock } from '../../services/fresh-context/fresh-context-block.js';
 import { createDispatchProvenanceToken, DISPATCH_PROVENANCE_ENV, writeDispatchProvenance, } from '../../services/worktree/dispatch-provenance.js';
@@ -443,10 +444,17 @@ export function registerDispatchCommand(parent, io) {
                 // "no probe available" hint instead of failing the
                 // dispatch.
             }
+            // Slice 2026-09-10-dispatch-token-and-swarm §4: advisory background
+            // capsule published by the orchestrator via `peaks sub-agent share`.
+            // Absent capsule → no pointer and no precedence line (byte-identical
+            // legacy prompt).
+            const capsuleRef = readSessionCapsule({ projectRoot, sid, rid });
             const memoryAugmentedBody = buildDispatchSystemPrompt({
                 taskTitle: role,
                 taskBody: options.prompt,
                 memoryBlock,
+                // 2026-09-10-dispatch-block-d (Option D): the composer owns the ONE
+                // unified Test Tool Detection injection for every role.
                 contextProbe,
                 // exactOptionalPropertyTypes: only set codegraphBlock when the rd
                 // preflight actually produced a value (null = attempted-unavailable,
@@ -459,7 +467,11 @@ export function registerDispatchCommand(parent, io) {
                 // Same optionality contract for the fresh-context block: set only
                 // when the rd/prd read ran (null = no block on disk → no block,
                 // undefined = non-rd/prd role → legacy prompt unchanged).
-                ...(freshContextBlock !== undefined ? { freshContextBlock } : {})
+                ...(freshContextBlock !== undefined ? { freshContextBlock } : {}),
+                // §4: advisory session capsule pointer + precedence line.
+                ...(capsuleRef !== null
+                    ? { capsule: { batchId: capsuleRef.batchId, key: capsuleRef.key, bytes: capsuleRef.bytes } }
+                    : {})
             });
             // Part 2.C: when --isolation worktree, prepend an isolation envelope
             // block so the sub-agent sees the lease id + worktree path. The block
@@ -498,7 +510,7 @@ export function registerDispatchCommand(parent, io) {
                     `confirm the file exists. Anti-fake-green rule (sediment 2026-08-11-rid-001-redo-fake-green-recovery-closure §Lesson 1): ` +
                     `if the file does not exist, your verdict MUST be \`status: "blocked"\` with reason "must_ls_files_failed". Do NOT silently skip this step.\n`;
             }
-            const effectivePrompt = `${formatTestToolDetection()}\n\n${memoryAugmentedBody}${isolationBlock}${mustLsFilesBlock}`;
+            const effectivePrompt = `${memoryAugmentedBody}${isolationBlock}${mustLsFilesBlock}`;
             const warnings = [...decision.warnings];
             let toolCall;
             try {

package/dist/cli/commands/dispatch-from-dag.js

@@ -32,6 +32,7 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { detectInstalledIde } from '../../services/ide/ide-detector.js';
 import { getAdapter } from '../../services/ide/ide-registry.js';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
+import { planFileOverlapWaves } from '../../services/dispatch/file-overlap-wave-planner.js';
 export async function runDispatchFromDag(role, options, asJson, io) {
     if (!options.fromDag)
         return;
@@ -135,6 +136,19 @@ export async function runDispatchFromDag(role, options, asJson, io) {
     // end-to-end, but they are NOT surfaced in the CLI envelope (the LLM
     // sees them only after re-invoking with fresh level-1 contracts).
     const firstLevelIds = new Set(levelArr[0] ?? []);
+    // Slice 2026-09-10-dispatch-token-and-swarm §3: when EVERY first-level
+    // node declares `files`, refine the level into file-overlap waves so the
+    // LLM fans out without serializing on a shared file. Emitted additively
+    // in the envelope; the topological dispatch flow itself is unchanged.
+    // Nodes without `files` → `firstLevelWaves: null` (legacy envelope).
+    const firstLevelDescriptors = [...firstLevelIds].map((id) => ({
+        id,
+        files: dag.nodes.find((n) => n.id === id)?.files ?? []
+    }));
+    const firstLevelWaves = firstLevelDescriptors.length > 0
+        && firstLevelDescriptors.every((d) => d.files.length > 0)
+        ? planFileOverlapWaves(firstLevelDescriptors).waves
+        : null;
     const emittedToolCalls = [];
     const emittedSliceIds = [];
     // CLI runner: emit the per-slice `buildToolCall` envelope, then return
@@ -240,6 +254,9 @@ export async function runDispatchFromDag(role, options, asJson, io) {
         dispatchCount: emittedSliceIds.length,
         levelsTotal: levelArr.length,
         firstLevel: emittedSliceIds,
+        // §3: file-overlap wave plan for the first level (null when any
+        // first-level node omits `files`). Additive field.
+        firstLevelWaves,
         toolCalls: emittedToolCalls,
         existingContractCount: existingContracts.length,
         expectedCompletionSeconds: 60,

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

@@ -1,3 +1,5 @@
+import { type MemoryIndexEntry, type MemoryIndexSnapshot, type ProjectMemoryKind } from '../../services/memory/memory-search-service.js';
+import { type MemoryReindexReport } from '../../services/memory/project-memory-service.js';
 import { type ProgramIO } from '../cli-helpers.js';
 export interface MemorySearchCommandOptions {
     query: string;
@@ -12,13 +14,35 @@ export interface MemoryListCommandOptions {
     fzfBin?: string;
     project?: string;
     json?: boolean;
+    /** Slice B: emit counts + names-of-first-N instead of the full entry array. */
+    summary?: boolean;
 }
 export interface MemoryReindexCommandOptions {
     project?: string;
     dryRun?: boolean;
     apply?: boolean;
     json?: boolean;
+    /** Slice B: emit counts + names-of-first-N instead of the full arrays. */
+    summary?: boolean;
 }
+/**
+ * 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 declare function buildMemoryReindexSummary(report: MemoryReindexReport): Record<string, unknown>;
+/**
+ * Slice B: bounded view of `memory list`. `count` is the true total; `names`
+ * carries `name (kind)` labels for the first N entries.
+ */
+export declare function buildMemoryListSummary(data: {
+    snapshot: MemoryIndexSnapshot;
+    entries: readonly MemoryIndexEntry[];
+    kindFilter: ProjectMemoryKind | undefined;
+    pickedEntries: readonly MemoryIndexEntry[];
+    pickedOutputPath: string | null;
+    fzfVersion: string | null;
+}): Record<string, unknown>;
 export interface MemoryIngestCommandOptions {
     project?: string;
     sourceDir?: string;

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

@@ -2,6 +2,7 @@ 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';
@@ -9,6 +10,53 @@ import { fail, ok } from 'peaks-loop-shared/result';
 import { getErrorMessage, printResult } from '../cli-helpers.js';
 import { join } from 'node:path';
 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)
@@ -63,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);
@@ -149,7 +210,13 @@ export async function runMemoryReindex(io, options) {
         if (report.nameConflicts.length > 0) {
             nextActions.push(`${report.nameConflicts.length} name collision(s) across files; both entries are kept — rename one file to disambiguate.`);
         }
-        printResult(io, ok('memory.reindex', report, [], nextActions), options.json);
+        // 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);

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;