peaks-loop 4.0.54 → 4.1.1

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

@@ -7,15 +7,15 @@ import { addJsonOption, printResult } from '../cli-helpers.js';
 import { isUnsafePathInput } from '../../shared/path-safety.js';
 import { JobStateStore } from '../../services/job/job-state-store.js';
 import { JobOrchestrator } from '../../services/job/job-orchestrator.js';
-import { writeJobProgress, readJobProgress, tryReadJobProgress } from '../../services/job/job-progress-store.js';
+import { writeJobProgress, readJobProgress, tryReadJobProgress, describeNextSlice } from '../../services/job/job-progress-store.js';
 import { JobRotation } from '../../services/job/job-rotation.js';
 import { SubAgentJobWrapper } from '../../services/job/subagent-job-wrapper.js';
 import { emitJobEvent } from '../../services/job/job-event-emitter.js';
-import { JobInitInputSchema, JobCheckpointInputSchema, JobBlockInputSchema, } from '../../services/job/job-types.js';
+import { JobInitInputSchema, JobCheckpointInputSchema, JobBlockInputSchema } from '../../services/job/job-types.js';
 import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-import { buildCostCheckEnvelope, runKarpathyCostCheck, } from '../../services/karpathy-cost/karpathy-cost-check-service.js';
+import { buildCostCheckEnvelope, runKarpathyCostCheck } from '../../services/karpathy-cost/karpathy-cost-check-service.js';
 import { read24hState } from '../../services/24h-mode/store.js';
-import { codegraphRefreshNotice, refreshCodegraphAfterSlice, } from '../../services/codegraph/codegraph-autorefresh.js';
+import { codegraphRefreshNotice, refreshCodegraphAfterSlice } from '../../services/codegraph/codegraph-autorefresh.js';
 // `printResult`'s third parameter is `asJson: boolean`. Each `job` subcommand
 // registers `--json` (see the `addJsonOption` calls below), so the flag to pass
 // it is `opts.json` — NEVER the whole options object. Commander types an
@@ -26,7 +26,13 @@ import { codegraphRefreshNotice, refreshCodegraphAfterSlice, } from '../../servi
 // envelope instead of on stderr as `warning: `. `job progress` always passed
 // `opts.json`; the rest of this file did not, and E1 (2026-09-17) brought them
 // in line. Do not reintroduce the object form.
