@namzu/cli 29.0.1 → 29.1.0

package/dist/schedule/commands/lifecycle.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `schedule pause | resume | remove | run-now | prune`.
+ *
+ * Resuming does not catch up what came due while the job was paused: the
+ * resume is a definition change, and the evaluator counts from it.
+ */
+import type { CommandContext } from '../../commands/types.js';
+import { EXIT_UNAVAILABLE } from '../../exit-codes.js';
+import { type FireDependencies } from '../fire/fire.js';
+import type { SchedulePaths } from '../paths.js';
+import type { ScheduleJobState } from '../types.js';
+export declare function pauseCommand(ctx: CommandContext, argv: readonly string[], resume?: boolean): Promise<number>;
+export declare function removeCommand(ctx: CommandContext, argv: readonly string[]): Promise<number>;
+/**
+ * Record the end of a job's parked run that was answered elsewhere (the TUI)
+ * and has since finished, as a scheduler's tick would. A scheduler that
+ * answers is asked to look now instead; with none, it is settled here.
+ * Idempotent: a run is settled only while the job's state still names it as
+ * parked and its turn is over, so a scheduler settling it too finds nothing
+ * left. Returns the job's state afterwards, or `undefined` for no such job.
+ */
+export declare function settleAnsweredPark(paths: SchedulePaths, jobId: string): Promise<ScheduleJobState | undefined>;
+export declare function runNowCommand(ctx: CommandContext, argv: readonly string[], 
+/** Test seam: what the foreground run is given. */
+fireDeps?: Omit<FireDependencies, 'keepLogging'>): Promise<number>;
+/**
+ * `schedule prune`: list — and with `--delete`, remove — run files and the
+ * sessions of runs that ended before `--older-than` (default 30 days).
+ * Sessions of runs still parked are never touched.
+ *
+ * A removed job's runs are included (without `--job`): `remove` keeps its
+ * history and run files, and nothing else would ever reach them. Once none
+ * of its runs is left, its history goes too.
+ */
+export declare function pruneCommand(ctx: CommandContext, argv: readonly string[]): Promise<number>;
+/** The size of what the scheduler keeps, for `status`. */
+export declare function scheduleDiskUsage(root: string): number;
+export { EXIT_UNAVAILABLE };
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/schedule/commands/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/schedule/commands/lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAaH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,EAAW,gBAAgB,EAAc,MAAM,qBAAqB,CAAA;AAM3E,OAAO,EAAE,KAAK,gBAAgB,EAAW,MAAM,iBAAiB,CAAA;AAEhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAahD,OAAO,KAAK,EAGX,gBAAgB,EAEhB,MAAM,aAAa,CAAA;AAIpB,wBAAsB,YAAY,CACjC,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,MAAM,UAAQ,GACZ,OAAO,CAAC,MAAM,CAAC,CA8CjB;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAqEjG;AAgDD;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACvC,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAIvC;AAED,wBAAsB,aAAa,CAClC,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,SAAS,MAAM,EAAE;AACvB,mDAAmD;AACnD,QAAQ,GAAE,IAAI,CAAC,gBAAgB,EAAE,aAAa,CAAM,GAClD,OAAO,CAAC,MAAM,CAAC,CAoJjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoJhG;AAoFD,0DAA0D;AAC1D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBtD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/schedule/commands/lifecycle.js

