peaks-loop 4.0.35 → 4.0.37

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/hooks-commands.js

@@ -300,6 +300,12 @@ export function registerHooksCommands(program, io) {
             // install left behind.
             const settingsPath = status.settingsPath;
             const settings = existsSync(settingsPath) ? readJsonObjectFile(settingsPath) : {};
+            // The gate-enforce entry is materialized into the machine-local
+            // settings file (see `resolveHookTargets`), so the on-disk entry list
+            // must be read from both files or `status` would report it missing.
+            const localSettings = status.localSettingsPath !== undefined && existsSync(status.localSettingsPath)
+                ? readJsonObjectFile(status.localSettingsPath)
+                : {};
             // Slice 2026-07-29-worktree-layer3-deny: report the Layer 3 deny
             // entries actually on disk. We read the existing settings.json
             // (above) and surface its `permissions.deny` block. Any entry
@@ -311,7 +317,10 @@ export function registerHooksCommands(program, io) {
             printResult(io, ok('hooks.status', {
                 ...status,
                 ide,
-                entries: readInstalledEntriesFromSettings(settings, ide),
+                entries: [
+                    ...readInstalledEntriesFromSettings(settings, ide),
+                    ...readInstalledEntriesFromSettings(localSettings, ide)
+                ],
                 permissionsDenyEntries: listSuperpowersDenyEntries(),
                 permissionsDenyOnDisk: onDiskDeny
             }), options.json);

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

@@ -1,4 +1,5 @@
 // src/cli/commands/job-commands.ts
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { Command } from 'commander';
 import { fail, ok } from 'peaks-loop-shared/result';
@@ -18,6 +19,30 @@ function projectRoot(opts) {
     // Reuse the workspace root resolver from peaks CLI; for now, CWD as a safe placeholder.
     return opts.project ?? process.cwd();
 }
+/**
+ * D6: every job subcommand resolves a job root, so every one of them must be
+ * able to name the session that holds the job. Same precedence as the rest of
+ * the CLI (`peaks sub-agent dispatch`, `peaks web *`, `peaks share *`), except
+ * that job state has no "unknown-sid" location to land in — an unresolvable
+ * session is an error, not a silent fallback.
+ */
+const SESSION_ID_HELP = 'session id (default: resolve from .peaks/_runtime/session.json; falls back to PEAKS_SESSION_ID env var; final fallback: NO_ACTIVE_SESSION error)';
+/**
+ * The session (a direct child of `<project>/.peaks/_runtime/`) that holds
+ * `jobId`, or null. Only used to explain a miss: a job that lives in another
+ * session must be reported by name so the caller can re-run with --session-id.
+ */
+function findSessionHoldingJob(project, jobId) {
+    const runtimeDir = join(project, '.peaks', '_runtime');
+    if (!existsSync(runtimeDir))
+        return null;
+    for (const entry of readdirSync(runtimeDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && existsSync(join(runtimeDir, entry.name, 'job', jobId, 'state.json'))) {
+            return entry.name;
+        }
+    }
+    return null;
+}
 /**
  * Resolves the on-disk root for Job state files.
  *
@@ -27,20 +52,50 @@ function projectRoot(opts) {
  * The `JobStateStore` itself only knows its `rootDir` + `jobId` and joins them. We
  * compute the canonical root here (per-call) so the store can stay layout-agnostic.
  *
- * Resolution order:
+ * Resolution order (D6 — a job must stay addressable while the single per-project
+ * `.peaks/_runtime/session.json` binding points at another session):
  * 1. `--session-id` flag (explicit override)
- * 2. `getCurrentSessionId(project)` — reads `.peaks/_runtime/session.json` per peaks-code
- * 3. Error (NO_ACTIVE_SESSION) — must never silently fall back to a random uuid
+ * 2. `PEAKS_SESSION_ID` env var
+ * 3. `getCurrentSessionId(project)` — reads `.peaks/_runtime/session.json`
+ * 4. Error (NO_ACTIVE_SESSION) — must never silently fall back to a random uuid
+ *
+ * When `jobId` is passed and it is absent from the resolved session, the thrown
+ * error names the session that does hold it (if any), instead of leaving the
+ * caller with a bare "no state for <job> at <other-sid>" path.
  */
-function resolveJobStateRoot(opts) {
+function resolveJobStateRoot(opts, jobId) {
     const project = projectRoot(opts);
-    const sessionId = opts.sessionId ?? getCurrentSessionId(project);
+    const sessionId = opts.sessionId ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(project);
     if (!sessionId) {
         throw new Error('NO_ACTIVE_SESSION: peaks job requires --session-id or an active peaks-code session via peaks workspace init');
     }
     const rootDir = join(project, '.peaks', '_runtime', sessionId, 'job');
+    if (jobId && !existsSync(join(rootDir, jobId, 'state.json'))) {
+        const other = findSessionHoldingJob(project, jobId);
+        throw new Error(other
+            ? `JOB_NOT_IN_SESSION: no job "${jobId}" in session "${sessionId}"; it lives in session "${other}" — re-run with --session-id ${other}`
+            : `JOB_NOT_IN_SESSION: no job "${jobId}" in session "${sessionId}" (and no other session under .peaks/_runtime/ has it)`);
+    }
     return { rootDir, sessionId, projectRoot: project };
 }
+/**
+ * D7: slices are keyed `slice-NNN`, but `peaks job init --slice-list "S1,…"`
+ * takes labels, so the natural string to pass back to `--slice-id` is that same
+ * label. Resolve an exact sliceId OR an exact label to the canonical sliceId;
+ * anything else is a hard error listing the valid ids, so a mistyped
+ * `slice-04` can never be accepted as a silent no-op that leaves the slice
+ * pending.
+ */
+function resolveSliceId(store, jobId, sliceId) {
+    const slices = store.load(jobId).slices;
+    const hit = slices.find((sl) => sl.sliceId === sliceId || sl.label === sliceId);
+    if (hit)
+        return { sliceId: hit.sliceId };
+    return {
+        message: `no slice "${sliceId}" in job ${jobId}; valid ids: ${slices.map((sl) => `${sl.sliceId} (${sl.label})`).join(', ')}`,
+        validSliceIds: slices.map((sl) => sl.sliceId),
+    };
+}
 export function registerJobCommands(program, io = { stdout: (t) => process.stdout.write(t), stderr: (t) => process.stderr.write(t) }) {
     const job = new Command('job').description('Drive long multi-slice work as one Job (peaks-code Step 0.8+)');
     job
@@ -51,14 +106,14 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--exit-policy <strict|best-effort>', 'strict')
         .option('--main-loop-strategy <single|rotating>', 'rotating')
         .option('--rotate-every <n>', 'rotate every N slices (rotating mode)', '3')
-        .option('--session-id <sid>', 'session id (default: read from .peaks/_runtime/session.json; required to land in the 2.7.1 single-scope-axis layout)')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
         const project = projectRoot(opts);
-        // Resolve sessionId: explicit flag > canonical session binding > FAIL.
+        // Resolve sessionId: explicit flag > PEAKS_SESSION_ID > canonical session binding > FAIL.
         // Per spec §3.3, Job state lives at .peaks/_runtime/<sessionId>/job/<jobId>/state.json —
         // a random UUID would scatter state across dirs and break resume/auto-compact.
-        let sessionId = opts.sessionId ?? getCurrentSessionId(project);
+        let sessionId = opts.sessionId ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(project);
         if (!sessionId) {
             return printResult(io, fail('init', 'NO_ACTIVE_SESSION', 'peaks job init requires --session-id (or an active peaks-code session via peaks workspace init)', { project }, [
                 'Re-run with --session-id <sid>',
@@ -105,9 +160,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .requiredOption('--job-id <jid>')
         .option('--watch', 'poll every 3s')
         .option('--show-cost', 'overlay cost from peaks budget')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const orch = new JobOrchestrator(store);
         const s = orch.status(opts.jobId);
         if (opts.watch) {
@@ -134,9 +190,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
     // M4.2: wire rotate-now to JobRotation (session-rotate callbacks are stubs pending M6.5 batch-fix).
     job.command('rotate-now')
         .requiredOption('--job-id <jid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const rotation = new JobRotation(store, async (_jid) => { /* delegate to peaks session rotate — implementation wired in M6.5 batch-fix */ return { rotated: true }; }, async (jid) => ({ jobId: jid, cycle: 0 }));
         const r = await rotation.rotateNow(opts.jobId);
         printResult(io, ok('rotate-now', r), opts);
@@ -146,9 +203,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .requiredOption('--job-id <jid>')
         .requiredOption('--batch-id <bid>')
         .option('--force')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const wrapper = new SubAgentJobWrapper(new JobStateStore(resolveJobStateRoot(opts).rootDir), async () => ({ batchId: opts.batchId }));
+        const wrapper = new SubAgentJobWrapper(new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir), async () => ({ batchId: opts.batchId }));
         const r = await wrapper.cleanup({ jobId: opts.jobId, batchId: opts.batchId, force: !!opts.force });
         printResult(io, ok('subagent-cleanup', r), opts);
     });
@@ -161,6 +219,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .requiredOption('--state <done|failed|skipped>')
         .option('--commit-sha <sha>')
         .option('--reason <text>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
         const parsed = JobCheckpointInputSchema.safeParse({
@@ -170,15 +229,25 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         });
         if (!parsed.success)
             return printResult(io, fail('checkpoint', 'INVALID_CHECKPOINT', parsed.error.message, {}), opts);
-        const jobRoot = resolveJobStateRoot(opts);
+        const jobRoot = resolveJobStateRoot(opts, opts.jobId);
         const store = new JobStateStore(jobRoot.rootDir);
+        // D7: `--slice-id` accepts the canonical `slice-NNN` or the slice's label
+        // ("S1"); an id that matches no slice is rejected here, BEFORE any write,
+        // so progress.json is never touched by a checkpoint that matched nothing.
+        const slice = resolveSliceId(store, parsed.data.jobId, parsed.data.sliceId);
+        if ('message' in slice) {
+            return printResult(io, fail('checkpoint', 'SLICE_NOT_FOUND', slice.message, {
+                jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, validSliceIds: slice.validSliceIds,
+            }, ['Re-run with one of the valid slice ids']), opts);
+        }
+        const sliceId = slice.sliceId;
         const orch = new JobOrchestrator(store);
         // 2026-09-03-codegraph-autorefresh: set on --state done so the ok
         // envelope carries a non-blocking `codegraph` result; null for
         // failed/skipped (no slice-complete boundary).
         let codegraph = null;
         if (parsed.data.state === 'done') {
-            await orch.checkpointDone({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, ...(parsed.data.commitSha ? { commitSha: parsed.data.commitSha } : {}) });
+            await orch.checkpointDone({ jobId: parsed.data.jobId, sliceId, ...(parsed.data.commitSha ? { commitSha: parsed.data.commitSha } : {}) });
             // v3.1.2: after each --state done, mirror slice progress to
             // .peaks/_runtime/<sessionId>/job/<jid>/progress.json so the
             // next LLM turn (or peaks code gate-step-08 hook) can read it.
@@ -203,12 +272,12 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
             }
         }
         else if (parsed.data.state === 'skipped') {
-            await orch.checkpointSkipped({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, reason: parsed.data.reason });
+            await orch.checkpointSkipped({ jobId: parsed.data.jobId, sliceId, reason: parsed.data.reason });
         }
         else {
-            await orch.checkpointFailed({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, reason: parsed.data.reason });
+            await orch.checkpointFailed({ jobId: parsed.data.jobId, sliceId, reason: parsed.data.reason });
         }
-        printResult(io, ok('checkpoint', { sliceId: parsed.data.sliceId, status: parsed.data.state, codegraph }), opts);
+        printResult(io, ok('checkpoint', { sliceId, status: parsed.data.state, codegraph }), opts);
     });
     addJsonOption(job.commands.find(c => c.name() === 'checkpoint'));
     job
@@ -216,6 +285,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .requiredOption('--job-id <jid>')
         .requiredOption('--slice-id <rid>')
         .requiredOption('--reason <text>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
         const parsed = JobBlockInputSchema.safeParse({
@@ -224,18 +294,27 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         });
         if (!parsed.success)
             return printResult(io, fail('block', 'INVALID_BLOCK', parsed.error.message, {}), opts);
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
+        // D7 (same silent no-op as checkpoint): resolve label → sliceId, reject a
+        // miss before any write.
+        const slice = resolveSliceId(store, parsed.data.jobId, parsed.data.sliceId);
+        if ('message' in slice) {
+            return printResult(io, fail('block', 'SLICE_NOT_FOUND', slice.message, {
+                jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, validSliceIds: slice.validSliceIds,
+            }, ['Re-run with one of the valid slice ids']), opts);
+        }
         const orch = new JobOrchestrator(store);
-        await orch.blockSlice(parsed.data);
-        printResult(io, ok('block', { blocked: parsed.data.sliceId, reason: parsed.data.reason }), opts);
+        await orch.blockSlice({ ...parsed.data, sliceId: slice.sliceId });
+        printResult(io, ok('block', { blocked: slice.sliceId, reason: parsed.data.reason }), opts);
     });
     addJsonOption(job.commands.find(c => c.name() === 'block'));
     job
         .command('continue')
         .requiredOption('--job-id <jid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const orch = new JobOrchestrator(store);
         const r = orch.continueNow(opts.jobId);
         printResult(io, ok('continue', r), opts);
@@ -244,9 +323,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
     job
         .command('resume')
         .requiredOption('--job-id <jid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const orch = new JobOrchestrator(store);
         const s = orch.status(opts.jobId);
         printResult(io, ok('resume', { resumed: opts.jobId, ...s }), opts);
@@ -261,11 +341,12 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .description('v3.1.2: read the on-disk slice progress mirror (.peaks/_runtime/<sid>/job/<jid>/progress.json). ' +
         'Returns { jobId, done, total, currentSlice, lastCommitSha, updatedAt }.')
         .requiredOption('--job-id <jid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .option('--allow-missing', 'return done=0/total=0 envelope instead of failing when progress.json is absent')
         .action(async (opts) => {
         try {
-            const jobRoot = resolveJobStateRoot(opts);
+            const jobRoot = resolveJobStateRoot(opts, opts.jobId);
             const sessId = jobRoot.sessionId;
             const project = projectRoot(opts);
             const progress = opts.allowMissing === true
@@ -292,9 +373,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
     job
         .command('handoff')
         .requiredOption('--job-id <jid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
         .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
+        const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const orch = new JobOrchestrator(store);
         const s = orch.status(opts.jobId);
         printResult(io, ok('handoff', { handoffFor: opts.jobId, ...s }), opts);
@@ -305,10 +387,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .description('Read the slice\'s rd/karpathy-review.md and decide whether to downgrade a block gateAction to warn (slice 2026-07-30-karpathy-cost-self-review).')
         .requiredOption('--review-file <path>', 'path to rd/karpathy-review.md (or its .json sibling if the file is JSON)')
         .option('--project <repo>')
-        .option('--session-id <sid>')
+        .option('--session-id <sid>', SESSION_ID_HELP)
         .action(async (opts) => {
         const project = projectRoot(opts);
-        const sessionId = opts.sessionId ?? getCurrentSessionId(project);
+        const sessionId = opts.sessionId ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(project);
         if (!sessionId) {
             return printResult(io, fail('karpathy-cost-check', 'NO_ACTIVE_SESSION', 'karpathy-cost-check requires --session-id (or an active peaks-code session)', { project }, [
                 'Re-run with --session-id <sid>',

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/scan-commands.js

@@ -198,7 +198,7 @@ export function registerScanCommands(program, io) {
     });
     addJsonOption(scan
         .command('file-size')
-        .description('Check git diff for files exceeding a line count threshold (karpathy-skills "Simplicity First")')
+        .description('Check git diff for files exceeding a line count threshold (karpathy-skills "Simplicity First"; tool output, lockfiles and append-only records such as CHANGELOG.md excluded)')
         .requiredOption('--project <path>', 'target project root')
         .option('--base-ref <ref>', 'compare working tree against this git ref (default: HEAD)')
         .option('--threshold <n>', `line count threshold (default: ${DEFAULT_FILE_SIZE_THRESHOLD})`)).action((options) => {