@detergent-software/conductor 2.2.0-dev.3 → 3.0.0-dev.10

package/build/local-files.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { cp } from 'node:fs/promises';
+import { dirname, join, matchesGlob, relative } from 'node:path';
+import { ConductorError } from "./errors.js";
+import { outputOf } from "./run.js";
+export const INCLUDE_FILE = '.worktreeinclude';
+// Copies the source checkout's included files into `target`; returns their paths, relative and with
+// forward slashes. Git lists ignored paths with whole ignored directories collapsed, which keeps
+// node_modules out of the walk. A pattern without a slash (".env*") matches at any depth but not
+// inside an ignored directory; an anchored one ("apps/api/secrets/*.json") also reaches into one.
+export async function copyLocalFiles(git, source, target) {
+    if (!existsSync(join(source, '.git')))
+        throw new ConductorError(`localFilesFrom ${source} is not a git checkout`, [
+            "set the profile's localFilesFrom to a checkout of the project you keep",
+        ]);
+    const patterns = includePatterns(join(source, INCLUDE_FILE));
+    if (patterns.length === 0)
+        return [];
+    const listed = await git(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], source);
+    if (listed.code !== 0)
+        throw new ConductorError(`git couldn't list the ignored files in ${source}`, [outputOf(listed, 500)]);
+    const copied = [];
+    // Asynchronous, so an included directory of any size doesn't hold up the daemon.
+    const copy = async (rel) => {
+        const to = join(target, rel);
+        mkdirSync(dirname(to), { recursive: true });
+        await cp(join(source, rel), to, { recursive: true });
+        copied.push(rel);
+    };
+    // Git can list a directory and also entries inside it (apps/, apps/api/, ...), parents first, so
+    // anything under a directory already copied or walked is skipped.
+    const handled = ['.claude/worktrees'];
+    for (const entry of listed.stdout.split('\0').filter(Boolean)) {
+        const isDir = entry.endsWith('/');
+        const rel = isDir ? entry.slice(0, -1) : entry;
+        if (handled.some((dir) => rel === dir || rel.startsWith(`${dir}/`)))
+            continue;
+        if (isIncluded(patterns, rel, isDir))
+            await copy(rel);
+        else if (isDir)
+            for (const file of walkAnchored(patterns, source, rel))
+                await copy(file);
+        if (isDir)
+            handled.push(rel);
+    }
+    return copied;
+}
+export function includePatterns(file) {
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, 'utf8')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'))
+        .map((line) => {
+        const negated = line.startsWith('!');
+        let pattern = negated ? line.slice(1) : line;
+        const dirOnly = pattern.endsWith('/');
+        if (dirOnly)
+            pattern = pattern.slice(0, -1);
+        const anchored = pattern.includes('/');
+        if (pattern.startsWith('/'))
+            pattern = pattern.slice(1);
+        return { anchored, dirOnly, glob: anchored ? pattern : `**/${pattern}`, negated };
+    });
+}
+export function isIncluded(patterns, rel, isDir) {
+    const parts = rel.split('/');
+    for (let i = 1; i < parts.length; i++)
+        if (matchesLast(patterns, parts.slice(0, i).join('/'), true))
+            return true;
+    return matchesLast(patterns, rel, isDir);
+}
+function matchesLast(patterns, rel, isDir) {
+    let result = false;
+    for (const p of patterns) {
+        if (p.dirOnly && !isDir)
+            continue;
+        if (matchesGlob(rel, p.glob))
+            result = !p.negated;
+    }
+    return result;
+}
+function* walkAnchored(patterns, source, dir) {
+    if (!patterns.some((p) => p.anchored && !p.negated && p.glob.startsWith(`${dir}/`)))
+        return;
+    for (const entry of readdirSync(join(source, dir), { recursive: true, withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        const rel = relative(source, join(entry.parentPath, entry.name)).split('\\').join('/');
+        if (isIncluded(patterns, rel, false))
+            yield rel;
+    }
+}
+//# sourceMappingURL=local-files.js.map

package/build/local-files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-files.js","sourceRoot":"","sources":["../src/local-files.ts"],"names":[],"mappings":"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"}

package/build/manager.js

@@ -1,17 +1,20 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { freePorts, releaseLocks } from "./broker.js";
-import { isLive, isStarting, permissionPrompt, SessionGone, turnEnded, } from "./claude.js";
+import { freePorts, portEnv, releaseLocks } from "./broker.js";
+import { isLive, isStarting, permissionPrompt, SessionGone, trustStep, turnEnded, WorkspaceUntrusted, } from "./claude.js";
 import { formatCondition, parseCondition, prRef, uncheckable } from "./conditions.js";
 import { ConductorError } from "./errors.js";
 import { UNWATCHED_HANDOFFS } from "./inbox.js";
 import { processAlive as defaultProcessAlive } from "./lock.js";
+import { missingPluginSkills, projectSkills } from "./plugin.js";
 import { WAKE_PREFIX } from "./protocol.js";
 import { resolveOpenWait } from "./resolve.js";
 import { findTranscript, formatTokens, lastTurnAt, localDay, projectSlug, readUsage, transcriptFiles, } from "./spend.js";
 import { ACTIVE_STATUSES, openStore, waitSchema, workerSchema, } from "./store.js";
+import { linkedPr } from "./tracker-writes.js";
 import { pendingCall } from "./transcript.js";
+import { BRANCH_PREFIX, worktreePath } from "./worktrees.js";
 // A worker as GET /fleet shows it.
 export const fleetWorkerSchema = workerSchema.extend({
     // launching, starting, working, idle, waiting on <x>, parked, stopped, no session
@@ -85,11 +88,17 @@ 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';
+// How long a started or woken worker's session has to report its plugin. A start runs the create
+// hook first only for a launch, which is before the clock starts.
+export const PLUGIN_REPORT_MS = 3 * 60_000;
 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;
+// How long a new session id has to stay listed before the worker follows it. A resuming session is
+// listed for under a second under the id its process started with, before it loads its own (ATK-574).
+const SESSION_ID_SETTLE_MS = 5_000;
 const TRANSCRIPT_SCAN_MS = 60_000;
 // A compaction with no boundary in the transcript this long after it started, its turn over, failed.
 const COMPACT_MINUTES = 10;
@@ -112,7 +121,7 @@ export function eventText(waits) {
     return `${WAKE_PREFIX}${[...facts].map(([fact, at]) => `${fact} ${clock(new Date(at))}`).join('; ')}`;
 }
 export function sessionManager(deps) {
-    const { claude, config, log, openTab, store, worktrees } = deps;
+    const { broker, claude, config, log, openTab, pluginDir, prs, 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)));
@@ -122,6 +131,8 @@ export function sessionManager(deps) {
     const stalls = new Map();
     const transcripts = new Map();
     const transcriptScans = new Map();
+    // worker id → a session id the listing shows for it that it hasn't followed yet, since when
+    const newSessionIds = new Map();
     let sessions = [];
     // Until the first sweep, nothing is known about any session.
     let listed = false;
@@ -132,6 +143,12 @@ export function sessionManager(deps) {
     const held = new Set();
     // Workers whose compaction failed: not tried again while the daemon runs (their inbox item says so).
     const uncompactable = new Set();
+    // Every session the conductor starts loads its plugin, and a resume whose saved --plugin-dir went
+    // missing runs on without it, silently (ATK-522). The mod reports each session start (pluginSeen),
+    // so a worker started or woken that doesn't report within PLUGIN_REPORT_MS is a
+    // `worker.plugin-missing`. In memory: a daemon restart forgets the starts it didn't see.
+    const pluginDue = new Map(); // worker id → when its session was last (re)started
+    const pluginReports = new Map(); // session id → its plugin's newest report
     const event = (worker, kind, data = {}, rule = null) => {
         const entry = {
             data: { name: worker.name, worker: worker.id, ...data },
@@ -142,6 +159,48 @@ export function sessionManager(deps) {
         };
         store.appendEvent(entry);
     };
+    // Its session was (re)started at `since`, before the claude call: its report must come after.
+    // Only a worker launched with the plugin keeps it in its saved options: one launched before it (by
+    // an older daemon, with workers in flight across an upgrade) never loads it and works on without.
+    const expectPlugin = (worker, since) => {
+        if (launchedWithPlugin(worker))
+            pluginDue.set(worker.id, since);
+    };
+    const withPlugin = new Map();
+    const launchedWithPlugin = (worker) => {
+        let known = withPlugin.get(worker.id);
+        if (known === undefined) {
+            known = store
+                .workerEvents(worker.id, 1000)
+                .some((e) => e.kind === 'worker.launched' && typeof e.data.pluginDir === 'string');
+            withPlugin.set(worker.id, known);
+        }
+        return known;
+    };
+    // A worker whose session hasn't reported its plugin within PLUGIN_REPORT_MS of its start, once per
+    // start. One with no session id yet waits for it: reports are matched by session.
+    const checkPlugins = () => {
+        const at = now().getTime();
+        for (const [id, since] of pluginDue) {
+            const worker = store.getWorker(id);
+            if (!worker || !ACTIVE_STATUSES.includes(worker.status)) {
+                pluginDue.delete(id);
+                continue;
+            }
+            if (worker.sessionId === null)
+                continue;
+            if ((pluginReports.get(worker.sessionId) ?? -1) >= since) {
+                pluginDue.delete(id);
+            }
+            else if (at - since >= PLUGIN_REPORT_MS) {
+                pluginDue.delete(id);
+                event(worker, 'worker.plugin-missing', { minutes: Math.round((at - since) / 60_000), plugin: pluginDir });
+            }
+        }
+        for (const [session, reported] of pluginReports)
+            if (at - reported > PLUGIN_REPORT_MS * 10)
+                pluginReports.delete(session);
+    };
     // Whether the rules let it park or resume now; a refusal is logged once until the rules allow it.
     const decide = (verb, worker, waits) => {
         const decision = policy(verb, worker, waits);
@@ -214,24 +273,56 @@ export function sessionManager(deps) {
         }
     };
     // ---------- launch ----------
+    // The worktree first (design note v2, section 2): its ports from the broker, then `git worktree add`
+    // from origin/<base>, the local files and the profile's setup. The session starts in it.
     const launchWorker = async (worker, root, profile, prompt) => {
         let current = worker;
-        let stage = 'create worktree';
+        let stage = 'assign ports';
+        const path = worktreePath(root, worker.name);
+        // A worktree there already (a kept one, or one a person made with `claude --worktree`) isn't
+        // this launch's to remove when it fails.
+        const reused = existsSync(join(path, '.git'));
         try {
-            const worktree = await worktrees.create(root, worker.name);
+            // Recorded before it exists: the broker keeps an in-flight worker's ports while its directory
+            // isn't there yet, and a create that fails part way is cleaned up.
+            current = update(current, { worktree: path });
+            const { ports } = await broker.assignPorts(path, worker.project, profile.ports);
+            stage = 'create worktree';
+            const env = portEnv(ports);
+            const worktree = await worktrees.create({
+                base: profile.baseBranch,
+                env: { ...env, CONDUCTOR_ITEM: worker.item, CONDUCTOR_PROJECT: worker.project, CONDUCTOR_WORKTREE: path },
+                ...(profile.localFilesFrom === undefined ? {} : { localFilesFrom: profile.localFilesFrom }),
+                name: worker.name,
+                root,
+                sessionEnv: env,
+                setup: profile.setup,
+            });
             current = update(current, { branch: await worktrees.branchOf(worktree), worktree });
             stage = 'check skills';
-            const problem = await worktrees.checkSkills(worktree, [profile.skills.work, profile.skills.verify]);
+            const skills = [profile.skills.work, profile.skills.verify];
+            const problem = worktrees.missingSkills(worktree, projectSkills(skills)) ?? missingPluginSkills(pluginDir, skills);
             if (problem)
                 throw new ConductorError(problem);
             stage = 'start session';
-            const handle = await claude.launch({
-                cwd: root,
+            const started = now().getTime();
+            const handle = await claude
+                .launch({
+                cwd: worktree,
                 disallowedTools: DISALLOWED_TOOLS,
                 name: worker.name,
                 permissionMode: PERMISSION_MODE,
+                pluginDir,
                 prompt,
-                worktree: worker.name,
+            })
+                .catch((error) => {
+                // Claude Code's own message names the worktree, which this failed launch removes.
+                if (!(error instanceof WorkspaceUntrusted))
+                    throw error;
+                throw new ConductorError(`Claude Code doesn't trust ${root}`, [
+                    `${trustStep(root)}, then \`conduct project check ${worker.project}\``,
+                    ...error.details,
+                ]);
             });
             try {
                 sessions = await claude.agents();
@@ -242,10 +333,11 @@ export function sessionManager(deps) {
             }
             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 });
+            event(current, 'worker.launched', { handle, pluginDir, sessionId: current.sessionId, worktree });
+            expectPlugin(current, started);
             if (profile.workers.tab) {
                 const tab = await openTab({
-                    cwd: root,
+                    cwd: worktree,
                     handle,
                     title: worker.name,
                     window: `${worker.probe ? 'probe' : 'Conductor'} · ${worker.project}`,
@@ -256,24 +348,62 @@ export function sessionManager(deps) {
         }
         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) : {};
+            const cleanup = reused
+                ? { kept: path, keptBecause: 'it was there before the launch' }
+                : current.worktree && existsSync(current.worktree)
+                    ? await removeIfClean(root, current.worktree)
+                    : {};
+            freePorts(store, path, 'launch failed');
             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 });
         }
     };
+    // A failed launch's worktree, unless it holds work. Its branch goes with it while it still has the
+    // name the launch gave it; a renamed one was the worker's.
     const removeIfClean = async (root, worktree) => {
         try {
             const work = await worktrees.unfinishedWork(worktree);
             if (work)
                 return { kept: worktree, ...work };
-            await worktrees.remove(root, worktree);
+            const branch = await worktrees.branchOf(worktree);
+            await worktrees.remove(root, worktree, { deleteBranch: branch?.startsWith(BRANCH_PREFIX) === true });
             return { removed: worktree };
         }
         catch (error) {
             return { removeError: messageOf(error) };
         }
     };
+    // Whether retiring the worker removes its worktree and branch: once its PR has merged, and for a
+    // probe or a forced retire. `unread`: its PR couldn't be read, so retire waits.
+    const worktreeFate = async (worker, force) => {
+        const decided = (remove, reason) => ({ reason, remove, unread: null });
+        if (worker.worktree === null || !existsSync(worker.worktree))
+            return decided(true, 'no worktree');
+        if (worker.probe)
+            return decided(true, 'a probe');
+        if (force)
+            return decided(true, 'retire --force');
+        // With no PR and nothing uncommitted or unpushed, nothing in it is lost (a canceled item, a worker
+        // retired before its first commit): it goes, with no inbox item.
+        if (worker.pr === null)
+            return (await worktrees.unfinishedWork(worker.worktree)) === null
+                ? decided(true, 'no PR and nothing unpushed')
+                : decided(false, 'it has no PR');
+        const profile = store.listProjects().find((p) => p.name === worker.project)?.profile;
+        if (!profile)
+            return { reason: '', remove: false, unread: `project ${worker.project} has no readable profile` };
+        // No read would ever answer for it, so waiting would refuse the retire for good.
+        if (linkedPr(worker.pr, profile) === null)
+            return decided(false, `its PR ${worker.pr} isn't one ${worker.project}'s code host reads`);
+        try {
+            const state = await prs(profile, worker.pr);
+            return decided(state === 'merged', `its PR ${worker.pr} is ${state}`);
+        }
+        catch (error) {
+            return { reason: '', remove: false, unread: messageOf(error) };
+        }
+    };
     // ---------- the sweep ----------
     // The clock: the sweep is its timer. The other kinds are the watchers'.
     const resolveTimeWaits = () => {
@@ -325,6 +455,7 @@ export function sessionManager(deps) {
         if (!decision.allowed)
             return;
         const text = eventText(resolved);
+        const started = now().getTime();
         const { copy } = await claude.resume({
             cwd: session?.cwd ?? worker.worktree ?? rootOf(worker),
             sessionId: worker.sessionId,
@@ -343,6 +474,7 @@ export function sessionManager(deps) {
         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) }, decision.rule);
+        expectPlugin(running, started);
     };
     // A resume of a session that still ran started a copy: the copy goes.
     const discardCopy = async (copy) => {
@@ -370,6 +502,7 @@ export function sessionManager(deps) {
         const before = worker.context;
         // Before the resume: a small context can be compacted before it returns.
         const since = now().toISOString();
+        const started = now().getTime();
         let copy;
         try {
             ({ copy } = await claude.resume({
@@ -394,6 +527,7 @@ export function sessionManager(deps) {
         const running = update(worker, { status: 'running', stoppedAt: null });
         stalls.set(worker.id, { compacting: { before, since } });
         event(running, 'worker.compacting', { tokens: before }, decision.rule);
+        expectPlugin(running, started);
     };
     const compactFailed = (worker, error, tokens, rule = null) => {
         uncompactable.add(worker.id);
@@ -518,14 +652,29 @@ export function sessionManager(deps) {
         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)) {
-            // A new session id (a /clear) writes a new transcript.
-            if (current.sessionId !== session.sessionId) {
+        // A changed session id is followed once it has stayed listed SESSION_ID_SETTLE_MS.
+        if (session) {
+            let sessionId = current.sessionId;
+            const pending = newSessionIds.get(current.id);
+            if (sessionId === null || session.sessionId === sessionId)
+                newSessionIds.delete(current.id);
+            else if (pending?.sessionId !== session.sessionId) {
+                newSessionIds.set(current.id, { sessionId: session.sessionId, since: now().getTime() });
+            }
+            else if (now().getTime() - pending.since >= SESSION_ID_SETTLE_MS) {
+                newSessionIds.delete(current.id);
+                // A new session id (a /clear) writes a new transcript.
                 transcripts.delete(current.id);
                 transcriptScans.delete(current.id);
+                sessionId = session.sessionId;
+            }
+            sessionId ??= session.sessionId;
+            if (sessionId !== current.sessionId || session.id !== current.handle) {
+                current = update(current, { handle: session.id, sessionId });
             }
-            current = update(current, { handle: session.id, sessionId: session.sessionId });
         }
+        else
+            newSessionIds.delete(current.id);
         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.
@@ -691,6 +840,7 @@ export function sessionManager(deps) {
                     busy.delete(id);
                 }
             }
+            checkPlugins();
         }
         catch (error) {
             log.log('error', 'sweep failed', { error: messageOf(error) });
@@ -713,8 +863,16 @@ export function sessionManager(deps) {
                     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) : {};
+                const worktree = worker.worktree ?? worktreePath(root, worker.name);
+                const reused = store
+                    .workerEvents(worker.id, 1000)
+                    .some((e) => e.kind === 'worker.launching' && e.data.reused === true);
+                const cleanup = reused
+                    ? { kept: worktree, keptBecause: 'it was there before the launch' }
+                    : listing !== null && existsSync(worktree)
+                        ? await removeIfClean(root, worktree)
+                        : {};
+                freePorts(store, worktree, 'launch failed');
                 store.closeWaits(worker.id, 'launch failed');
                 event(update(worker, { status: 'failed' }), 'worker.launch-failed', {
                     error: 'the daemon stopped during the launch',
@@ -776,6 +934,7 @@ export function sessionManager(deps) {
             try {
                 let current = worker;
                 const resumed = current.status !== 'running';
+                let started = null;
                 if (resumed) {
                     const settle = current.stoppedAt === null
                         ? 0
@@ -783,6 +942,7 @@ export function sessionManager(deps) {
                     if (settle > 0)
                         await sleep(settle);
                     // No event text: the session wakes idle and keeps running when the tab closes.
+                    started = now().getTime();
                     const { copy } = await claude.resume({
                         cwd: sessionOf(current)?.cwd ?? current.worktree ?? rootOf(current),
                         sessionId,
@@ -797,12 +957,14 @@ export function sessionManager(deps) {
                 current = update(current, { attachedAt: now().toISOString(), status: 'running', stoppedAt: null });
                 forgetAttach(current.id);
                 const tab = await openTab({
-                    cwd: rootOf(current),
+                    cwd: current.worktree ?? rootOf(current),
                     handle,
                     title: current.name,
                     window: `${current.probe ? 'probe' : 'Conductor'} · ${current.project}`,
                 });
                 event(current, 'worker.attached', { resumed, ...(tab ? { tabError: tab } : {}) });
+                if (started !== null)
+                    expectPlugin(current, started);
                 return { resumed, tab, worker: current };
             }
             finally {
@@ -831,14 +993,24 @@ export function sessionManager(deps) {
                 probe: request.probe === true,
                 project: target.name,
             });
+            // A worktree there already isn't the launch's to remove if it fails, after a restart too.
+            const reused = existsSync(join(worktreePath(target.root, name), '.git'));
             event(worker, 'worker.launching', {
                 probe: worker.probe,
+                ...(reused ? { reused } : {}),
                 ...(request.cause === undefined ? {} : { cause: request.cause }),
             });
             busy.add(worker.id);
             void track(launchWorker(worker, target.root, target.profile, prompt).finally(() => busy.delete(worker.id)));
             return worker;
         },
+        pluginSeen: (sessionId) => {
+            pluginReports.set(sessionId, now().getTime());
+            // A /clear's session reports before the worker follows its new id.
+            return (store
+                .listWorkers(ACTIVE_STATUSES)
+                .find((w) => w.sessionId === sessionId || newSessionIds.get(w.id)?.sessionId === sessionId) ?? null);
+        },
         retire: async (workerId, { cause, force = false } = {}) => {
             const worker = activeWorker(workerId);
             if (busy.has(worker.id) || worker.status === 'launching') {
@@ -869,7 +1041,13 @@ export function sessionManager(deps) {
                 if (session && isLive(session) && !turnEnded(session) && !force) {
                     return refuse('its turn is still running: retire once it ends, or retire --force', true);
                 }
-                const work = worker.worktree ? await worktrees.unfinishedWork(worker.worktree) : null;
+                // The worktree and its branch go once the PR has merged; a probe's and a forced retire's go
+                // anyway. Otherwise both are kept, so nothing the PR didn't land is lost (design note v2,
+                // section 2), and the inbox says where they are.
+                const fate = await worktreeFate(worker, force);
+                if (fate.unread)
+                    return refuse(`its PR couldn't be read: ${fate.unread}`, true);
+                const work = fate.remove && 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', false, work);
                 const root = store.listProjects().find((p) => p.name === worker.project)?.root;
@@ -890,14 +1068,21 @@ export function sessionManager(deps) {
                         return { outcome: 'partial', steps, worker };
                     }
                 }
+                let kept = null;
                 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);
-                        freePorts(store, worktree, 'worker retired');
-                    });
+                    if (fate.remove) {
+                        await step(steps, 'remove worktree', async () => {
+                            if (!root)
+                                throw new Error(`project ${worker.project} is not registered`);
+                            await worktrees.remove(root, worktree, { deleteBranch: true });
+                        });
+                    }
+                    else if (existsSync(worktree)) {
+                        kept = { branch: await worktrees.branchOf(worktree), reason: fate.reason, worktree };
+                    }
+                    // No session serves on them any more, kept worktree or not.
+                    freePorts(store, worktree, 'worker retired');
                 }
                 try {
                     readSpend(worker); // the last of it, before the session goes
@@ -919,6 +1104,7 @@ export function sessionManager(deps) {
                 event(current, ok ? 'worker.retired' : 'worker.retire-partial', {
                     forced: force && work !== null,
                     steps,
+                    ...(kept === null ? {} : { kept }),
                     ...(cause === undefined ? {} : { cause }),
                 });
                 return { outcome: ok ? 'retired' : 'partial', steps, worker: current };
@@ -937,6 +1123,7 @@ export function sessionManager(deps) {
                 throw new ConductorError(`${worker.name} has no session`);
             busy.add(worker.id);
             try {
+                const started = now().getTime();
                 const { copy } = await claude.resume({
                     cwd: worker.worktree ?? rootOf(worker),
                     sessionId: worker.sessionId,
@@ -949,6 +1136,7 @@ export function sessionManager(deps) {
                 }
                 const running = update(worker, { status: 'running', stoppedAt: null });
                 event(running, 'worker.revived', { text }, rule);
+                expectPlugin(running, started);
                 return running;
             }
             finally {