@@ -0,0 +1,585 @@
+/**
+ * `schedule pause | resume | remove | run-now | prune`.
+ *
+ * Resuming does not catch up what came due while the job was paused: the
+ * resume is a definition change, and the evaluator counts from it.
+ */
+import { readdirSync, rmSync, statSync } from 'node:fs';
+import { constants as osConstants } from 'node:os';
+import { join } from 'node:path';
+import { NOOP_LOGGER, SessionPaths, asSessionId, generateScheduleRunId, openSessionIndex, releaseHeldSessionLeases, } from '@namzu/sdk';
+import { EXIT_OK, EXIT_UNAVAILABLE, EXIT_USAGE } from '../../exit-codes.js';
+import { closeSessions, refreshIndex } from '../../integrations/sessions/store.js';
+import { CLI_VERSION } from '../../version.js';
+import { MANUAL_KEY_PREFIX, ScheduleDaemon, appendRunRecord } from '../daemon/daemon.js';
+import { callEndpoint, readEndpoint } from '../daemon/endpoint.js';
+import { abandonParkedTurn, sessionFacts, sessionLeaseLive } from '../daemon/sessions.js';
+import { runFire } from '../fire/fire.js';
+import { isFinal, readRunResult } from '../fire/result.js';
+import { resumeCommand } from '../resume-command.js';
+import { claimOccurrence } from '../store/claims.js';
+import { appendHistory, foldHistory, readHistory } from '../store/history.js';
+import { confirmationHolds, deleteJob, findJob, listJobs, readJob, updateJob, } from '../store/jobs.js';
+import { readState, writeState } from '../store/state.js';
+import { flag, has, interactive, parseArgs, parseMs, pathsFor } from './args.js';
+import { askYesNo } from './confirm-prompt.js';
+export async function pauseCommand(ctx, argv, resume = false) {
+    const args = parseArgs(argv, ['home']);
+    if (args.unknown.length > 0 || !args.positionals[0]) {
+        ctx.formatter.error({ message: `usage: namzu schedule ${resume ? 'resume' : 'pause'} <job>` });
+        return EXIT_USAGE;
+    }
+    const paths = pathsFor(args);
+    try {
+        const job = findJob(paths, args.positionals[0]);
+        if (resume) {
+            if (job.state !== 'paused') {
+                ctx.formatter.error({ message: `${job.name} is ${job.state}, not paused` });
+                return 1;
+            }
+            if (!confirmationHolds(job)) {
+                ctx.formatter.error({
+                    message: `${job.name} changed since it was confirmed; confirm it with \`namzu schedule confirm ${job.name}\``,
+                });
+                return 1;
+            }
+        }
+        else if (job.state !== 'active' && job.state !== 'pending-confirmation') {
+            ctx.formatter.error({ message: `${job.name} is ${job.state}` });
+            return 1;
+        }
+        const now = new Date();
+        const next = updateJob(paths, job.id, job.revision, (j) => resume
+            ? { ...j, state: 'active', pausedAt: undefined, pausedBy: undefined }
+            : { ...j, state: 'paused', pausedAt: now.toISOString(), pausedBy: 'operator' });
+        appendHistory(paths, job.id, {
+            v: 1,
+            kind: 'job',
+            at: now.toISOString(),
+            action: resume ? 'resumed' : 'paused',
+            by: 'operator',
+        });
+        ctx.formatter.print({
+            text: `${next.name} ${resume ? 'resumed' : 'paused'}.`,
+            state: next.state,
+        });
+        return EXIT_OK;
+    }
+    catch (error) {
+        ctx.formatter.error({ message: error instanceof Error ? error.message : String(error) });
+        return 1;
+    }
+}
+export async function removeCommand(ctx, argv) {
+    const args = parseArgs(argv, ['home', 'yes!', 'force!']);
+    if (args.unknown.length > 0 || !args.positionals[0]) {
+        ctx.formatter.error({ message: 'usage: namzu schedule remove <job> [--yes] [--force]' });
+        return EXIT_USAGE;
+    }
+    const paths = pathsFor(args);
+    try {
+        const job = findJob(paths, args.positionals[0]);
+        const state = readState(paths, job.id);
+        if (state.activeRun && !has(args, 'force')) {
+            ctx.formatter.error({
+                message: state.activeRun.status === 'awaiting-approval'
+                    ? `${job.name} has a run waiting for approval; pass --force to remove the job anyway (the waiting turn is abandoned)`
+                    : `${job.name} has a run in progress; pass --force to remove the job anyway (the run is left to finish)`,
+            });
+            return 1;
+        }
+        if (!has(args, 'yes')) {
+            if (!interactive()) {
+                ctx.formatter.error({ message: 'no terminal to confirm on; pass --yes' });
+                return EXIT_USAGE;
+            }
+            if (!(await askYesNo(`Remove the scheduled job ${job.name}? Its history is kept.`)))
+                return 1;
+        }
+        // A park nobody can answer once the job is gone: its turn is closed and
+        // the run recorded now. A run still going records its own end.
+        const parked = state.activeRun?.status === 'awaiting-approval' ? state.activeRun : undefined;
+        if (parked) {
+            const abandoned = await abandonRemovedPark(paths, parked);
+            if (!abandoned.ok) {
+                ctx.formatter.error({ message: `${job.name}: ${abandoned.reason}; not removed` });
+                return 1;
+            }
+        }
+        deleteJob(paths, job.id);
+        if (parked) {
+            appendRunRecord(paths, job.id, parked, {
+                v: 1,
+                kind: 'schedule-run-result',
+                runId: parked.runId,
+                jobId: job.id,
+                startedAt: parked.startedAt,
+                ...(parked.sessionId ? { sessionId: parked.sessionId } : {}),
+                status: 'cancelled',
+                exitCode: 1,
+                reason: 'the job was removed while the run waited for approval',
+            }, new Date().toISOString());
+        }
+        appendHistory(paths, job.id, {
+            v: 1,
+            kind: 'job',
+            at: new Date().toISOString(),
+            action: 'removed',
+            by: 'operator',
+        });
+        ctx.formatter.print({ text: `Removed ${job.name}.` });
+        return EXIT_OK;
+    }
+    catch (error) {
+        ctx.formatter.error({ message: error instanceof Error ? error.message : String(error) });
+        return 1;
+    }
+}
+const REMOVED_PARK_REASON = 'Scheduled run: the job was removed';
+/** Close the parked turn of a job being removed, unless someone is answering it right now. */
+async function abandonRemovedPark(paths, run) {
+    if (!run.sessionId || !run.projectSlug || !run.turnId)
+        return { ok: true };
+    const ref = { home: paths.home, projectSlug: run.projectSlug, sessionId: run.sessionId };
+    if (await sessionLeaseLive(ref)) {
+        return { ok: false, reason: 'its waiting run is open in a session right now' };
+    }
+    const facts = await sessionFacts(ref);
+    if (facts?.activeTurn?.turnId !== run.turnId || !facts.activeTurn.paused)
+        return { ok: true };
+    try {
+        await abandonParkedTurn(ref, run.turnId, REMOVED_PARK_REASON);
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `its waiting turn could not be closed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+/** The epoch a foreground `run-now` records its run under. */
+const FOREGROUND_EPOCH = 'foreground';
+/** A daemon that starts nothing: it records and settles a foreground run as a scheduler would. */
+function foregroundRecorder(paths) {
+    return new ScheduleDaemon({
+        paths,
+        log: NOOP_LOGGER,
+        version: CLI_VERSION,
+        epoch: FOREGROUND_EPOCH,
+        maxConcurrentRuns: 1,
+        // The operator is at this terminal.
+        notifications: false,
+        spawnFire: () => {
+            throw new Error('a foreground recorder starts no runs');
+        },
+        notify: async () => { },
+        fingerprint: () => '',
+    });
+}
+/**
+ * Record the end of a job's parked run that was answered elsewhere (the TUI)
+ * and has since finished, as a scheduler's tick would. A scheduler that
+ * answers is asked to look now instead; with none, it is settled here.
+ * Idempotent: a run is settled only while the job's state still names it as
+ * parked and its turn is over, so a scheduler settling it too finds nothing
+ * left. Returns the job's state afterwards, or `undefined` for no such job.
+ */
+export async function settleAnsweredPark(paths, jobId) {
+    const endpoint = readEndpoint(paths.endpoint);
+    if (endpoint && (await callEndpoint(endpoint, 'reload')))
+        return readState(paths, jobId);
+    return foregroundRecorder(paths).reconcileJob(jobId);
+}
+export async function runNowCommand(ctx, argv, 
+/** Test seam: what the foreground run is given. */
+fireDeps = {}) {
+    const args = parseArgs(argv, ['home']);
+    if (args.unknown.length > 0 || !args.positionals[0]) {
+        ctx.formatter.error({ message: 'usage: namzu schedule run-now <job>' });
+        return EXIT_USAGE;
+    }
+    const paths = pathsFor(args);
+    try {
+        const job = findJob(paths, args.positionals[0]);
+        const endpoint = readEndpoint(paths.endpoint);
+        if (endpoint) {
+            const answer = await callEndpoint(endpoint, 'run-now', { jobId: job.id });
+            if (answer) {
+                if (answer.ok) {
+                    ctx.formatter.print({
+                        text: `${job.name} queued with the scheduler; follow it with \`namzu schedule history ${job.name}\`.`,
+                    });
+                    return EXIT_OK;
+                }
+                ctx.formatter.error({ message: String(answer.message ?? 'refused') });
+                return 1;
+            }
+        }
+        // No daemon: run it here, in the foreground, with the same once-only claim.
+        if (job.state !== 'active' || !confirmationHolds(job)) {
+            ctx.formatter.error({ message: `${job.name} is not active and confirmed` });
+            return 1;
+        }
+        const recorder = foregroundRecorder(paths);
+        let state = readState(paths, job.id);
+        // An earlier foreground run whose process is gone (killed, the terminal
+        // closed) is settled first, as a scheduler would settle it.
+        if (state.activeRun?.daemonEpoch === FOREGROUND_EPOCH)
+            state = (await recorder.reconcileJob(job.id)) ?? state;
+        if (state.activeRun) {
+            ctx.formatter.error({
+                message: `${job.name} already has a run ${state.activeRun.status === 'awaiting-approval' ? 'waiting for approval' : 'in progress'}`,
+            });
+            return 1;
+        }
+        const runId = generateScheduleRunId();
+        const key = `${MANUAL_KEY_PREFIX}${runId}`;
+        const startedAt = new Date().toISOString();
+        if (!claimOccurrence(paths, {
+            jobId: job.id,
+            key,
+            runId,
+            daemonEpoch: FOREGROUND_EPOCH,
+            at: startedAt,
+        }))
+            return 1;
+        ctx.formatter.info(`The scheduler is not running; running ${job.name} here.`);
+        // Recorded as the job's run in progress, as a daemon's run is: a
+        // scheduler that starts meanwhile adopts it instead of starting the
+        // next occurrence beside it, and a park is found by `/resume`, held
+        // against later occurrences and expired like any other.
+        const run = {
+            runId,
+            key,
+            trigger: 'manual',
+            startedAt,
+            daemonEpoch: FOREGROUND_EPOCH,
+            status: 'running',
+        };
+        writeState(paths, { ...readState(paths, job.id), activeRun: run });
+        appendHistory(paths, job.id, {
+            v: 1,
+            kind: 'run',
+            at: startedAt,
+            runId,
+            key,
+            trigger: 'manual',
+            startedAt,
+            status: 'running',
+        });
+        // How the run ended is recorded once, whichever way it ends: runFire
+        // returning, its watchdog stopping the process, or a signal.
+        let recorded;
+        const record = (code, reason) => {
+            recorded ??= (async () => {
+                const written = readRunResult(paths, job.id, runId);
+                const result = isFinal(written)
+                    ? written
+                    : {
+                        v: 1,
+                        kind: 'schedule-run-result',
+                        runId,
+                        jobId: job.id,
+                        startedAt,
+                        ...(written ?? {}),
+                        status: 'interrupted',
+                        exitCode: code || 1,
+                        reason,
+                    };
+                if (!(await recorder.finalizeRun(job.id, runId, result)) && !readJob(paths, job.id)) {
+                    // Removed with --force meanwhile: nothing else will record it.
+                    appendRunRecord(paths, job.id, run, result, new Date().toISOString());
+                }
+                return result;
+            })();
+            return recorded;
+        };
+        const exit = fireDeps.exit ?? ((c) => process.exit(c));
+        const onSignal = (signal) => {
+            const code = 128 + (osConstants.signals[signal] ?? 1);
+            void record(code, `the run was interrupted (${signal})`)
+                .catch(() => undefined)
+                .then(() => releaseHeldSessionLeases().catch(() => undefined))
+                .finally(() => exit(code));
+        };
+        const handlers = ['SIGINT', 'SIGTERM', 'SIGHUP'].map((signal) => [signal, () => onSignal(signal)]);
+        for (const [signal, handler] of handlers)
+            process.on(signal, handler);
+        let code;
+        try {
+            // This terminal's logging stays as the operator set it; a run started by
+            // the daemon writes JSON lines into its log file instead.
+            code = await runFire(ctx, paths, { jobId: job.id, runId, key, revision: job.revision, trigger: 'manual' }, {
+                ...fireDeps,
+                keepLogging: true,
+                // The watchdog has written `timed-out`; record it before the process goes.
+                exit: (c) => {
+                    void record(c, 'the run ended without recording a result')
+                        .catch(() => undefined)
+                        .finally(() => exit(c));
+                },
+            });
+        }
+        finally {
+            for (const [signal, handler] of handlers)
+                process.off(signal, handler);
+        }
+        const result = await record(code, 'the run ended without recording a result');
+        ctx.formatter.print({
+            text: `${job.name}: ${result?.status ?? 'interrupted'}${result?.reason ? ` — ${result.reason}` : ''}${result?.sessionId ? `\nsession ${result.sessionId}` : ''}${result?.status === 'awaiting-approval' && result.sessionId ? `\nanswer it: ${resumeCommand(job, result.sessionId)}` : ''}`,
+            status: result?.status,
+        });
+        return code;
+    }
+    catch (error) {
+        ctx.formatter.error({ message: error instanceof Error ? error.message : String(error) });
+        return 1;
+    }
+}
+/**
+ * `schedule prune`: list — and with `--delete`, remove — run files and the
+ * sessions of runs that ended before `--older-than` (default 30 days).
+ * Sessions of runs still parked are never touched.
+ *
+ * A removed job's runs are included (without `--job`): `remove` keeps its
+ * history and run files, and nothing else would ever reach them. Once none
+ * of its runs is left, its history goes too.
+ */
+export async function pruneCommand(ctx, argv) {
+    const args = parseArgs(argv, ['home', 'job', 'older-than', 'delete!', 'yes!']);
+    if (args.unknown.length > 0) {
+        ctx.formatter.error({ message: `unknown option: ${args.unknown.join(', ')}` });
+        return EXIT_USAGE;
+    }
+    const paths = pathsFor(args);
+    const olderThan = parseMs('--older-than', flag(args, 'older-than')) ?? 30 * 86_400_000;
+    const cutoff = Date.now() - olderThan;
+    const live = flag(args, 'job')
+        ? [findJob(paths, flag(args, 'job'))]
+        : listJobs(paths).jobs;
+    const subjects = live.map((job) => {
+        const active = readState(paths, job.id).activeRun?.runId;
+        return { id: job.id, name: job.name, removed: false, ...(active ? { active } : {}) };
+    });
+    if (!flag(args, 'job')) {
+        const known = new Set(listJobIds(paths));
+        for (const id of removedJobIds(paths, known))
+            subjects.push({ id, name: `removed job ${id}`, removed: true });
+    }
+    const doomed = [];
+    /** Removed jobs every one of whose runs is doomed: their history goes too. */
+    const emptied = [];
+    for (const subject of subjects) {
+        const kept = new Set();
+        const seen = new Set();
+        for (const folded of foldHistory(readHistory(paths, subject.id))) {
+            if (folded.kind !== 'run')
+                continue;
+            seen.add(folded.runId);
+            // A removed job's run the history still shows open had nobody left to
+            // record its end: its own result, or its session, says whether it did.
+            const r = subject.removed ? await settleRemovedRun(paths, subject.id, folded) : folded;
+            if (r.runId === subject.active ||
+                r.status === 'awaiting-approval' ||
+                r.status === 'running' ||
+                !(Date.parse(r.endedAt ?? r.at) < cutoff)) {
+                kept.add(r.runId);
+                continue;
+            }
+            const result = readRunResult(paths, subject.id, r.runId);
+            doomed.push({
+                subject,
+                runId: r.runId,
+                ...(r.sessionId ? { sessionId: r.sessionId } : {}),
+                ...(result?.projectSlug ? { slug: result.projectSlug } : {}),
+            });
+        }
+        // Run files history does not name (a removed job's, or a run that never
+        // got a record): by the result's end time, else the file's.
+        if (subject.removed) {
+            for (const runId of runIdsOnDisk(paths, subject.id)) {
+                if (seen.has(runId))
+                    continue;
+                const result = readRunResult(paths, subject.id, runId);
+                const ended = result?.endedAt
+                    ? Date.parse(result.endedAt)
+                    : mtimeOf(paths, subject.id, runId);
+                if (result?.status === 'running' ||
+                    result?.status === 'awaiting-approval' ||
+                    !(ended < cutoff)) {
+                    kept.add(runId);
+                    continue;
+                }
+                doomed.push({
+                    subject,
+                    runId,
+                    ...(result?.sessionId ? { sessionId: result.sessionId } : {}),
+                    ...(result?.projectSlug ? { slug: result.projectSlug } : {}),
+                });
+            }
+            if (kept.size === 0)
+                emptied.push(subject);
+        }
+    }
+    const lines = [
+        ...doomed.map((d) => `${d.subject.name}  run ${d.runId}${d.sessionId ? `  session ${d.sessionId}` : ''}`),
+        ...emptied.map((subject) => `${subject.name}  history`),
+    ];
+    if (!has(args, 'delete')) {
+        ctx.formatter.print(lines.length === 0
+            ? 'Nothing older than the cutoff.'
+            : `Would delete ${doomed.length} runs${emptied.length > 0 ? ` and the history of ${emptied.length} removed jobs` : ''} (pass --delete):\n${lines.join('\n')}`);
+        return EXIT_OK;
+    }
+    if (lines.length === 0) {
+        ctx.formatter.print('Nothing older than the cutoff.');
+        return EXIT_OK;
+    }
+    ctx.formatter.info(`Deleting:\n${lines.join('\n')}`);
+    if (!has(args, 'yes')) {
+        if (!interactive()) {
+            ctx.formatter.error({ message: 'no terminal to confirm on; pass --yes' });
+            return EXIT_USAGE;
+        }
+        if (!(await askYesNo('Delete these runs and their sessions?')))
+            return 1;
+    }
+    const touched = [];
+    for (const d of doomed) {
+        rmSync(paths.runResult(d.subject.id, d.runId), { force: true });
+        rmSync(paths.runLog(d.subject.id, d.runId), { force: true });
+        if (d.sessionId && d.slug) {
+            const sp = new SessionPaths({ home: paths.home, slug: d.slug });
+            const locator = { sessionId: asSessionId(d.sessionId) };
+            rmSync(sp.sessionLog(locator), { force: true });
+            rmSync(sp.sessionDir(locator), { recursive: true, force: true });
+            touched.push({ slug: d.slug, sessionId: d.sessionId });
+        }
+    }
+    for (const subject of emptied) {
+        rmSync(paths.historyOf(subject.id), { force: true });
+        rmSync(paths.runsOf(subject.id), { recursive: true, force: true });
+    }
+    // The session index learns each deleted session is gone. By slug, so a
+    // removed job's folder need not be known.
+    if (touched.length > 0) {
+        try {
+            const index = await openSessionIndex({ home: paths.home });
+            try {
+                for (const t of touched) {
+                    await refreshIndex({ paths: new SessionPaths({ home: paths.home, slug: t.slug }), slug: t.slug, index }, asSessionId(t.sessionId)).catch(() => undefined);
+                }
+            }
+            finally {
+                closeSessions({ index });
+            }
+        }
+        catch { }
+    }
+    ctx.formatter.print({
+        text: `Deleted ${doomed.length} runs${emptied.length > 0 ? ` and the history of ${emptied.length} removed jobs` : ''}.`,
+    });
+    return EXIT_OK;
+}
+/**
+ * A removed job's run as it stands, when its history still shows it open:
+ * ended as its result file says, or `interrupted` once no process holds its
+ * session. A park is over: nobody can answer the park of a job that is gone.
+ */
+async function settleRemovedRun(paths, jobId, r) {
+    if (r.status !== 'running' && r.status !== 'awaiting-approval')
+        return r;
+    const result = readRunResult(paths, jobId, r.runId);
+    if (isFinal(result) && result?.status !== 'awaiting-approval') {
+        return {
+            ...r,
+            status: result?.status,
+            endedAt: result?.endedAt ?? r.at,
+            ...(result?.sessionId ? { sessionId: result.sessionId } : {}),
+        };
+    }
+    const sessionId = result?.sessionId ?? r.sessionId;
+    if (sessionId && result?.projectSlug) {
+        const ref = { home: paths.home, projectSlug: result.projectSlug, sessionId };
+        if (await sessionLeaseLive(ref))
+            return r;
+    }
+    else if (r.status === 'running' && Date.now() - Date.parse(r.startedAt) < 60_000) {
+        return r;
+    }
+    const ended = mtimeOf(paths, jobId, r.runId);
+    return {
+        ...r,
+        status: r.status === 'awaiting-approval' ? 'cancelled' : 'interrupted',
+        endedAt: new Date(Number.isFinite(ended) ? ended : Date.parse(r.at)).toISOString(),
+    };
+}
+/** Job ids with a definition file. */
+function listJobIds(paths) {
+    return namesIn(paths.jobs)
+        .filter((n) => n.endsWith('.json'))
+        .map((n) => n.slice(0, -'.json'.length));
+}
+/** Ids that have run files or history but no definition any more. */
+function removedJobIds(paths, known) {
+    const ids = new Set([
+        ...namesIn(paths.runs),
+        ...namesIn(paths.history)
+            .filter((n) => n.endsWith('.jsonl'))
+            .map((n) => n.slice(0, -'.jsonl'.length)),
+    ]);
+    return [...ids].filter((id) => !known.has(id)).sort();
+}
+function runIdsOnDisk(paths, jobId) {
+    return [
+        ...new Set(namesIn(paths.runsOf(jobId))
+            .filter((n) => n.endsWith('.json') || n.endsWith('.log'))
+            .map((n) => n.replace(/\.(json|log)$/, ''))),
+    ];
+}
+function mtimeOf(paths, jobId, runId) {
+    for (const path of [paths.runResult(jobId, runId), paths.runLog(jobId, runId)]) {
+        try {
+            return statSync(path).mtimeMs;
+        }
+        catch { }
+    }
+    return Number.NaN;
+}
+function namesIn(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/** The size of what the scheduler keeps, for `status`. */
+export function scheduleDiskUsage(root) {
+    let total = 0;
+    const visit = (dir) => {
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            const path = join(dir, name);
+            try {
+                const st = statSync(path);
+                if (st.isDirectory())
+                    visit(path);
+                else
+                    total += st.size;
+            }
+            catch { }
+        }
+    };
+    visit(root);
+    return total;
+}
+export { EXIT_UNAVAILABLE };
+//# sourceMappingURL=lifecycle.js.map