peaks-loop 4.1.2 → 4.1.3

package/dist/cli/commands/evolution-propose-command.js

@@ -0,0 +1,145 @@
+import { EvolutionIntegrityError } from '../../services/evolution/evolution-service.js';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { ok } from 'peaks-loop-shared/result';
+import { deltaMinFailure, invalidTargetFailure, isScoreInRange, parseTargetFlag, reportFailure, reportIntegrityFailure, scoreRangeFailure, withEvolutionDb } from './evolution-command-shared.js';
+const PROPOSE_DESCRIPTION = "M4: persist a new evolution proposal. Enforces AC-8 (single object + single dimension). The proposal's verdict starts at 'needs-user-decision' until the scoring + skeptic step lands.";
+/**
+ * Validate `--target`, `--before-score`, `--after-score` and
+ * `--delta-min` in that order, returning the first failure envelope
+ * the original action would have printed.
+ */
+function preparePropose(options) {
+    const target = parseTargetFlag(options.target);
+    if (!target)
+        return { ok: false, failure: invalidTargetFailure('evolution.propose', options.target) };
+    const before = Number(options.beforeScore);
+    if (!isScoreInRange(before)) {
+        return {
+            ok: false,
+            failure: scoreRangeFailure({
+                command: 'evolution.propose',
+                code: 'EVOLUTION_INVALID_BEFORE_SCORE',
+                label: 'before_score',
+                flag: '--before-score',
+                key: 'beforeScore',
+                raw: options.beforeScore
+            })
+        };
+    }
+    const after = Number(options.afterScore);
+    if (!isScoreInRange(after)) {
+        return {
+            ok: false,
+            failure: scoreRangeFailure({
+                command: 'evolution.propose',
+                code: 'EVOLUTION_INVALID_AFTER_SCORE',
+                label: 'after_score',
+                flag: '--after-score',
+                key: 'afterScore',
+                raw: options.afterScore
+            })
+        };
+    }
+    const deltaMin = Number(options.deltaMin);
+    if (!Number.isFinite(deltaMin) || deltaMin < 0) {
+        return { ok: false, failure: deltaMinFailure('evolution.propose', options.deltaMin) };
+    }
+    return { ok: true, target, before, after, deltaMin };
+}
+/** The `EvolutionProposalInput` the service receives. */
+function proposeInput(prep, options) {
+    return {
+        target_kind: prep.target.kind,
+        target_release_id: prep.target.id,
+        optimization_dimension: options.dimension,
+        before_snapshot: {},
+        after_snapshot: { after_score: prep.after },
+        diff: {},
+        before_score: prep.before,
+        after_score: prep.after,
+        score_delta_min: prep.deltaMin,
+        author_id: options.author,
+        single_object: true,
+        single_optimization_dimension: true,
+        rubric: {},
+        red_lines: [],
+        source_traces: []
+    };
+}
+/** The `ok(...)` `data` payload for a freshly created proposal. */
+function proposeEnvelopeData(proposal, options) {
+    return {
+        proposal: {
+            id: proposal.id,
+            target_kind: proposal.target_kind,
+            target_release_id: proposal.target_release_id,
+            optimization_dimension: proposal.optimization_dimension,
+            before_score: proposal.before_score,
+            after_score: proposal.after_score,
+            score_delta: proposal.score_delta,
+            score_delta_min: proposal.score_delta_min,
+            author_id: proposal.author_id,
+            verdict: 'needs-user-decision',
+            ...(options.briefPointer !== undefined ? { brief_pointer: options.briefPointer } : {})
+        },
+        nextActions: [
+            `Run \`peaks evolution evaluate --proposal ${proposal.id} --evaluator <id> --skeptic <id> --evaluator-score <n> --json\` to score the proposal.`
+        ]
+    };
+}
+/** Print the propose failure envelope for `err` and set exit code 1. */
+function reportProposeFailure(io, err, options) {
+    if (err instanceof EvolutionIntegrityError) {
+        reportIntegrityFailure({
+            io,
+            command: 'evolution.propose',
+            error: err,
+            nextActions: [
+                'Re-shape the proposal per spec §6: single object, single dimension, separate scorer.',
+                'If you intended a multi-object change, split it into multiple rounds.'
+            ],
+            asJson: options.json
+        });
+        return;
+    }
+    reportFailure({
+        io,
+        command: 'evolution.propose',
+        code: 'EVOLUTION_PROPOSE_FAILED',
+        error: err,
+        data: {},
+        nextActions: ['Verify the target flag and dimension.'],
+        asJson: options.json
+    });
+}
+/** The `propose` action body. */
+export function runPropose(options, io) {
+    try {
+        const prep = preparePropose(options);
+        if (!prep.ok) {
+            printResult(io, prep.failure, options.json);
+            process.exitCode = 1;
+            return;
+        }
+        const input = proposeInput(prep, options);
+        const proposal = withEvolutionDb(options.project, (svc) => svc.createProposal(input));
+        printResult(io, ok('evolution.propose', proposeEnvelopeData(proposal, options), [], []), options.json);
+    }
+    catch (err) {
+        reportProposeFailure(io, err, options);
+    }
+}
+/** Register `peaks evolution propose` on the `evolution` parent. */
+export function registerProposeCommand(evolution, io) {
+    addJsonOption(evolution
+        .command('propose')
+        .description(PROPOSE_DESCRIPTION)
+        .requiredOption('--target <kind:id>', "target asset, e.g. 'loop:loop-onboarding-research' or 'bee:42'")
+        .requiredOption('--dimension <name>', "single optimization dimension (e.g. 'clarity')")
+        .requiredOption('--before-score <n>', 'score on the 0..10 scale BEFORE the change')
+        .requiredOption('--after-score <n>', 'score on the 0..10 scale AFTER the change (LLM-claimed)')
+        .option('--delta-min <n>', `minimum score delta for promotion (default: 1.0; spec §6.1 #5)`, '1.0')
+        .requiredOption('--author <id>', 'author agent id (the LLM proposing the change)')
+        .option('--brief-pointer <ptr>', 'pointer to the evidence brief used in the recommendation (spec §4.7 / §4.4)')
+        .option('--project <path>', 'project root (default: cwd)')).action((options) => runPropose(options, io));
+}