-function asJson(opts) {
+//
+// S10 (2026-09-20): the parameter is now `JobJsonOpts` rather than `any`. The
+// gate above is about which VALUE is passed, not about the parameter's type —
+// declaring the one field this function reads is what stops every `opts.<x>`
+// call site in the file from being an `any` access. See the option-interface
+// block above `registerJobCommands`.
+export function asJson(opts) {
     return opts.json === true;
 }
 /**
@@ -71,7 +77,7 @@ function projectRoot(opts) {
  * 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)';
+export 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
@@ -82,7 +88,8 @@ function findSessionHoldingJob(project, jobId) {
     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'))) {
+        if (entry.isDirectory() &&
+            existsSync(join(runtimeDir, entry.name, 'job', jobId, 'state.json'))) {
             return entry.name;
         }
     }
@@ -109,7 +116,7 @@ function findSessionHoldingJob(project, jobId) {
  * 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, jobId) {
+export function resolveJobStateRoot(opts, jobId) {
     const project = projectRoot(opts);
     const sessionId = opts.sessionId ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(project);
     if (!sessionId) {
@@ -146,10 +153,13 @@ function resolveSliceId(store, jobId, sliceId) {
         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),
+        validSliceIds: slices.map((sl) => sl.sliceId)
     };
 }
-export function registerJobCommands(program, io = { stdout: (t) => process.stdout.write(t), stderr: (t) => process.stderr.write(t) }) {
+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
         .command('init')
@@ -161,7 +171,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--rotate-every <n>', 'rotate every N slices (rotating mode)', '3')
         .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
-        .action(async (opts) => {
+        .action((opts) => {
         const project = projectRoot(opts);
         // Resolve sessionId: explicit flag > PEAKS_SESSION_ID > caller-first session binding
         // (this caller's binding, else the project-global session.json) > FAIL.
@@ -177,13 +187,16 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         const parsed = JobInitInputSchema.safeParse({
             jobId: opts.jobId,
             sessionId,
-            sliceList: opts.sliceList.split(',').map((s) => s.trim()).filter(Boolean),
+            sliceList: opts.sliceList
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
             parallelismHint: opts.parallelismHint,
             exitPolicy: opts.exitPolicy,
             mainLoopStrategy: opts.mainLoopStrategy,
             rotateEvery: Number(opts.rotateEvery),
             project,
-            json: opts.json,
+            json: opts.json
         });
         if (!parsed.success)
             return failResult(io, fail('init', 'INVALID_INIT', parsed.error.message, {}), opts);
@@ -197,10 +210,15 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
             parallelismHint: parsed.data.parallelismHint,
             exitPolicy: parsed.data.exitPolicy,
             mainLoopStrategy: parsed.data.mainLoopStrategy,
-            rotateEvery: parsed.data.rotateEvery,
+            rotateEvery: parsed.data.rotateEvery
         });
         try {
-            emitJobEvent({ kind: 'job-started', jobId: state.jobId, total: state.slices.length, strategy: state.mainLoopStrategy });
+            emitJobEvent({
+                kind: 'job-started',
+                jobId: state.jobId,
+                total: state.slices.length,
+                strategy: state.mainLoopStrategy
+            });
         }
         catch (e) {
             // ADVISORY (F1, 2026-09-17) — deliberately exits 0. Event emission is a
@@ -210,9 +228,13 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
             // in tests/unit/cli/job-exit-code.test.ts.
             void e;
         }
-        printResult(io, ok('init', { jobId: state.jobId, sliceCount: state.slices.length, statePath: `${jobRoot.rootDir}/${state.jobId}/state.json` }), asJson(opts));
+        printResult(io, ok('init', {
+            jobId: state.jobId,
+            sliceCount: state.slices.length,
+            statePath: `${jobRoot.rootDir}/${state.jobId}/state.json`
+        }), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'init'));
+    addJsonOption(job.commands.find((c) => c.name() === 'init'));
     job
         .command('status')
         .requiredOption('--job-id <jid>')
@@ -220,7 +242,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--show-cost', 'overlay cost from peaks budget')
         .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
-        .action(async (opts) => {
+        .action((opts) => {
         const store = new JobStateStore(resolveJobStateRoot(opts, opts.jobId).rootDir);
         const orch = new JobOrchestrator(store);
         const s = orch.status(opts.jobId);
@@ -230,13 +252,28 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
                 process.stdout.write(`\rjob ${opts.jobId}: ${bar} ${s.done}/${s.total}${s.currentSlice ? ` next=${s.currentSlice}` : ''}    `);
             };
             draw();
-            const iv = setInterval(() => { const u = orch.status(opts.jobId); Object.assign(s, u); draw(); if (u.done + u.failed + u.skipped + u.blocked >= u.total)
-                clearInterval(iv); }, 3000);
-            process.on('SIGINT', () => { clearInterval(iv); process.stdout.write('\n'); process.exit(0); });
+            const iv = setInterval(() => {
+                const u = orch.status(opts.jobId);
+                Object.assign(s, u);
+                draw();
+                if (u.done + u.failed + u.skipped + u.blocked >= u.total)
+                    clearInterval(iv);
+            }, 3000);
+            process.on('SIGINT', () => {
+                clearInterval(iv);
+                process.stdout.write('\n');
+                process.exit(0);
+            });
             return;
         }
         try {
-            emitJobEvent({ kind: 'job-progress', jobId: opts.jobId, done: s.done, total: s.total, ...(s.currentSlice ? { currentSlice: s.currentSlice } : {}) });
+            emitJobEvent({
+                kind: 'job-progress',
+                jobId: opts.jobId,
+                done: s.done,
+                total: s.total,
+                ...(s.currentSlice ? { currentSlice: s.currentSlice } : {})
+            });
         }
         catch (e) {
             // ADVISORY (F1, 2026-09-17) — deliberately exits 0. The status itself
@@ -246,20 +283,26 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         }
         printResult(io, ok('status', s), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'status'));
+    addJsonOption(job.commands.find((c) => c.name() === 'status'));
     // M4.2: wire rotate-now to JobRotation (session-rotate callbacks are stubs pending M6.5 batch-fix).
-    job.command('rotate-now')
+    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, 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 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), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'rotate-now'));
-    job.command('subagent-cleanup')
+    addJsonOption(job.commands.find((c) => c.name() === 'rotate-now'));
+    job
+        .command('subagent-cleanup')
         .requiredOption('--job-id <jid>')
         .requiredOption('--batch-id <bid>')
         .option('--force')
@@ -267,10 +310,14 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--project <repo>')
         .action(async (opts) => {
         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 });
+        const r = await wrapper.cleanup({
+            jobId: opts.jobId,
+            batchId: opts.batchId,
+            force: !!opts.force
+        });
         printResult(io, ok('subagent-cleanup', r), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'subagent-cleanup'));
+    addJsonOption(job.commands.find((c) => c.name() === 'subagent-cleanup'));
     // M3.2: wire the remaining 5 subcommand slots — block, checkpoint, continue, handoff, resume.
     job
         .command('checkpoint')
@@ -283,9 +330,13 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--project <repo>')
         .action(async (opts) => {
         const parsed = JobCheckpointInputSchema.safeParse({
-            jobId: opts.jobId, sliceId: opts.sliceId, state: opts.state,
-            commitSha: opts.commitSha, reason: opts.reason,
-            project: projectRoot(opts), json: opts.json,
+            jobId: opts.jobId,
+            sliceId: opts.sliceId,
+            state: opts.state,
+            commitSha: opts.commitSha,
+            reason: opts.reason,
+            project: projectRoot(opts),
+            json: opts.json
         });
         if (!parsed.success)
             return failResult(io, fail('checkpoint', 'INVALID_CHECKPOINT', parsed.error.message, {}), opts);
@@ -297,7 +348,9 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         const slice = resolveSliceId(store, parsed.data.jobId, parsed.data.sliceId);
         if ('message' in slice) {
             return failResult(io, fail('checkpoint', 'SLICE_NOT_FOUND', slice.message, {
-                jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, validSliceIds: slice.validSliceIds,
+                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;
@@ -310,7 +363,11 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         // when the refresh succeeded or when no codegraph store was in use.
         let codegraphWarning = null;
         if (parsed.data.state === 'done') {
-            await orch.checkpointDone({ jobId: parsed.data.jobId, 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.
@@ -321,7 +378,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
                 jobId: parsed.data.jobId,
                 done: state.done,
                 total: state.total,
-                currentSlice: state.currentSlice ?? `slice-${state.done + 1}`,
+                currentSlice: state.currentSlice,
                 lastCommitSha: parsed.data.commitSha ?? null,
                 updatedAt: new Date().toISOString()
             });
@@ -347,19 +404,31 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
                 codegraph = await refreshCodegraphAfterSlice(project);
             }
             catch (e) {
-                codegraph = { refreshed: false, reason: 'unavailable', note: `auto codegraph refresh failed: ${e instanceof Error ? e.message : String(e)}` };
+                codegraph = {
+                    refreshed: false,
+                    reason: 'unavailable',
+                    note: `auto codegraph refresh failed: ${e instanceof Error ? e.message : String(e)}`
+                };
             }
             codegraphWarning = codegraphRefreshNotice(codegraph);
         }
         else if (parsed.data.state === 'skipped') {
-            await orch.checkpointSkipped({ jobId: parsed.data.jobId, 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, reason: parsed.data.reason });
+            await orch.checkpointFailed({
+                jobId: parsed.data.jobId,
+                sliceId,
+                reason: parsed.data.reason
+            });
         }
         printResult(io, ok('checkpoint', { sliceId, status: parsed.data.state, codegraph }, codegraphWarning === null ? [] : [codegraphWarning]), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'checkpoint'));
+    addJsonOption(job.commands.find((c) => c.name() === 'checkpoint'));
     job
         .command('block')
         .requiredOption('--job-id <jid>')
@@ -369,8 +438,11 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         .option('--project <repo>')
         .action(async (opts) => {
         const parsed = JobBlockInputSchema.safeParse({
-            jobId: opts.jobId, sliceId: opts.sliceId, reason: opts.reason,
-            project: projectRoot(opts), json: opts.json,
+            jobId: opts.jobId,
+            sliceId: opts.sliceId,
+            reason: opts.reason,
+            project: projectRoot(opts),
+            json: opts.json
         });
         if (!parsed.success)
             return failResult(io, fail('block', 'INVALID_BLOCK', parsed.error.message, {}), opts);
@@ -380,42 +452,43 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         const slice = resolveSliceId(store, parsed.data.jobId, parsed.data.sliceId);
         if ('message' in slice) {
             return failResult(io, fail('block', 'SLICE_NOT_FOUND', slice.message, {
-                jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, validSliceIds: slice.validSliceIds,
+                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, sliceId: slice.sliceId });
         printResult(io, ok('block', { blocked: slice.sliceId, reason: parsed.data.reason }), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'block'));
+    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) => {
+        .action((opts) => {
         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), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'continue'));
+    addJsonOption(job.commands.find((c) => c.name() === 'continue'));
     job
         .command('resume')
         .requiredOption('--job-id <jid>')
         .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
-        .action(async (opts) => {
+        .action((opts) => {
         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 }), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'resume'));
-    // v3.1.2: read the on-disk slice progress mirror written by `peaks
-    // job checkpoint --state done`. Used by peaks code gate-step-08 and
-    // by peaks-code Step 0.7 (resume) to surface `Next: slice #N of M
-    // (<currentSlice>)` without re-deriving from state.json.
+    addJsonOption(job.commands.find((c) => c.name() === 'resume'));
+    // v3.1.2: read the on-disk slice progress mirror written by `peaks job
+    // checkpoint --state done`; gate-step-08 and Step 0.7 (resume) read it too. The
+    // `next:` sentence comes from describeNextSlice, never re-derived from state.json.
     job
         .command('progress')
         .description('v3.1.2: read the on-disk slice progress mirror (.peaks/_runtime/<sid>/job/<jid>/progress.json). ' +
@@ -436,7 +509,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         // `tryReadJobProgress` returns `null` for a corrupt file too, so "done=0"
         // there would report unreadable state as empty state).
         .option('--allow-missing', 'report an absent progress.json as NO_PROGRESS (expected absence) rather than PROGRESS_READ_FAILED (read error); the command still exits non-zero')
-        .action(async (opts) => {
+        .action((opts) => {
         try {
             const jobRoot = resolveJobStateRoot(opts, opts.jobId);
             const sessId = jobRoot.sessionId;
@@ -462,40 +535,38 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
                 ]), opts);
                 return;
             }
-            printResult(io, ok('progress', progress, [], [
-                `Next: slice #${progress.done + 1} of ${progress.total} (${progress.currentSlice})`
-            ]), asJson(opts));
+            printResult(io, ok('progress', progress, [], [`Next: ${describeNextSlice(progress, progress.jobId)}`]), asJson(opts));
         }
         catch (err) {
             failResult(io, fail('progress', 'PROGRESS_READ_FAILED', err instanceof Error ? err.message : String(err), { jobId: opts.jobId }, ['Verify the job id and try again']), opts);
         }
     });
-    addJsonOption(job.commands.find(c => c.name() === 'progress'));
+    addJsonOption(job.commands.find((c) => c.name() === 'progress'));
     job
         .command('handoff')
         .requiredOption('--job-id <jid>')
         .option('--session-id <sid>', SESSION_ID_HELP)
         .option('--project <repo>')
-        .action(async (opts) => {
+        .action((opts) => {
         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 }), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'handoff'));
+    addJsonOption(job.commands.find((c) => c.name() === 'handoff'));
     job
         .command('karpathy-cost-check')
-        .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).')
+        .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>', SESSION_ID_HELP)
-        .action(async (opts) => {
+        .action((opts) => {
         const project = projectRoot(opts);
         const sessionId = opts.sessionId ?? process.env.PEAKS_SESSION_ID ?? getCurrentSessionId(project);
         if (!sessionId) {
             return failResult(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>',
-                'Or run `peaks workspace init` to create a session first',
+                'Or run `peaks workspace init` to create a session first'
             ]), opts);
         }
         const is24hModeActive = () => {
@@ -509,10 +580,10 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         };
         const out = runKarpathyCostCheck({
             reviewFilePath: opts.reviewFile,
-            is24hModeActive,
+            is24hModeActive
         });
         printResult(io, buildCostCheckEnvelope(out), asJson(opts));
     });
-    addJsonOption(job.commands.find(c => c.name() === 'karpathy-cost-check'));
+    addJsonOption(job.commands.find((c) => c.name() === 'karpathy-cost-check'));
     program.addCommand(job);
 }

package/dist/cli/commands/lease-metrics-commands-support.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Slice `b1-filesplit-campaign` (wave 3B) — verbatim extraction of the
+ * `peaks lease-metrics` option/kind type layer and the multi-session event
+ * reader out of `./lease-metrics-commands.ts` (344 raw lines > the 300 cap) so
+ * that module clears the cap. No field, no default, no message string and no
+ * filter changed: `lease-metrics-commands.ts` imports the names it still uses,
+ * re-exports the two public ones from its own path, and
+ * `./lease-stats-commands.ts` therefore needed no edit.
+ *
+ * `aggregateLeaseEvents` and `recomputeRate` stayed behind on purpose — each
+ * carries findings, and a NEW module in this campaign must be clean outright.
+ */
+import { type ObservabilityEvent } from '../../services/observability/observability-service.js';
+export type LeaseMetricsOptions = {
+    session?: string;
+    project?: string;
+    rate?: boolean;
+    allSessions?: boolean;
+    json?: boolean;
+};
+export type KindCounts = {
+    spawn: number;
+    renew: number;
+    release: number;
+    gc: number;
+    autoRelease: number;
+    'autoRelease-failed': number;
+    'autoRelease-skipped': number;
+};
+export declare const EMPTY_COUNTS: KindCounts;
+/**
+ * Part 5: leak-rate + lifetime statistics.
+ *
+ * Leaks are leases that were spawned but neither released (manual)
+ * nor auto-released nor gc'd. A naive count is
+ * `spawn - release - gc - autoRelease`; the result is the number
+ * of currently-alive leases in the absence of in-flight work
+ * (the on-disk lease files in `.peaks/_runtime/<sid>/worktree-leases/`
+ * are the canonical "alive" set; this aggregation is an estimate
+ * for sessions whose files have been pruned but the metrics
+ * stream survived).
+ *
+ * Lifetime: pair each spawn event with its first terminal event
+ * (release / gc / autoRelease / autoRelease-failed) for the same
+ * leaseId; the duration is the difference in milliseconds. The
+ * result is an avg / p99 across the completed leases. p99 is the
+ * 99th percentile; with 0-1 completed leases the field is null.
+ */
+export type RateStats = {
+    readonly totalSpawn: number;
+    readonly totalTerminal: number;
+    /** spawn - terminal — leases still "alive" per the metrics stream alone. */
+    readonly estimatedActive: number;
+    /** Estimated leaked = active - autoRelease-failed. Positive = worktrees
+     *  the user / CLI will need to gc manually. */
+    readonly estimatedLeaked: number;
+    readonly completedLifetimes: number;
+    readonly avgLifetimeMs: number | null;
+    readonly p99LifetimeMs: number | null;
+};
+/**
+ * Part 5: enumerate every session under `.peaks/_runtime/` for a
+ * project root and aggregate their lease events. Sessions without
+ * a `metrics/slices.jsonl` are skipped silently (a clean project
+ * has no lease events to report; that's not an error).
+ */
+export declare function readAllSessionLeaseEvents(projectRoot: string): {
+    sessions: ReadonlyArray<{
+        sessionId: string;
+        events: ReadonlyArray<ObservabilityEvent>;
+    }>;
+    missingSessions: number;
+};

package/dist/cli/commands/lease-metrics-commands-support.js

@@ -0,0 +1,67 @@
+/**
+ * Slice `b1-filesplit-campaign` (wave 3B) — verbatim extraction of the
+ * `peaks lease-metrics` option/kind type layer and the multi-session event
+ * reader out of `./lease-metrics-commands.ts` (344 raw lines > the 300 cap) so
+ * that module clears the cap. No field, no default, no message string and no
+ * filter changed: `lease-metrics-commands.ts` imports the names it still uses,
+ * re-exports the two public ones from its own path, and
+ * `./lease-stats-commands.ts` therefore needed no edit.
+ *
+ * `aggregateLeaseEvents` and `recomputeRate` stayed behind on purpose — each
+ * carries findings, and a NEW module in this campaign must be clean outright.
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { readObservabilityEvents } from '../../services/observability/observability-service.js';
+export const EMPTY_COUNTS = {
+    spawn: 0,
+    renew: 0,
+    release: 0,
+    gc: 0,
+    autoRelease: 0,
+    'autoRelease-failed': 0,
+    'autoRelease-skipped': 0
+};
+/**
+ * Part 5: enumerate every session under `.peaks/_runtime/` for a
+ * project root and aggregate their lease events. Sessions without
+ * a `metrics/slices.jsonl` are skipped silently (a clean project
+ * has no lease events to report; that's not an error).
+ */
+export function readAllSessionLeaseEvents(projectRoot) {
+    const runtimeDir = join(projectRoot, '.peaks', '_runtime');
+    if (!existsSync(runtimeDir))
+        return { sessions: [], missingSessions: 0 };
+    let entries;
+    try {
+        entries = readdirSync(runtimeDir);
+    }
+    catch {
+        return { sessions: [], missingSessions: 0 };
+    }
+    const sessions = [];
+    let missing = 0;
+    for (const sid of entries) {
+        const sessionDir = join(runtimeDir, sid);
+        try {
+            if (!statSync(sessionDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        try {
+            const all = readObservabilityEvents(projectRoot, sid);
+            const leaseEvents = all.filter((e) => e.category === 'lease');
+            if (leaseEvents.length === 0) {
+                missing++;
+                continue;
+            }
+            sessions.push({ sessionId: sid, events: leaseEvents });
+        }
+        catch {
+            missing++;
+        }
+    }
+    return { sessions, missingSessions: missing };
+}

package/dist/cli/commands/lease-metrics-commands.d.ts

@@ -17,51 +17,10 @@
  * on `category === 'lease'`; the schema is the same as every other
  * observability event (Part 4.A reused the existing schema v1).
  */
-import { Command } from 'commander';
+import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';
 import { type ObservabilityEvent } from '../../services/observability/observability-service.js';
-/**
- * Part 5: leak-rate + lifetime statistics.
- *
- * Leaks are leases that were spawned but neither released (manual)
- * nor auto-released nor gc'd. A naive count is
- * `spawn - release - gc - autoRelease`; the result is the number
- * of currently-alive leases in the absence of in-flight work
- * (the on-disk lease files in `.peaks/_runtime/<sid>/worktree-leases/`
- * are the canonical "alive" set; this aggregation is an estimate
- * for sessions whose files have been pruned but the metrics
- * stream survived).
- *
- * Lifetime: pair each spawn event with its first terminal event
- * (release / gc / autoRelease / autoRelease-failed) for the same
- * leaseId; the duration is the difference in milliseconds. The
- * result is an avg / p99 across the completed leases. p99 is the
- * 99th percentile; with 0-1 completed leases the field is null.
- */
-export type RateStats = {
-    readonly totalSpawn: number;
-    readonly totalTerminal: number;
-    /** spawn - terminal — leases still "alive" per the metrics stream alone. */
-    readonly estimatedActive: number;
-    /** Estimated leaked = active - autoRelease-failed. Positive = worktrees
-     *  the user / CLI will need to gc manually. */
-    readonly estimatedLeaked: number;
-    readonly completedLifetimes: number;
-    readonly avgLifetimeMs: number | null;
-    readonly p99LifetimeMs: number | null;
-};
+import { readAllSessionLeaseEvents, type RateStats } from './lease-metrics-commands-support.js';
+export { readAllSessionLeaseEvents, type RateStats };
 export declare function recomputeRate(leaseEvents: ReadonlyArray<ObservabilityEvent>): RateStats;
-/**
- * Part 5: enumerate every session under `.peaks/_runtime/` for a
- * project root and aggregate their lease events. Sessions without
- * a `metrics/slices.jsonl` are skipped silently (a clean project
- * has no lease events to report; that's not an error).
- */
-export declare function readAllSessionLeaseEvents(projectRoot: string): {
-    sessions: ReadonlyArray<{
-        sessionId: string;
-        events: ReadonlyArray<ObservabilityEvent>;
-    }>;
-    missingSessions: number;
-};
 export declare function registerLeaseMetricsCommand(parent: Command, io: ProgramIO): void;