peaks-loop 4.0.54 → 4.1.0

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

@@ -26,9 +26,7 @@ import { registerSession24hModeCommand } from '../session-24h-mode.js';
 import { registerSpillDemoCommand } from '../spill-demo-command.js';
 export function registerSessionCommand(program, io) {
     const session = program.command('session').description('Manage Peaks session directories');
-    addJsonOption(session
-        .command('list')
-        .description('List all session directories with titles and metadata')).action((options) => {
+    addJsonOption(session.command('list').description('List all session directories with titles and metadata')).action((options) => {
         const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
         const metas = listSessionMetas(projectRoot);
         printResult(io, ok('session.list', { sessions: metas, total: metas.length }), options.json);
@@ -64,7 +62,10 @@ export function registerSessionCommand(program, io) {
             catch (error) {
                 if (error instanceof CallerIdError) {
                     const code = error.code === 'EX_USAGE' ? 64 : 65;
-                    printResult(io, fail('session.info', 'CALLER_ID_INVALID', error.message, { source: error.source }, [`Set --caller-id to a value matching ^[a-zA-Z0-9._-]{1,200}$`, 'Or set PEAKS_CALLER_ID env var (or CLAUDE_CODE_SESSION_ID for Claude Code)']), options.json);
+                    printResult(io, fail('session.info', 'CALLER_ID_INVALID', error.message, { source: error.source }, [
+                        `Set --caller-id to a value matching ^[a-zA-Z0-9._-]{1,200}$`,
+                        'Or set PEAKS_CALLER_ID env var (or CLAUDE_CODE_SESSION_ID for Claude Code)'
+                    ]), options.json);
                     process.exitCode = code;
                     return;
                 }
@@ -93,7 +94,10 @@ export function registerSessionCommand(program, io) {
                 }), options.json);
                 return;
             }
-            printResult(io, ok('session.info', { callerId, note: '--caller-id resolved; pass --active to also look up the bound peak session' }), options.json);
+            printResult(io, ok('session.info', {
+                callerId,
+                note: '--caller-id resolved; pass --active to also look up the bound peak session'
+            }), options.json);
             return;
         }
         // Slice 007 + slice 021 — sub-agent session sharing. A sub-agent that
@@ -147,7 +151,9 @@ export function registerSessionCommand(program, io) {
             // contract). `warnings` is a top-level envelope field, not a
             // data field, so it goes through ok()'s 3rd positional arg.
             const legacyWarnings = bindingSource === 'legacy'
-                ? ['Read from legacy back-compat path .peaks/.session.json. Run `peaks workspace reconcile --apply` to migrate to the canonical home (.peaks/_runtime/session.json).']
+                ? [
+                    'Read from legacy back-compat path .peaks/.session.json. Run `peaks workspace reconcile --apply` to migrate to the canonical home (.peaks/_runtime/session.json).'
+                ]
                 : [];
             printResult(io, ok('session.info', {
                 active: true,
@@ -182,7 +188,9 @@ export function registerSessionCommand(program, io) {
             printResult(io, ok('session.title', meta), options.json);
         }
         catch (error) {
-            printResult(io, fail('session.title', 'SESSION_TITLE_FAILED', getErrorMessage(error), { sessionId }, ['Verify the sessionId exists under .peaks/']), options.json);
+            printResult(io, fail('session.title', 'SESSION_TITLE_FAILED', getErrorMessage(error), { sessionId }, [
+                'Verify the sessionId exists under .peaks/'
+            ]), options.json);
             process.exitCode = 1;
         }
     });
@@ -210,7 +218,7 @@ export function registerSessionCommand(program, io) {
         .command('rotate')
         .description('Drop the project-level session binding so the next peaks call auto-generates a fresh session id. The on-disk session directory is left intact — only .peaks/.session.json is removed.')
         .option('--project <path>', 'target project root (defaults to git root or cwd)')
-        .option('--reason <text>', 'human-readable reason for the rotation, recorded in the response data')).action(async (options) => {
+        .option('--reason <text>', 'human-readable reason for the rotation, recorded in the response data')).action((options) => {
         try {
             // Canonicalise the project root before touching the binding.
             // `peaks workspace init` writes the binding with the

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

@@ -153,7 +153,10 @@ import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.j
 import { registerSkillSearchCommand } from '../skill-search-commands.js';
 export function registerSkillCommand(program, io) {
     const skill = program.command('skill').description('Manage Peaks skills');
-    addJsonOption(skill.command('list').description('List skills derived from skills/*/SKILL.md').option('--include-internal', 'include skills with visibility: internal (default: hide them)')).action(async (options) => {
+    addJsonOption(skill
+        .command('list')
+        .description('List skills derived from skills/*/SKILL.md')
+        .option('--include-internal', 'include skills with visibility: internal (default: hide them)')).action(async (options) => {
         let skills = await listSkills();
         if (options.includeInternal !== true) {
             skills = skills.filter((s) => s.visibility !== 'internal');
@@ -227,14 +230,14 @@ export function registerSkillCommand(program, io) {
                 projectRoot,
                 ...(platforms !== undefined ? { platforms } : {}),
                 ...(options.dryRun === true ? { dryRun: true } : {}),
-                ...(options.reconcileJunctions === true ? { reconcileJunctions: true } : {}),
+                ...(options.reconcileJunctions === true ? { reconcileJunctions: true } : {})
             });
             const envelope = ok('skill.sync', result, [], [
                 `syncedCount: ${result.syncedCount}/${result.perPlatform.length} platforms`,
                 `totalInstalled: ${result.totalInstalled} skill symlinks`,
                 result.failedCount > 0
                     ? `failedCount: ${result.failedCount} (run \`peaks skill status\` for details)`
-                    : 'no failures',
+                    : 'no failures'
             ]);
             printResult(io, envelope, options.json);
             if (result.failedCount > 0) {
@@ -257,7 +260,9 @@ export function registerSkillCommand(program, io) {
                 : fail('skill.runbook', inspection.hasRunbook ? 'SKILL_RUNBOOK_APPLY_UNGATED' : 'SKILL_RUNBOOK_MISSING', inspection.hasRunbook
                     ? `Skill ${inspection.name} has ${inspection.destructiveApplyLines.length} destructive --apply command(s) without an authorization/dry-run note`
                     : `Skill ${inspection.name} is missing a ## Default runbook section`, inspection, inspection.hasRunbook
-                    ? ['Add an authorization or --dry-run note next to destructive --apply lines in the runbook section']
+                    ? [
+                        'Add an authorization or --dry-run note next to destructive --apply lines in the runbook section'
+                    ]
                     : ['Add a `## Default runbook` section to the skill SKILL.md']);
             printResult(io, result, options.json);
             if (!inspection.ok) {
@@ -304,7 +309,12 @@ export function registerSkillCommand(program, io) {
             }, generatedConfig.warnings, verdict.nextActions), options.json);
             return;
         }
-        printResult(io, ok('skill.presence', { active: true, ...presence, ...(verdict.context !== null ? { context: verdict.context } : {}), ...generatedConfig.field }, generatedConfig.warnings, verdict.nextActions), options.json);
+        printResult(io, ok('skill.presence', {
+            active: true,
+            ...presence,
+            ...(verdict.context !== null ? { context: verdict.context } : {}),
+            ...generatedConfig.field
+        }, generatedConfig.warnings, verdict.nextActions), options.json);
     });
     addJsonOption(skill
         .command('presence:set <name>')
@@ -328,7 +338,9 @@ export function registerSkillCommand(program, io) {
         // production CLI traffic must go through this gate.
         const boundSessionId = getSessionId(projectRoot);
         if (boundSessionId === null) {
-            printResult(io, fail('skill.presence:set', 'PEAKS_SESSION_NOT_BOUND', 'No canonical peaks session is bound for this project (RD §3 D1).', { projectRoot, name }, ['Run `peaks workspace init --project <p>` first, then re-run `peaks skill presence:set`.']), options.json);
+            printResult(io, fail('skill.presence:set', 'PEAKS_SESSION_NOT_BOUND', 'No canonical peaks session is bound for this project (RD §3 D1).', { projectRoot, name }, [
+                'Run `peaks workspace init --project <p>` first, then re-run `peaks skill presence:set`.'
+            ]), options.json);
             process.exitCode = 1;
             return;
         }
@@ -337,8 +349,10 @@ export function registerSkillCommand(program, io) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            printResult(io, fail('skill.presence:set', 'PEAKS_CALLER_NOT_RESOLVED', `Active IDE adapter could not resolve a callerId (RD §3 D1): ${message}`, { projectRoot, name }, ['Ensure the active IDE is detected by `peaks` and the IDE session variable is set.',
-                'Or set PEAKS_CALLER_ID=<id> in the environment for scripted usage.']), options.json);
+            printResult(io, fail('skill.presence:set', 'PEAKS_CALLER_NOT_RESOLVED', `Active IDE adapter could not resolve a callerId (RD §3 D1): ${message}`, { projectRoot, name }, [
+                'Ensure the active IDE is detected by `peaks` and the IDE session variable is set.',
+                'Or set PEAKS_CALLER_ID=<id> in the environment for scripted usage.'
+            ]), options.json);
             process.exitCode = 1;
             return;
         }
@@ -376,7 +390,8 @@ export function registerSkillCommand(program, io) {
         try {
             await generateProjectContext(projectRoot);
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        catch {
+            // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // non-fatal: context update failure should not block presence clear
         }
         // Report the state the project is actually in, not the state this command
@@ -435,7 +450,7 @@ export function registerSkillCommand(program, io) {
             const result = await gcStalePresenceLeases({
                 projectRoot,
                 ...(options.now !== undefined ? { now: options.now } : {}),
-                trigger: 'manual',
+                trigger: 'manual'
             });
             printResult(io, ok('skill.lease.gc', {
                 envelopeVersion: '4.0.8',
@@ -444,14 +459,16 @@ export function registerSkillCommand(program, io) {
                 trigger: result.trigger,
                 inFlightBatch: result.inFlightBatch,
                 warnings: result.warnings,
-                errors: result.errors,
+                errors: result.errors
             }, result.warnings.map((w) => `${w.code}: ${w.message}`), [
                 'GC predicate: now - lastHeartbeat > 1h AND now - startedAt > 24h (RD §3 D2 + D3).',
-                'Re-run `peaks workspace init` or `peaks skill presence:set` to sweep the same project on the bound trigger.',
+                'Re-run `peaks workspace init` or `peaks skill presence:set` to sweep the same project on the bound trigger.'
             ]), options.json);
         }
         catch (err) {
-            printResult(io, fail('skill.lease.gc', 'PEAKS_LEASE_GC_FAILED', getErrorMessage(err), { projectRoot }, ['Re-run with a valid --project and ensure the session is bound.']), options.json);
+            printResult(io, fail('skill.lease.gc', 'PEAKS_LEASE_GC_FAILED', getErrorMessage(err), { projectRoot }, [
+                'Re-run with a valid --project and ensure the session is bound.'
+            ]), options.json);
             process.exitCode = 1;
         }
     });
@@ -495,9 +512,7 @@ export function registerSkillCommand(program, io) {
         };
         printResult(io, ok('skill.presence:check-stale', data), options.json);
     });
-    addJsonOption(skill
-        .command('heartbeat')
-        .description('Show the heartbeat status of the active Peaks skill')).action((options) => {
+    addJsonOption(skill.command('heartbeat').description('Show the heartbeat status of the active Peaks skill')).action((options) => {
         const presence = getSkillPresence();
         if (presence === null) {
             printResult(io, ok('skill.heartbeat', { active: false, heartbeat: 'none' }), options.json);

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

@@ -20,14 +20,22 @@ export const LOOP_ENGINEERING_GUIDELINES_RELATIVE_PATH = '.peaks/standards/loop-
 export function runLoopEngineeringLint(projectRoot) {
     const root = resolve(projectRoot);
     const guidelinePath = join(root, LOOP_ENGINEERING_GUIDELINES_RELATIVE_PATH);
-    const data = { category: LOOP_ENGINEERING_CATEGORY, path: guidelinePath, redLineCount: 0, redLineIds: [], findings: [] };
+    const data = {
+        category: LOOP_ENGINEERING_CATEGORY,
+        path: guidelinePath,
+        redLineCount: 0,
+        redLineIds: [],
+        findings: []
+    };
     if (!existsSync(guidelinePath)) {
         return {
             ok: false,
             code: 'LINT_FILE_NOT_FOUND',
             message: `no ${LOOP_ENGINEERING_GUIDELINES_RELATIVE_PATH} under ${root}`,
             data,
-            nextActions: [`Pass --project pointing at a peaks-loop checkout (the lint reads its own guideline file).`],
+            nextActions: [
+                `Pass --project pointing at a peaks-loop checkout (the lint reads its own guideline file).`
+            ]
         };
     }
     const result = lintLoopEngineeringGuidelines(readFileSync(guidelinePath, 'utf-8'));
@@ -39,7 +47,7 @@ export function runLoopEngineeringLint(projectRoot) {
             code: 'STANDARDS_LINT_OK',
             message: `${redLineIds.length} red line(s) present with all 4 sections (expected: ${EXPECTED_RED_LINE_IDS.join(', ')})`,
             data: fullData,
-            nextActions: ['Any new red line must use the 4-section form or this lint will reject it.'],
+            nextActions: ['Any new red line must use the 4-section form or this lint will reject it.']
         };
     }
     return {
@@ -49,12 +57,14 @@ export function runLoopEngineeringLint(projectRoot) {
         data: { ...fullData, findings: result.findings },
         nextActions: [
             'Address every finding in data.findings, then re-run the lint.',
-            'Each red line must be a `## RL-N — <title>` heading with the 4 sections: Failure modes / Rewrite / Self-check / Out-of-scope.',
-        ],
+            'Each red line must be a `## RL-N — <title>` heading with the 4 sections: Failure modes / Rewrite / Self-check / Out-of-scope.'
+        ]
     };
 }
 export function registerStandardsCommand(program, io) {
-    const standards = program.command('standards').description('Manage project-local coding standards');
+    const standards = program
+        .command('standards')
+        .description('Manage project-local coding standards');
     addJsonOption(standards
         .command('init')
         .description('Initialize project-local coding standards for Peaks skill preflight')
@@ -69,11 +79,22 @@ export function registerStandardsCommand(program, io) {
             return;
         }
         try {
-            const result = executeProjectStandardsInitIdeAware({ projectRoot: options.project, ...(options.language !== undefined ? { language: options.language } : {}), ...(options.ide !== undefined ? { ideId: options.ide } : {}), apply: options.apply === true });
+            const result = executeProjectStandardsInitIdeAware({
+                projectRoot: options.project,
+                ...(options.language !== undefined ? { language: options.language } : {}),
+                ...(options.ide !== undefined
+                    ? {
+                        ideId: options.ide
+                    }
+                    : {}),
+                apply: options.apply === true
+            });
             printResult(io, ok('standards.init', summarizeProjectStandardsInitResult(result)), options.json);
         }
         catch (error) {
-            printResult(io, fail('standards.init', 'STANDARDS_INIT_FAILED', getErrorMessage(error), {}, ['Check the project path and existing .claude/rules directory before retrying']), options.json);
+            printResult(io, fail('standards.init', 'STANDARDS_INIT_FAILED', getErrorMessage(error), {}, [
+                'Check the project path and existing .claude/rules directory before retrying'
+            ]), options.json);
             process.exitCode = 1;
         }
     });
@@ -86,12 +107,23 @@ export function registerStandardsCommand(program, io) {
         .option('--dry-run', 'preview writes without changing files')
         .option('--apply', 'append managed metadata to the target project')).action((options) => {
         if (options.dryRun === true && options.apply === true) {
-            printResult(io, fail('standards.update', 'INVALID_STANDARDS_UPDATE_FLAGS', 'Use either --dry-run or --apply, not both', {}, ['Run without --apply to preview writes, or omit --dry-run when applying standards updates']), options.json);
+            printResult(io, fail('standards.update', 'INVALID_STANDARDS_UPDATE_FLAGS', 'Use either --dry-run or --apply, not both', {}, [
+                'Run without --apply to preview writes, or omit --dry-run when applying standards updates'
+            ]), options.json);
             process.exitCode = 1;
             return;
         }
         try {
-            const result = executeProjectStandardsUpdateIdeAware({ projectRoot: options.project, ...(options.language !== undefined ? { language: options.language } : {}), ...(options.ide !== undefined ? { ideId: options.ide } : {}), apply: options.apply === true });
+            const result = executeProjectStandardsUpdateIdeAware({
+                projectRoot: options.project,
+                ...(options.language !== undefined ? { language: options.language } : {}),
+                ...(options.ide !== undefined
+                    ? {
+                        ideId: options.ide
+                    }
+                    : {}),
+                apply: options.apply === true
+            });
             const summary = summarizeProjectStandardsUpdateResult(result);
             const response = summary.reviewSuggestions.length > 0
                 ? fail('standards.update', 'STANDARDS_UPDATE_REVIEW_REQUIRED', 'Standards update requires manual review', summary, summary.reviewSuggestions)
@@ -102,7 +134,9 @@ export function registerStandardsCommand(program, io) {
             }
         }
         catch (error) {
-            printResult(io, fail('standards.update', 'STANDARDS_UPDATE_FAILED', getErrorMessage(error), {}, ['Check the project path, CLAUDE.md contents, and existing .claude/rules directory before retrying']), options.json);
+            printResult(io, fail('standards.update', 'STANDARDS_UPDATE_FAILED', getErrorMessage(error), {}, [
+                'Check the project path, CLAUDE.md contents, and existing .claude/rules directory before retrying'
+            ]), options.json);
             process.exitCode = 1;
         }
     });
@@ -126,7 +160,7 @@ export function registerStandardsCommand(program, io) {
                     preservedFiles: [],
                     wouldChange: false,
                     applied: false,
-                    nextActions: [],
+                    nextActions: []
                 }, [getErrorMessage(error)]), options.json);
                 process.exitCode = 1;
             }
@@ -137,7 +171,15 @@ export function registerStandardsCommand(program, io) {
             printResult(io, ok('standards.migrate', result.data, [], result.data.nextActions), options.json);
         }
         catch (error) {
-            printResult(io, fail('standards.migrate', 'STANDARDS_MIGRATE_FAILED', getErrorMessage(error), { file: null, foundOldBlock: false, wouldChange: false, applied: false, before: null, after: null, nextActions: [] }, [getErrorMessage(error)]), options.json);
+            printResult(io, fail('standards.migrate', 'STANDARDS_MIGRATE_FAILED', getErrorMessage(error), {
+                file: null,
+                foundOldBlock: false,
+                wouldChange: false,
+                applied: false,
+                before: null,
+                after: null,
+                nextActions: []
+            }, [getErrorMessage(error)]), options.json);
             process.exitCode = 1;
         }
     });

package/dist/cli/commands/cron-commands-actions.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The three `peaks cron` action handlers (init / list / run) — moved VERBATIM
+ * out of `cron-commands.ts` (job strict-remediation-abc, slice
+ * c1-eslint-family-sweep, leaf c3w1-cron-commands) so the registration file
+ * clears the `max-lines-per-function` findings.
+ *
+ * NOTHING was restructured: same predicate order inside the due/nextDueAt
+ * annotation (`e.enabled && (e.lastRunAt === null || now - e.lastRunAt >=
+ * e.intervalMs)`, with `>=` exactly as it was), same `process.exitCode = 1`
+ * points, same emitted message text, same sort. The run action's 66-line body
+ * was further split into `runCronTasks` / `runTargets` / `printRunOutcome`
+ * purely to cross the function-length line; ordering is unchanged.
+ *
+ * One dead local was not copied: `const now = Date.now();` inside the run
+ * action was never read (it carried a `no-unused-vars` baseline ERROR on the
+ * original file). Removing an unread, effect-free assignment changes no branch,
+ * throw, exit code, or emitted byte — and a new sibling must be clean outright.
+ *
+ * ONE thing has since been restructured, and it is not the verbatim move above:
+ * rid `2026-10-01-cron-last-run-at-01` repair cycle 1 replaced `runCronTasks`'s
+ * own fold-and-write (a `runTargets` that built the next file from the snapshot
+ * read before the runs, stamping every record including killed ones) with the
+ * scheduler's `persistLastRunAt`, so one rule and one write-time re-read cover
+ * all three `lastRunAt` writers. The `ran` / `records` envelope, the exit-code
+ * branch and every emitted message are unchanged; what changed on disk is that a
+ * killed run no longer advances `lastRunAt` here, and that entries another writer
+ * added mid-run are no longer reverted. The rule is in
+ * `cron-scheduler-persist.ts`.
+ */
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function handleCronInit(io: ProgramIO, options: {
+    project?: string;
+    json?: boolean;
+}): void;
+export declare function handleCronList(io: ProgramIO, options: {
+    project?: string;
+    json?: boolean;
+}): void;
+export declare function handleCronRun(io: ProgramIO, options: {
+    id?: string;
+    project?: string;
+    json?: boolean;
+}): void;

package/dist/cli/commands/cron-commands-actions.js

@@ -0,0 +1,128 @@
+/**
+ * The three `peaks cron` action handlers (init / list / run) — moved VERBATIM
+ * out of `cron-commands.ts` (job strict-remediation-abc, slice
+ * c1-eslint-family-sweep, leaf c3w1-cron-commands) so the registration file
+ * clears the `max-lines-per-function` findings.
+ *
+ * NOTHING was restructured: same predicate order inside the due/nextDueAt
+ * annotation (`e.enabled && (e.lastRunAt === null || now - e.lastRunAt >=
+ * e.intervalMs)`, with `>=` exactly as it was), same `process.exitCode = 1`
+ * points, same emitted message text, same sort. The run action's 66-line body
+ * was further split into `runCronTasks` / `runTargets` / `printRunOutcome`
+ * purely to cross the function-length line; ordering is unchanged.
+ *
+ * One dead local was not copied: `const now = Date.now();` inside the run
+ * action was never read (it carried a `no-unused-vars` baseline ERROR on the
+ * original file). Removing an unread, effect-free assignment changes no branch,
+ * throw, exit code, or emitted byte — and a new sibling must be clean outright.
+ *
+ * ONE thing has since been restructured, and it is not the verbatim move above:
+ * rid `2026-10-01-cron-last-run-at-01` repair cycle 1 replaced `runCronTasks`'s
+ * own fold-and-write (a `runTargets` that built the next file from the snapshot
+ * read before the runs, stamping every record including killed ones) with the
+ * scheduler's `persistLastRunAt`, so one rule and one write-time re-read cover
+ * all three `lastRunAt` writers. The `ran` / `records` envelope, the exit-code
+ * branch and every emitted message are unchanged; what changed on disk is that a
+ * killed run no longer advances `lastRunAt` here, and that entries another writer
+ * added mid-run are no longer reverted. The rule is in
+ * `cron-scheduler-persist.ts`.
+ */
+import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
+import { printResult } from '../cli-helpers.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { ensureLeaseGcEntry, listDueTasks, readSchedule, schedulePath, writeSchedule } from './cron-commands-schedule.js';
+import { runTask } from './cron-commands.js';
+import { persistLastRunAt } from './cron-scheduler-persist.js';
+const STDERR_NEXT_ACTIONS_TRUNCATE_CHARS = 200;
+export function handleCronInit(io, options) {
+    try {
+        const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        const file = readSchedule(projectRoot);
+        const updated = ensureLeaseGcEntry(file);
+        writeSchedule(projectRoot, updated);
+        const added = updated.entries.length - file.entries.length;
+        printResult(io, ok('cron.init', {
+            projectRoot,
+            schedulePath: schedulePath(projectRoot),
+            totalEntries: updated.entries.length,
+            added
+        }, [], [
+            added > 0
+                ? `Added ${added} built-in task(s). Use 'peaks cron list' to inspect.`
+                : 'Schedule already contains the built-in tasks; no change made.'
+        ]), options.json);
+    }
+    catch (err) {
+        printResult(io, fail('cron.init', 'CRON_INIT_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+            'Verify the project root is a peaks-loop project (.peaks/ exists).',
+            'Check filesystem permissions.'
+        ]), options.json);
+        process.exitCode = 1;
+    }
+}
+export function handleCronList(io, options) {
+    try {
+        const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+        const file = readSchedule(projectRoot);
+        const now = Date.now();
+        const annotated = file.entries.map((e) => ({
+            ...e,
+            due: e.enabled && (e.lastRunAt === null || now - e.lastRunAt >= e.intervalMs),
+            nextDueAt: e.lastRunAt === null ? now : e.lastRunAt + e.intervalMs
+        }));
+        annotated.sort((a, b) => a.nextDueAt - b.nextDueAt);
+        printResult(io, ok('cron.list', { projectRoot, schedulePath: schedulePath(projectRoot), entries: annotated }, [], [`${annotated.length} task(s); ${annotated.filter((e) => e.due).length} due now.`]), options.json);
+    }
+    catch (err) {
+        printResult(io, fail('cron.list', 'CRON_LIST_FAILED', getErrorMessage(err), { projectRoot: options.project }, ["If schedule.json is missing, run 'peaks cron init' first."]), options.json);
+        process.exitCode = 1;
+    }
+}
+export function handleCronRun(io, options) {
+    try {
+        runCronTasks(io, options);
+    }
+    catch (err) {
+        printResult(io, fail('cron.run', 'CRON_RUN_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+            "If schedule.json is missing, run 'peaks cron init' first."
+        ]), options.json);
+        process.exitCode = 1;
+    }
+}
+function runCronTasks(io, options) {
+    const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+    const file = readSchedule(projectRoot);
+    const targets = options.id
+        ? file.entries.filter((e) => e.id === options.id)
+        : listDueTasks(projectRoot);
+    if (targets.length === 0) {
+        printResult(io, ok('cron.run', { projectRoot, ran: 0, records: [] }, [], ['No due tasks; nothing to run.']), options.json);
+        return;
+    }
+    const records = runTargets(projectRoot, targets);
+    // ONE rule, ONE writer (rid `2026-10-01-cron-last-run-at-01`, repair cycle 1).
+    // This call is the third site of the `lastRunAt` fold, whose rule and platform
+    // costs live in `cron-scheduler-persist.ts`. Two things it replaces: a fold that
+    // stamped EVERY record, killed ones included (so the same killed fire went quiet
+    // here and stayed due under the daemon), and a write built from the `file`
+    // snapshot read above — taken up to `EXEC_TIMEOUT_MS` (300,000 ms) of synchronous
+    // runs before the write, so it reverted any stamp the daemon landed in between,
+    // back to `null`. `persistLastRunAt` re-reads at write time instead.
+    persistLastRunAt(projectRoot, records);
+    printRunOutcome(io, options, projectRoot, records);
+}
+function runTargets(projectRoot, targets) {
+    const records = [];
+    for (const task of targets)
+        records.push(runTask(projectRoot, task));
+    return records;
+}
+function printRunOutcome(io, options, projectRoot, records) {
+    printResult(io, ok('cron.run', { projectRoot, ran: records.length, records }, records
+        .filter((r) => r.exitCode !== 0)
+        .map((r) => `Task ${r.taskId} failed (exit=${r.exitCode}): ${r.stderr.slice(0, STDERR_NEXT_ACTIONS_TRUNCATE_CHARS)}`), [
+        `Ran ${records.length} task(s); ${records.filter((r) => r.exitCode === 0).length} succeeded.`
+    ]), options.json);
+    if (records.some((r) => r.exitCode !== 0))
+        process.exitCode = 1;
+}

package/dist/cli/commands/cron-commands-schedule.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The schedule model half of `peaks cron` (Part 14) — moved VERBATIM out of
+ * `cron-commands.ts` (job strict-remediation-abc, slice c1-eslint-family-sweep,
+ * leaf c3w1-cron-commands) so that file clears the 300-line cap and the
+ * `complexity` finding on `readSchedule` falls.
+ *
+ * NOTHING was restructured: same branch order, same predicates, same throw
+ * points, same message text, same on-disk bytes. `readSchedule` was split into
+ * `assertScheduleRoot` + `toScheduleEntry` + `isStringArray` only to shed the
+ * complexity finding; every check still runs in the original order with the
+ * original short-circuits.
+ *
+ * `runTask` (and its exec-timeout + record-truncation constants) deliberately
+ * stays in `cron-commands.ts`: that file carries the baseline `no-magic-numbers`
+ * warning on the timeout constant, and a new sibling must be clean outright.
+ */
+export declare const SCHEDULE_VERSION: 1;
+/**
+ * PRD-002b slice 2 — extract cron-orchestration magic numbers (24h
+ * default interval, 5-minute exec timeout, stderr-message truncation
+ * lengths in the renderer). The exec-timeout constant itself stayed in
+ * `cron-commands.ts` with `runTask`.
+ */
+export declare const MS_PER_SECOND = 1000;
+export declare const MINUTES_PER_HOUR = 60;
+export declare const SECONDS_PER_MINUTE = 60;
+export type ScheduleEntry = {
+    readonly id: string;
+    readonly name: string;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+    readonly intervalMs: number;
+    readonly lastRunAt: number | null;
+    readonly enabled: boolean;
+    readonly createdAt: number;
+};
+export type ScheduleFile = {
+    readonly version: typeof SCHEDULE_VERSION;
+    readonly entries: ReadonlyArray<ScheduleEntry>;
+};
+export type RunRecord = {
+    readonly id: string;
+    readonly taskId: string;
+    readonly startedAt: number;
+    readonly finishedAt: number;
+    readonly exitCode: number;
+    readonly stderr: string;
+    /**
+     * Present (and `true`) ONLY when the task was killed for exceeding its exec
+     * timeout — i.e. when there is no child exit status behind `exitCode` and the
+     * work may have been mid-flight. Added by rid 2026-10-01-cron-task-tree-kill-01
+     * so a killed run cannot be read as a clean `exitCode 1` failure.
+     *
+     * OPTIONAL on purpose: `appendHistory` is the only writer of
+     * `history.jsonl` and nothing in this repo reads it back, so the smallest
+     * representation that consumers can carry is "the key is absent unless the
+     * task was killed" — every pre-existing row shape is unchanged.
+     */
+    readonly killed?: true;
+};
+export declare function schedulePath(projectRoot: string): string;
+export declare function readSchedule(projectRoot: string): ScheduleFile;
+/**
+ * The one "can this raw JSON entry be represented?" predicate. Exported because
+ * a writer that must NOT lose an entry needs to know which ones the reader
+ * dropped (rid `2026-10-01-cron-last-run-at-01`, repair cycle 1, F5 — see
+ * `persistLastRunAt` in `cron-scheduler-persist.ts`).
+ */
+export declare function toScheduleEntry(e: unknown): ScheduleEntry | null;
+/**
+ * The write half's input shape: a version plus the entries to store.
+ *
+ * `entries` is `ReadonlyArray<unknown>`, not `ReadonlyArray<ScheduleEntry>`, for one
+ * caller: `persistLastRunAt` re-writes the raw JSON of entries `toScheduleEntry`
+ * refused, so that a daemon write cannot delete an operator's hand-edited entry
+ * (rid `2026-10-01-cron-last-run-at-01` repair cycle 1, F5). Every other caller
+ * passes a `ScheduleFile`, which satisfies this shape.
+ */
+export type ScheduleWrite = {
+    readonly version: typeof SCHEDULE_VERSION;
+    readonly entries: ReadonlyArray<unknown>;
+};
+export declare function writeSchedule(projectRoot: string, file: ScheduleWrite): void;
+export declare function appendHistory(projectRoot: string, record: RunRecord): void;
+export declare function ensureLeaseGcEntry(file: ScheduleFile): ScheduleFile;
+export declare function listDueTasks(projectRoot: string, now?: number): ReadonlyArray<ScheduleEntry>;