@detergent-software/conductor 0.0.0-stage → 1.0.0-dev.2

package/build/manager.js

@@ -0,0 +1,614 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { isLive, isStarting, permissionPrompt, turnEnded } from "./claude.js";
+import { formatCondition, parseCondition, uncheckable } from "./conditions.js";
+import { ConductorError } from "./errors.js";
+import { processAlive as defaultProcessAlive } from "./lock.js";
+import { resolveOpenWait } from "./resolve.js";
+import { findTranscript, localDay, projectSlug, readUsage, transcriptFiles } from "./spend.js";
+import { ACTIVE_STATUSES, waitSchema, workerSchema, } from "./store.js";
+// A worker as GET /fleet shows it.
+export const fleetWorkerSchema = workerSchema.extend({
+    // launching, starting, working, idle, waiting on <x>, parked, stopped, no session
+    activity: z.string(),
+    spend: z.object({ today: z.number(), total: z.number() }),
+    waits: z.array(waitSchema),
+});
+export const PROBE_PREFIX = 'probe-';
+export const PROBE_PROMPT = 'This is a conductor probe session started by a test run. It works no issue: reply "probe ready" and wait.';
+// conduct-atk starts workers this way; a resume keeps both (ATK-309's open check).
+export const PERMISSION_MODE = 'auto';
+export const DISALLOWED_TOOLS = ['EnterPlanMode', 'ExitPlanMode'];
+const ITEM = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const STOP_WAIT_MS = 30_000;
+// A park that failed (the process outlived `claude stop`) is tried again this much later.
+const PARK_RETRY_MS = 5 * 60_000;
+const TRANSCRIPT_SCAN_MS = 60_000;
+// The statuses a sweep looks at; a launching worker belongs to its launch.
+const SWEPT = ['running', 'parked', 'stopped-unexpectedly'];
+// The resume text: facts only, as a user turn (design note, section 4), such as
+// `[conductor] event: time 2026-10-10T22:05:00.000Z reached 22:05`. The worker re-reads the source.
+export function eventText(waits) {
+    const facts = waits.map((w) => `${w.resolution ?? w.condition} ${clock(new Date(w.resolvedAt ?? w.createdAt))}`);
+    return `[conductor] event: ${facts.join('; ')}`;
+}
+export function sessionManager(deps) {
+    const { claude, config, log, openTab, store, worktrees } = deps;
+    const now = deps.now ?? (() => new Date());
+    const alive = deps.processAlive ?? defaultProcessAlive;
+    const sleep = deps.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+    // Workers with an operation in flight (launch, park, resume, retire, attach): a sweep leaves them alone.
+    const busy = new Set();
+    const tasks = new Set();
+    const stalls = new Map();
+    const transcripts = new Map();
+    const transcriptScans = new Map();
+    let sessions = [];
+    // Until the first sweep, nothing is known about any session.
+    let listed = false;
+    let sweeping = null;
+    let timer;
+    const event = (worker, kind, data = {}) => {
+        const entry = { data: { name: worker.name, worker: worker.id, ...data }, kind, project: worker.project, subject: worker.item };
+        store.appendEvent(entry);
+    };
+    const update = (worker, patch) => store.updateWorker(worker.id, patch);
+    const track = (task) => {
+        tasks.add(task);
+        void task.finally(() => tasks.delete(task)).catch(() => { });
+        return task;
+    };
+    const project = (name) => {
+        const projects = store.listProjects();
+        const found = name === undefined && projects.length === 1 ? projects[0] : projects.find((p) => p.name === name);
+        if (!found) {
+            throw new ConductorError(name === undefined ? 'name the project' : `no project "${name}"`, [
+                `registered: ${projects.map((p) => p.name).join(', ') || 'none'}`,
+            ]);
+        }
+        if (!found.profile)
+            throw new ConductorError(`project "${found.name}" has a problem: ${found.problem ?? 'no profile'}`);
+        if (!found.enabled)
+            throw new ConductorError(`project "${found.name}" is disabled`);
+        return { ...found, profile: found.profile };
+    };
+    // Where a worker's commands run: its project's main checkout, where conduct-atk starts them too.
+    const rootOf = (worker) => store.listProjects().find((p) => p.name === worker.project)?.root ?? worker.worktree ?? process.cwd();
+    const sessionOf = (worker) => sessions.find((s) => (worker.sessionId !== null && s.sessionId === worker.sessionId) || (worker.handle !== null && s.id === worker.handle));
+    const minutesSince = (iso) => (now().getTime() - Date.parse(iso)) / 60_000;
+    // `claude stop`, then wait until its process has exited: the listing can drop the pid first.
+    const stopAndWait = async (handle, pid) => {
+        await claude.stop(handle);
+        if (pid === undefined)
+            return true;
+        for (let waited = 0; alive(pid); waited += 250) {
+            if (waited >= STOP_WAIT_MS)
+                return false;
+            await sleep(250);
+        }
+        return true;
+    };
+    const step = async (steps, name, action) => {
+        try {
+            await action();
+            steps.push({ ok: true, step: name });
+            return true;
+        }
+        catch (error) {
+            steps.push({ error: messageOf(error), ok: false, step: name });
+            return false;
+        }
+    };
+    // ---------- launch ----------
+    const launchWorker = async (worker, root, profile, prompt) => {
+        let current = worker;
+        let stage = 'create worktree';
+        try {
+            const worktree = await worktrees.create(root, worker.name);
+            current = update(current, { branch: await worktrees.branchOf(worktree), worktree });
+            stage = 'check skills';
+            const problem = await worktrees.checkSkills(worktree, [profile.skills.work, profile.skills.verify]);
+            if (problem)
+                throw new ConductorError(problem);
+            stage = 'start session';
+            const handle = await claude.launch({
+                cwd: root,
+                disallowedTools: DISALLOWED_TOOLS,
+                name: worker.name,
+                permissionMode: PERMISSION_MODE,
+                prompt,
+                worktree: worker.name,
+            });
+            try {
+                sessions = await claude.agents();
+                listed = true;
+            }
+            catch {
+                // The next sweep lists it; until then the worker has no session id.
+            }
+            const session = sessions.find((s) => s.id === handle);
+            current = update(current, { handle, sessionId: session?.sessionId ?? null, status: 'running' });
+            event(current, 'worker.launched', { handle, sessionId: current.sessionId, worktree });
+            if (profile.workers.tab) {
+                const tab = await openTab({
+                    cwd: root,
+                    handle,
+                    title: worker.name,
+                    window: `${worker.probe ? 'probe' : 'Conductor'} · ${worker.project}`,
+                });
+                if (tab)
+                    event(current, 'worker.tab-failed', { error: tab });
+            }
+        }
+        catch (error) {
+            // A worktree with no session would read as in flight; one with work in it is kept.
+            const cleanup = current.worktree ? await removeIfClean(root, current.worktree) : {};
+            current = update(current, { status: 'failed' });
+            event(current, 'worker.launch-failed', { error: messageOf(error), step: stage, ...cleanup });
+            log.log('warn', 'launch failed', { error: messageOf(error), step: stage, worker: worker.id });
+        }
+    };
+    const removeIfClean = async (root, worktree) => {
+        try {
+            const work = await worktrees.unfinishedWork(worktree);
+            if (work)
+                return { kept: worktree, ...work };
+            await worktrees.remove(root, worktree);
+            return { removed: worktree };
+        }
+        catch (error) {
+            return { removeError: messageOf(error) };
+        }
+    };
+    // ---------- the sweep ----------
+    // The clock: the sweep is its timer. The other kinds are the watchers'.
+    const resolveTimeWaits = () => {
+        for (const wait of store.openWaits()) {
+            const at = timeOf(wait.condition);
+            if (at === null || now().getTime() < at.getTime())
+                continue;
+            resolveOpenWait(store, wait, `time ${at.toISOString()} reached`);
+        }
+    };
+    // A park that fails is reported once per spell and tried again after PARK_RETRY_MS, so one
+    // stuck process doesn't hold up every sweep for STOP_WAIT_MS.
+    const park = async (worker, session, waits) => {
+        if (worker.handle === null)
+            return;
+        const state = stalls.get(worker.id) ?? {};
+        if (state.parkFailed && now().getTime() < state.parkFailed.retryAt)
+            return;
+        let error = null;
+        try {
+            if (!(await stopAndWait(worker.handle, session.pid))) {
+                error = `pid ${session.pid} still runs ${STOP_WAIT_MS / 1000} s after claude stop`;
+            }
+        }
+        catch (stopError) {
+            error = messageOf(stopError);
+        }
+        if (error !== null) {
+            if (!state.parkFailed)
+                event(worker, 'worker.park-failed', { error, retryMinutes: PARK_RETRY_MS / 60_000 });
+            state.parkFailed = { retryAt: now().getTime() + PARK_RETRY_MS };
+            stalls.set(worker.id, state);
+            return;
+        }
+        const parked = update(worker, { status: 'parked', stoppedAt: now().toISOString() });
+        stalls.delete(worker.id);
+        event(parked, 'worker.parked', { waits: waits.map((w) => w.condition) });
+    };
+    const resume = async (worker, resolved, session) => {
+        if (worker.sessionId === null || worker.stoppedAt === null)
+            return;
+        // Let the stop settle: a resume straight after it has started a copy instead.
+        if (now().getTime() - Date.parse(worker.stoppedAt) < config.settleSeconds * 1000)
+            return;
+        const text = eventText(resolved);
+        const { copy } = await claude.resume({ cwd: session?.cwd ?? worker.worktree ?? rootOf(worker), sessionId: worker.sessionId, text });
+        if (copy) {
+            const steps = [];
+            await step(steps, 'stop copy', () => claude.stop(copy));
+            await step(steps, 'rm copy', () => claude.rm(copy));
+            const again = update(worker, { stoppedAt: now().toISOString() });
+            event(again, 'worker.resume-failed', { copy, error: 'the session still ran, so claude started a copy; retried on a later sweep', steps });
+            return;
+        }
+        store.deliverWaits(resolved.map((w) => w.id));
+        const running = update(worker, { attachedAt: null, status: 'running', stoppedAt: null });
+        event(running, 'worker.resumed', { text, waits: resolved.map((w) => w.id) });
+    };
+    const checkStalls = (worker, session, waiting) => {
+        const state = stalls.get(worker.id) ?? {};
+        const prompt = permissionPrompt(session);
+        if (prompt === null)
+            state.permission = undefined;
+        else {
+            if (state.permission?.waitingFor !== prompt)
+                state.permission = { reported: false, since: now().toISOString(), waitingFor: prompt };
+            const minutes = minutesSince(state.permission.since);
+            if (!state.permission.reported && minutes >= config.permissionMinutes) {
+                state.permission.reported = true;
+                event(worker, 'worker.stalled', { kind: 'permission', minutes: Math.floor(minutes), since: state.permission.since, waitingFor: prompt });
+            }
+        }
+        // An attached worker is Jason's while he has it open.
+        if (!turnEnded(session) || waiting || worker.attachedAt !== null)
+            state.idle = undefined;
+        else {
+            state.idle ??= { reported: false, since: now().toISOString() };
+            const minutes = minutesSince(state.idle.since);
+            if (!state.idle.reported && minutes >= config.idleMinutes) {
+                state.idle.reported = true;
+                event(worker, 'worker.stalled', { kind: 'idle', minutes: Math.floor(minutes), since: state.idle.since });
+            }
+        }
+        stalls.set(worker.id, state);
+    };
+    // The daemon can't see the tab, so attached means "Jason may be in it" only while the session is
+    // in use. Once its turn has been over `idleMinutes`, the worker is the daemon's again, and its
+    // waits park and resume it as usual.
+    const releaseAttached = (worker, session) => {
+        const state = stalls.get(worker.id) ?? {};
+        stalls.set(worker.id, state);
+        if (!turnEnded(session)) {
+            state.attachedIdleSince = undefined;
+            return worker;
+        }
+        state.attachedIdleSince ??= now().toISOString();
+        const minutes = minutesSince(state.attachedIdleSince);
+        if (minutes < config.idleMinutes)
+            return worker;
+        state.attachedIdleSince = undefined;
+        const released = update(worker, { attachedAt: null });
+        event(released, 'worker.detached', { idleMinutes: Math.floor(minutes) });
+        return released;
+    };
+    const sweepWorker = async (worker) => {
+        let current = worker;
+        const session = sessionOf(current);
+        // The listing is the truth for ids: fill them in after a launch, and follow a changed short id.
+        if (session && (current.sessionId !== session.sessionId || current.handle !== session.id)) {
+            current = update(current, { handle: session.id, sessionId: session.sessionId });
+        }
+        const waits = store.waitsOf(current.id);
+        const resolved = waits.filter((w) => w.resolvedAt !== null);
+        // A listed pid can outlive its process for a moment after a stop.
+        const live = session !== undefined && isLive(session) && (session.pid === undefined || alive(session.pid));
+        if (current.status === 'running') {
+            if (!live) {
+                stalls.delete(current.id);
+                const gone = update(current, { status: 'stopped-unexpectedly', stoppedAt: now().toISOString() });
+                event(gone, 'worker.stopped-unexpectedly', { session: session ? { id: session.id, state: session.state } : null });
+                return;
+            }
+            if (current.attachedAt !== null)
+                current = releaseAttached(current, session);
+            checkStalls(current, session, waits.length > 0);
+            // A wait that resolved before the turn ended parks the worker too; the resume carries it.
+            if (waits.length > 0 && turnEnded(session) && current.attachedAt === null)
+                await park(current, session, waits);
+            return;
+        }
+        // Parked, or stopped unexpectedly, and running again: someone woke it outside the daemon.
+        if (live && !isStarting(session)) {
+            const running = update(current, { status: 'running', stoppedAt: null });
+            event(running, 'worker.running-again', { was: current.status });
+            return;
+        }
+        if (current.status === 'parked' && resolved.length > 0)
+            await resume(current, resolved, session);
+    };
+    // The transcript is under the slug of the session's cwd, which is usually its worktree. Failing
+    // that, every project directory is scanned, at most once a minute per worker.
+    const transcriptOf = (worker, sessionId) => {
+        const known = transcripts.get(worker.id);
+        if (known !== undefined)
+            return known;
+        const cwd = sessionOf(worker)?.cwd ?? worker.worktree;
+        const direct = cwd ? join(deps.projectsDir, projectSlug(cwd), `${sessionId}.jsonl`) : null;
+        let found = direct !== null && existsSync(direct) ? direct : null;
+        if (found === null) {
+            const scannedAt = transcriptScans.get(worker.id);
+            if (scannedAt !== undefined && now().getTime() - scannedAt < TRANSCRIPT_SCAN_MS)
+                return null;
+            transcriptScans.set(worker.id, now().getTime());
+            found = findTranscript(deps.projectsDir, sessionId);
+        }
+        if (found !== null)
+            transcripts.set(worker.id, found);
+        return found;
+    };
+    const readSpend = (worker) => {
+        if (worker.sessionId === null)
+            return;
+        const main = transcriptOf(worker, worker.sessionId);
+        if (main === null)
+            return;
+        for (const file of transcriptFiles(main)) {
+            const { byDay, cursor } = readUsage(file, store.transcriptCursor(file) ?? { bytes: 0, recentIds: [] });
+            // The spend and the cursor move together, so a crash between them can't count usage twice.
+            store.transaction(() => {
+                for (const [day, usage] of byDay)
+                    store.addSpend({ day, item: worker.item, project: worker.project, usage, worker: worker.id });
+                store.saveTranscript(file, worker.id, cursor);
+            });
+        }
+    };
+    // Never rejects: it runs on a timer, and an unhandled rejection would end the daemon.
+    const sweepOnce = async () => {
+        const listedAt = now().toISOString();
+        try {
+            sessions = await claude.agents();
+            listed = true;
+        }
+        catch (error) {
+            log.log('warn', 'claude agents failed; sweep skipped', { error: messageOf(error) });
+            return;
+        }
+        try {
+            resolveTimeWaits();
+            for (const { id } of store.listWorkers(SWEPT)) {
+                if (busy.has(id))
+                    continue;
+                busy.add(id);
+                try {
+                    // Read again: a park can take seconds, and meanwhile a retire or an attach may have
+                    // changed this worker. One changed after the listing waits for the next sweep, whose
+                    // listing shows its session as it is now.
+                    const worker = store.getWorker(id);
+                    if (!worker || !SWEPT.includes(worker.status) || worker.updatedAt > listedAt)
+                        continue;
+                    await sweepWorker(worker);
+                    readSpend(store.getWorker(id) ?? worker);
+                }
+                catch (error) {
+                    log.log('error', 'sweep failed for a worker', { error: messageOf(error), worker: id });
+                }
+                finally {
+                    busy.delete(id);
+                }
+            }
+        }
+        catch (error) {
+            log.log('error', 'sweep failed', { error: messageOf(error) });
+        }
+    };
+    // A launch the daemon was stopped in can have made its worktree and even started its session.
+    // A session by the worker's name is adopted; otherwise the launch failed, and a clean worktree
+    // it left is removed.
+    const recoverLaunches = async (workers) => {
+        if (workers.length === 0)
+            return;
+        const listing = await claude.agents().catch(() => null);
+        for (const worker of workers) {
+            try {
+                const session = listing?.find((s) => s.name === worker.name && isLive(s));
+                if (session) {
+                    event(update(worker, { handle: session.id, sessionId: session.sessionId, status: 'running' }), 'worker.launch-recovered', {
+                        handle: session.id,
+                    });
+                    continue;
+                }
+                const root = rootOf(worker);
+                const worktree = worker.worktree ?? join(root, '.claude', 'worktrees', worker.name);
+                const cleanup = listing !== null && existsSync(worktree) ? await removeIfClean(root, worktree) : {};
+                store.closeWaits(worker.id, 'launch failed');
+                event(update(worker, { status: 'failed' }), 'worker.launch-failed', {
+                    error: 'the daemon stopped during the launch',
+                    step: 'interrupted',
+                    ...cleanup,
+                });
+            }
+            catch (error) {
+                log.log('error', 'could not recover an interrupted launch', { error: messageOf(error), worker: worker.id });
+            }
+        }
+    };
+    // ---------- the manager ----------
+    const activeWorker = (id) => {
+        const worker = store.getWorker(id);
+        if (!worker || !ACTIVE_STATUSES.includes(worker.status))
+            throw new ConductorError(`no worker ${id} in flight`);
+        return worker;
+    };
+    const manager = {
+        addWait: (workerId, condition) => {
+            const worker = activeWorker(workerId);
+            if (worker.status === 'launching')
+                throw new ConductorError(`${worker.name} is still launching`);
+            const parsed = parseCondition(condition);
+            const problem = uncheckable(parsed, store.listProjects().find((p) => p.name === worker.project)?.profile ?? null);
+            if (problem) {
+                throw new ConductorError(problem, [`the conductor reads ${worker.project}'s profile as registered; after changing it, run \`conduct project add\` again`]);
+            }
+            // Stored in its normal full form, so the watchers and `conduct status` read one spelling.
+            const wait = store.addWait(worker.id, formatCondition(parsed));
+            // A new wait hands an attached worker back to the daemon: it parks when its turn ends.
+            const current = worker.attachedAt === null ? worker : update(worker, { attachedAt: null });
+            event(current, 'wait.added', { condition: wait.condition, wait: wait.id });
+            return wait;
+        },
+        attach: async (workerId) => {
+            const worker = activeWorker(workerId);
+            if (busy.has(worker.id) || worker.status === 'launching')
+                throw new ConductorError(`${worker.name} is busy; try again shortly`);
+            const { handle, sessionId } = worker;
+            if (handle === null || sessionId === null)
+                throw new ConductorError(`${worker.name} has no session`);
+            busy.add(worker.id);
+            try {
+                let current = worker;
+                const resumed = current.status !== 'running';
+                if (resumed) {
+                    const settle = current.stoppedAt === null ? 0 : config.settleSeconds * 1000 - (now().getTime() - Date.parse(current.stoppedAt));
+                    if (settle > 0)
+                        await sleep(settle);
+                    // No event text: the session wakes idle and keeps running when the tab closes.
+                    const { copy } = await claude.resume({ cwd: sessionOf(current)?.cwd ?? current.worktree ?? rootOf(current), sessionId, text: null });
+                    if (copy) {
+                        await claude.stop(copy).catch(() => { });
+                        await claude.rm(copy).catch(() => { });
+                        throw new ConductorError(`${current.name} still ran, so claude started a copy (removed); try again shortly`);
+                    }
+                }
+                current = update(current, { attachedAt: now().toISOString(), status: 'running', stoppedAt: null });
+                const tab = await openTab({
+                    cwd: rootOf(current),
+                    handle,
+                    title: current.name,
+                    window: `${current.probe ? 'probe' : 'Conductor'} · ${current.project}`,
+                });
+                event(current, 'worker.attached', { resumed, ...(tab ? { tabError: tab } : {}) });
+                return { resumed, tab, worker: current };
+            }
+            finally {
+                busy.delete(worker.id);
+            }
+        },
+        fleet: () => {
+            const spend = store.spendByWorker(localDay(now()));
+            return store.listWorkers(ACTIVE_STATUSES).map((worker) => ({
+                ...worker,
+                activity: listed ? activityOf(worker, sessionOf(worker)) : 'not listed yet',
+                spend: spend.get(worker.id) ?? { today: 0, total: 0 },
+                waits: store.waitsOf(worker.id),
+            }));
+        },
+        idle: async () => {
+            while (tasks.size > 0 || sweeping)
+                await Promise.allSettled([...tasks, sweeping]);
+        },
+        launch: (request) => {
+            if (!ITEM.test(request.item))
+                throw new ConductorError(`"${request.item}" is not an item id`);
+            const target = project(request.project);
+            const name = `${request.probe ? PROBE_PREFIX : ''}${request.item}`;
+            const prompt = request.prompt ??
+                (request.probe
+                    ? PROBE_PROMPT
+                    : `/${target.profile.skills.work} ${request.item} --conducted${request.conductor ? ` --conductor ${request.conductor}` : ''}`);
+            const worker = store.insertWorker({ item: request.item, name, probe: request.probe === true, project: target.name });
+            event(worker, 'worker.launching', { probe: worker.probe });
+            busy.add(worker.id);
+            void track(launchWorker(worker, target.root, target.profile, prompt).finally(() => busy.delete(worker.id)));
+            return worker;
+        },
+        retire: async (workerId, { force = false } = {}) => {
+            const worker = activeWorker(workerId);
+            if (busy.has(worker.id) || worker.status === 'launching') {
+                return { outcome: 'refused', reason: 'still launching, or another operation runs: try again shortly', worker };
+            }
+            busy.add(worker.id);
+            try {
+                // Fresh: the last sweep's listing can be ten seconds old.
+                const session = (await claude.agents().catch(() => sessions)).find((s) => s.sessionId === worker.sessionId || s.id === worker.handle);
+                const refuse = (reason, work) => {
+                    event(worker, 'worker.retire-refused', { reason, ...work });
+                    return { outcome: 'refused', reason, ...(work ? { work } : {}), worker };
+                };
+                // Removing the worktree while `claude --bg` still sets the session up there strands it.
+                if (session && isStarting(session))
+                    return refuse('its session is still starting: try again shortly');
+                // A turn that runs can write between the check below and the stop.
+                if (session && isLive(session) && !turnEnded(session) && !force) {
+                    return refuse('its turn is still running: retire once it ends, or retire --force');
+                }
+                const work = worker.worktree ? await worktrees.unfinishedWork(worker.worktree) : null;
+                if (work && !force)
+                    return refuse('unfinished work: commit and push it, or retire --force to throw it away', work);
+                const root = store.listProjects().find((p) => p.name === worker.project)?.root;
+                const steps = [];
+                const handle = worker.handle;
+                if (handle !== null && session?.pid !== undefined) {
+                    const stopped = await step(steps, 'stop', async () => {
+                        if (!(await stopAndWait(handle, session.pid)))
+                            throw new Error(`pid ${session.pid} still runs after claude stop`);
+                    });
+                    // Nothing is removed from under a session that still runs.
+                    if (!stopped) {
+                        event(worker, 'worker.retire-partial', { forced: force && work !== null, steps });
+                        return { outcome: 'partial', steps, worker };
+                    }
+                }
+                if (worker.worktree !== null) {
+                    const worktree = worker.worktree;
+                    await step(steps, 'remove worktree', async () => {
+                        if (!root)
+                            throw new Error(`project ${worker.project} is not registered`);
+                        await worktrees.remove(root, worktree);
+                    });
+                }
+                try {
+                    readSpend(worker); // the last of it, before the session goes
+                }
+                catch (error) {
+                    log.log('warn', 'spend not read at retire', { error: messageOf(error), worker: worker.id });
+                }
+                if (handle !== null)
+                    await step(steps, 'rm', () => claude.rm(handle));
+                const ok = steps.every((s) => s.ok);
+                const current = ok ? update(worker, { status: 'exited', stoppedAt: now().toISOString() }) : worker;
+                if (ok)
+                    store.closeWaits(worker.id, 'worker retired');
+                stalls.delete(worker.id);
+                event(current, ok ? 'worker.retired' : 'worker.retire-partial', { forced: force && work !== null, steps });
+                return { outcome: ok ? 'retired' : 'partial', steps, worker: current };
+            }
+            finally {
+                busy.delete(worker.id);
+            }
+        },
+        start: () => {
+            const interrupted = store.listWorkers(['launching']).filter((w) => !busy.has(w.id));
+            interrupted.forEach((w) => busy.add(w.id));
+            void track(recoverLaunches(interrupted).finally(() => interrupted.forEach((w) => busy.delete(w.id))));
+            timer = setInterval(() => {
+                manager.sweep().catch((error) => log.log('error', 'sweep failed', { error: messageOf(error) }));
+            }, config.pollSeconds * 1000);
+            timer.unref();
+        },
+        stop: async () => {
+            clearInterval(timer);
+            await sweeping;
+        },
+        sweep: () => {
+            sweeping ??= track(sweepOnce()).finally(() => (sweeping = null));
+            return sweeping;
+        },
+    };
+    return manager;
+}
+function activityOf(worker, session) {
+    if (worker.status === 'launching')
+        return 'launching';
+    if (worker.status === 'parked')
+        return 'parked';
+    if (!session)
+        return 'no session';
+    if (isStarting(session))
+        return 'starting';
+    if (!isLive(session))
+        return 'stopped';
+    const prompt = session.status === 'waiting' ? (session.waitingFor ?? 'input') : null;
+    if (prompt)
+        return `waiting on ${prompt}`;
+    return turnEnded(session) ? 'idle' : 'working';
+}
+// HH:MM, local.
+function clock(at) {
+    return `${String(at.getHours()).padStart(2, '0')}:${String(at.getMinutes()).padStart(2, '0')}`;
+}
+function messageOf(error) {
+    if (error instanceof ConductorError)
+        return [error.message, ...error.details].join(': ');
+    return error instanceof Error ? error.message : String(error);
+}
+function timeOf(condition) {
+    if (!condition.startsWith('time:'))
+        return null;
+    const at = new Date(condition.slice('time:'.length));
+    return Number.isNaN(at.getTime()) ? null : at;
+}
+//# sourceMappingURL=manager.js.map