package/dist/cli/commands/evolution-status-command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `peaks evolution status` — M4 / spec §4.4. Split out of
+ * `evolution-commands.ts`: the option surface, the envelope and the
+ * exit-code sites are unchanged.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+/** The `--options` Commander hands to the `status` action. */
+export interface StatusOptions {
+    target: string;
+    project?: string;
+    json?: boolean;
+}
+/** The `status` action body. */
+export declare function runStatus(options: StatusOptions, io: ProgramIO): void;
+/** Register `peaks evolution status` on the `evolution` parent. */
+export declare function registerStatusCommand(evolution: Command, io: ProgramIO): void;

package/dist/cli/commands/evolution-status-command.js

@@ -0,0 +1,41 @@
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { ok } from 'peaks-loop-shared/result';
+import { invalidTargetFailure, parseTargetFlag, reportFailure, withEvolutionDb } from './evolution-command-shared.js';
+const STATUS_DESCRIPTION = 'M4: read the status snapshot for a target (counts of evaluations by verdict + latest evaluation id).';
+/** The `{ target_kind, target_release_id }` argument `svc.status` takes. */
+function statusTarget(target) {
+    return { target_kind: target.kind, target_release_id: target.id };
+}
+/** The `status` action body. */
+export function runStatus(options, io) {
+    try {
+        const target = parseTargetFlag(options.target);
+        if (!target) {
+            printResult(io, invalidTargetFailure('evolution.status', options.target), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        const targetArg = statusTarget(target);
+        const status = withEvolutionDb(options.project, (svc) => svc.status(targetArg));
+        printResult(io, ok('evolution.status', status, [], []), options.json);
+    }
+    catch (err) {
+        reportFailure({
+            io,
+            command: 'evolution.status',
+            code: 'EVOLUTION_STATUS_FAILED',
+            error: err,
+            data: { target: options.target },
+            nextActions: ['Verify the target flag.'],
+            asJson: options.json
+        });
+    }
+}
+/** Register `peaks evolution status` on the `evolution` parent. */
+export function registerStatusCommand(evolution, io) {
+    addJsonOption(evolution
+        .command('status')
+        .description(STATUS_DESCRIPTION)
+        .requiredOption('--target <kind:id>', "target asset, e.g. 'loop:loop-onboarding-research'")
+        .option('--project <path>', 'project root (default: cwd)')).action((options) => runStatus(options, io));
+}

package/dist/cli/commands/evolution-verdict-commands.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `peaks evolution mark-keep` + `peaks evolution revert` — the two
+ * explicit-verdict verbs (spec §6.1 #8). Split out of
+ * `evolution-commands.ts`: the option surfaces, the envelope keys and
+ * the exit-code sites are unchanged.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+/** The `--options` Commander hands to the `mark-keep` action. */
+export interface MarkKeepOptions {
+    proposal: string;
+    userConfirmation: string;
+    project?: string;
+    json?: boolean;
+}
+/** The `--options` Commander hands to the `revert` action. */
+export interface RevertOptions {
+    proposal: string;
+    userConfirmation?: string;
+    project?: string;
+    json?: boolean;
+}
+/** The `mark-keep` action body. */
+export declare function runMarkKeep(options: MarkKeepOptions, io: ProgramIO): void;
+/** The `revert` action body. */
+export declare function runRevert(options: RevertOptions, io: ProgramIO): void;
+/** Register `peaks evolution mark-keep` on the `evolution` parent. */
+export declare function registerMarkKeepCommand(evolution: Command, io: ProgramIO): void;
+/** Register `peaks evolution revert` on the `evolution` parent. */
+export declare function registerRevertCommand(evolution: Command, io: ProgramIO): void;

package/dist/cli/commands/evolution-verdict-commands.js

@@ -0,0 +1,100 @@
+import { EvolutionIntegrityError } from '../../services/evolution/evolution-service.js';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { ok } from 'peaks-loop-shared/result';
+import { proposalNotFoundFailure, reportFailure, reportIntegrityFailure, withEvolutionDb } from './evolution-command-shared.js';
+const MARK_KEEP_DESCRIPTION = 'M4: explicit user-confirmed `keep` verdict. Requires --user-confirmation <ptr> and a score_delta >= score_delta_min (AC-11/AC-15).';
+const REVERT_DESCRIPTION = 'M4: revert a proposal (universal recovery; spec §6.1 #8). Always allowed; the user may supply --user-confirmation for audit.';
+/** Print the mark-keep failure envelope for `err` and set exit code 1. */
+function reportMarkKeepFailure(io, err, options) {
+    if (err instanceof EvolutionIntegrityError) {
+        reportIntegrityFailure({
+            io,
+            command: 'evolution.mark-keep',
+            error: err,
+            nextActions: ['Re-shape the proposal or the score so score_delta >= score_delta_min.'],
+            asJson: options.json
+        });
+        return;
+    }
+    reportFailure({
+        io,
+        command: 'evolution.mark-keep',
+        code: 'EVOLUTION_MARK_KEEP_FAILED',
+        error: err,
+        data: { proposalId: options.proposal },
+        nextActions: ['Verify the proposal id.'],
+        asJson: options.json
+    });
+}
+/** The `ok(...)` `data` payload for a confirmed `keep`. */
+function markKeepEnvelopeData(updated) {
+    return {
+        proposalId: updated.id,
+        verdict: updated.verdict,
+        user_confirmation_pointer: updated.user_confirmation_pointer ?? null,
+        score_delta: updated.proposal.score_delta,
+        score_delta_min: updated.proposal.score_delta_min
+    };
+}
+/** The `mark-keep` action body. */
+export function runMarkKeep(options, io) {
+    try {
+        const updated = withEvolutionDb(options.project, (svc) => svc.markVerdict(options.proposal, 'keep', options.userConfirmation));
+        if (!updated) {
+            printResult(io, proposalNotFoundFailure('evolution.mark-keep', options.proposal, [
+                'Verify the proposal id.'
+            ]), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, ok('evolution.mark-keep', markKeepEnvelopeData(updated), [], []), options.json);
+    }
+    catch (err) {
+        reportMarkKeepFailure(io, err, options);
+    }
+}
+/** The `revert` action body. */
+export function runRevert(options, io) {
+    try {
+        const updated = withEvolutionDb(options.project, (svc) => svc.revert(options.proposal, options.userConfirmation));
+        if (!updated) {
+            printResult(io, proposalNotFoundFailure('evolution.revert', options.proposal, ['Verify the proposal id.']), options.json);
+            process.exitCode = 1;
+            return;
+        }
+        printResult(io, ok('evolution.revert', {
+            proposalId: updated.id,
+            verdict: updated.verdict,
+            user_confirmation_pointer: updated.user_confirmation_pointer ?? null
+        }, [], []), options.json);
+    }
+    catch (err) {
+        reportFailure({
+            io,
+            command: 'evolution.revert',
+            code: 'EVOLUTION_REVERT_FAILED',
+            error: err,
+            data: { proposalId: options.proposal },
+            nextActions: ['Verify the proposal id.'],
+            asJson: options.json
+        });
+    }
+}
+/** Register `peaks evolution mark-keep` on the `evolution` parent. */
+export function registerMarkKeepCommand(evolution, io) {
+    addJsonOption(evolution
+        .command('mark-keep')
+        .description(MARK_KEEP_DESCRIPTION)
+        .requiredOption('--proposal <id>', 'proposal id')
+        .option('--user-confirmation <ptr>', 'pointer to the user choice record (AC-15) — omit to surface the EVOLUTION_MISSING_USER_CONFIRMATION service-layer error')
+        .option('--project <path>', 'project root (default: cwd)')).action((options) => runMarkKeep(options, io));
+}
+/** Register `peaks evolution revert` on the `evolution` parent. */
+export function registerRevertCommand(evolution, io) {
+    addJsonOption(evolution
+        .command('revert')
+        .description(REVERT_DESCRIPTION)
+        .requiredOption('--proposal <id>', 'proposal id')
+        .option('--user-confirmation <ptr>', 'optional pointer to the user choice record')
+        .option('--project <path>', 'project root (default: cwd)')).action((options) => runRevert(options, io));
+}

package/dist/cli/commands/finalize-accumulator.d.ts

@@ -0,0 +1,44 @@
+import type { DispatchRecord } from '../../services/dispatch/dispatch-record-writer.js';
+import type { FinalizeSelection } from './finalize-selection.js';
+interface FinalizedEntry {
+    recordPath: string;
+    requestId: string;
+    status: string;
+}
+interface SkippedEntry {
+    recordPath: string;
+    reason: string;
+}
+interface FailedEntry {
+    recordPath: string;
+    error: string;
+}
+/** The sweep's three counters, threaded explicitly instead of closed over. */
+export interface FinalizeAccumulator {
+    readonly finalized: FinalizedEntry[];
+    readonly skipped: SkippedEntry[];
+    readonly errors: FailedEntry[];
+}
+export interface MappedOutcome {
+    readonly status: 'done' | 'failed' | 'cancelled';
+    readonly outcome: 'success' | 'failed' | 'cancelled';
+}
+export declare const OUTCOME_MAP: Record<string, MappedOutcome>;
+export declare function makeAccumulator(): FinalizeAccumulator;
+/**
+ * N2 — one unreadable record must not abort the sweep.
+ *
+ * Skipping `active-dispatches.json` and `batch-*.counter.json` by FILENAME
+ * removed the two non-record files that happened to be in the directory, but a
+ * single stale or foreign `dispatch-*.json` (an old `version`, hand-edited
+ * JSON, a truncated write) still made `readRecord` throw from OUTSIDE any
+ * try/catch — and the throw escaped to the action's outer handler, so
+ * `--request-id` AND `--batch` both died with `FINALIZE_ERROR` and exit 1
+ * without touching a single healthy record.
+ *
+ * A record that cannot be read is now reported in `errors[]` and skipped;
+ * every other record is processed as before.
+ */
+export declare function tryReadRecord(recordPath: string, readRecord: (recordPath: string) => DispatchRecord, acc: FinalizeAccumulator): DispatchRecord | null;
+export declare function buildFinalizeHints(acc: FinalizeAccumulator, selection: FinalizeSelection | null): string[];
+export {};

package/dist/cli/commands/finalize-accumulator.js

@@ -0,0 +1,55 @@
+/**
+ * The finalize sweep's counters and the two pure helpers that read them, split
+ * out of `finalize-runners.ts` to keep each module under the line cap. The
+ * accumulator object replaces the mutable arrays the pre-split action closed
+ * over: it is created once and threaded explicitly through every branch.
+ */
+import { getErrorMessage } from 'peaks-loop-shared/result';
+// map outcome -> (status, outcome)
+export const OUTCOME_MAP = {
+    done: { status: 'done', outcome: 'success' },
+    failed: { status: 'failed', outcome: 'failed' },
+    cancelled: { status: 'cancelled', outcome: 'cancelled' }
+};
+export function makeAccumulator() {
+    return { finalized: [], skipped: [], errors: [] };
+}
+/**
+ * N2 — one unreadable record must not abort the sweep.
+ *
+ * Skipping `active-dispatches.json` and `batch-*.counter.json` by FILENAME
+ * removed the two non-record files that happened to be in the directory, but a
+ * single stale or foreign `dispatch-*.json` (an old `version`, hand-edited
+ * JSON, a truncated write) still made `readRecord` throw from OUTSIDE any
+ * try/catch — and the throw escaped to the action's outer handler, so
+ * `--request-id` AND `--batch` both died with `FINALIZE_ERROR` and exit 1
+ * without touching a single healthy record.
+ *
+ * A record that cannot be read is now reported in `errors[]` and skipped;
+ * every other record is processed as before.
+ */
+export function tryReadRecord(recordPath, readRecord, acc) {
+    try {
+        return readRecord(recordPath);
+    }
+    catch (e) {
+        acc.errors.push({ recordPath, error: getErrorMessage(e) });
+        return null;
+    }
+}
+export function buildFinalizeHints(acc, selection) {
+    const hints = [];
+    if (acc.errors.length > 0) {
+        hints.push('Re-run after fixing; unreadable records are listed in errors[] and were skipped, not fatal.');
+    }
+    else if (acc.finalized.length === 0 && acc.skipped.length > 0) {
+        hints.push("Nothing was finalized: every matching record had already left `queued`. See skipped[] for each record's status.");
+    }
+    else {
+        hints.push('All targeted records transitioned out of queued.');
+    }
+    if (selection !== null) {
+        hints.push(`--request-id selection (${selection.rule}): chose ${selection.chosen ?? '(none)'} of ${selection.matched} matching record(s); ${selection.rejected.length} rejected.`);
+    }
+    return hints;
+}

package/dist/cli/commands/finalize-branches.d.ts

@@ -0,0 +1,34 @@
+import { type ProgramIO } from '../cli-helpers.js';
+import type { ActiveDispatchEntry, DispatchRecord } from '../../services/dispatch/dispatch-record-writer.js';
+import { type FinalizeSelection } from './finalize-selection.js';
+import type { FinalizeAccumulator } from './finalize-accumulator.js';
+export declare function finalizeAllStale(input: {
+    readActiveDispatchIndex: (projectRoot: string, sessionId: string) => Record<string, ActiveDispatchEntry>;
+    projectRoot: string;
+    sessionId: string;
+    apply: (recordPath: string, rid: string) => void;
+    acc: FinalizeAccumulator;
+}): void;
+export declare function finalizeByRequestId(input: {
+    projectRoot: string;
+    sessionId: string;
+    requestId: string;
+    io: ProgramIO;
+    asJson: boolean;
+    readOne: (recordPath: string) => DispatchRecord | null;
+    apply: (recordPath: string, rid: string) => void;
+    acc: FinalizeAccumulator;
+}): Promise<{
+    kind: 'not-found';
+} | {
+    kind: 'ok';
+    selection: FinalizeSelection;
+}>;
+export declare function finalizeByBatch(input: {
+    projectRoot: string;
+    sessionId: string;
+    batchId: string | undefined;
+    readOne: (recordPath: string) => DispatchRecord | null;
+    apply: (recordPath: string, rid: string) => void;
+    acc: FinalizeAccumulator;
+}): Promise<void>;

package/dist/cli/commands/finalize-branches.js

@@ -0,0 +1,119 @@
+/**
+ * The three finalize sweep branches — `--all-stale`, `--request-id` and
+ * `--batch` — split out of `finalize-runners.ts` to keep each module under the
+ * line cap. Each branch reads records, decides which to act on, and records
+ * the outcome in the shared accumulator; the runner owns the envelope.
+ */
+import { fail, getErrorMessage } from 'peaks-loop-shared/result';
+import { printResult } from '../cli-helpers.js';
+import { FINALIZE_SELECTION_RULE, describeFinalizeRejection, selectFinalizeTarget } from './finalize-selection.js';
+import { safeRecordPath } from './share-record-paths.js';
+export function finalizeAllStale(input) {
+    const index = input.readActiveDispatchIndex(input.projectRoot, input.sessionId);
+    for (const [recordPath, entry] of Object.entries(index)) {
+        if (entry.status !== 'queued') {
+            input.acc.skipped.push({ recordPath, reason: 'status is ' + entry.status });
+            continue;
+        }
+        try {
+            input.apply(recordPath, entry.requestId);
+        }
+        catch (e) {
+            input.acc.errors.push({ recordPath, error: getErrorMessage(e) });
+        }
+    }
+}
+export async function finalizeByRequestId(input) {
+    const candidates = await collectRequestIdCandidates(input);
+    if (candidates.length === 0) {
+        printResult(input.io, fail('sub-agent.finalize', 'RECORD_NOT_FOUND', 'No dispatch record for requestId=' + input.requestId, { ok: false }, ['Check --request-id matches the dispatch envelope.']), input.asJson);
+        process.exitCode = 1;
+        return { kind: 'not-found' };
+    }
+    // N3: same rule as `--batch` — see `selectFinalizeTarget`.
+    const { selection, chosen } = buildRequestIdSelection(candidates, input.requestId);
+    for (const rejected of selection.rejected) {
+        input.acc.skipped.push({ recordPath: rejected.recordPath, reason: rejected.reason });
+    }
+    if (chosen !== null) {
+        try {
+            input.apply(chosen.recordPath, chosen.requestId);
+        }
+        catch (e) {
+            input.acc.errors.push({ recordPath: chosen.recordPath, error: getErrorMessage(e) });
+        }
+    }
+    return { kind: 'ok', selection };
+}
+async function collectRequestIdCandidates(input) {
+    const fs2 = await import('node:fs');
+    const path2 = await import('node:path');
+    const dir = path2.resolve(input.projectRoot, '.peaks', '_sub_agents', input.sessionId);
+    const candidates = [];
+    if (fs2.existsSync(dir)) {
+        for (const f of fs2.readdirSync(dir)) {
+            // Only dispatch records are readable records. The session directory also
+            // holds `active-dispatches.json` (an index) and `batch-<uuid>.counter.json`
+            // (batch counters); neither carries a `version` field, so `readRecord` on
+            // them throws `Dispatch record version mismatch ... got undefined`. The
+            // `--batch` branch below has always used this same filter.
+            if (!f.startsWith('dispatch-') || !f.endsWith('.json'))
+                continue;
+            const p = safeRecordPath(path2.join(dir, f));
+            const r = input.readOne(p);
+            if (r === null || r.requestId !== input.requestId)
+                continue;
+            candidates.push({
+                recordPath: p,
+                requestId: r.requestId,
+                status: r.status,
+                createdAt: r.createdAt
+            });
+        }
+    }
+    return candidates;
+}
+function buildRequestIdSelection(candidates, requestId) {
+    const chosen = selectFinalizeTarget(candidates);
+    const selection = {
+        requestId,
+        rule: FINALIZE_SELECTION_RULE,
+        matched: candidates.length,
+        chosen: chosen?.recordPath ?? null,
+        rejected: candidates
+            .filter((candidate) => candidate !== chosen)
+            .map((candidate) => ({
+            recordPath: candidate.recordPath,
+            status: candidate.status,
+            reason: describeFinalizeRejection(candidate, chosen)
+        }))
+    };
+    return { selection, chosen };
+}
+export async function finalizeByBatch(input) {
+    const fs2 = await import('node:fs');
+    const path2 = await import('node:path');
+    const dir = path2.resolve(input.projectRoot, '.peaks', '_sub_agents', input.sessionId);
+    if (!fs2.existsSync(dir))
+        return;
+    for (const f of fs2.readdirSync(dir)) {
+        if (!f.startsWith('dispatch-') || !f.endsWith('.json'))
+            continue;
+        const p = safeRecordPath(path2.join(dir, f));
+        const r = input.readOne(p);
+        if (r === null)
+            continue;
+        if (r.batchId !== input.batchId)
+            continue;
+        if (r.status !== 'queued') {
+            input.acc.skipped.push({ recordPath: p, reason: 'status is ' + r.status });
+            continue;
+        }
+        try {
+            input.apply(p, r.requestId);
+        }
+        catch (e) {
+            input.acc.errors.push({ recordPath: p, error: getErrorMessage(e) });
+        }
+    }
+}

package/dist/cli/commands/finalize-runners.d.ts

@@ -0,0 +1,3 @@
+import { type ProgramIO } from '../cli-helpers.js';
+import type { FinalizeOptions } from './finalize-selection.js';
+export declare function runFinalize(options: FinalizeOptions, io: ProgramIO): Promise<void>;