@adecore/agents 0.21.1 → 0.21.2

package/src/messages/deliver-message.ts

@@ -24,13 +24,11 @@ export interface DeliverMessageDeps {
 }
 
 /*
- * Opens the turn a message earns a chat. The messages themselves are not carried here: they wait in
- * the notice store and the turn's preamble takes them (`NoticeNotes`), the same channel a person's
- * own prompt reads them through, so one message is heard once whichever of the two opens the turn.
+ * Opens the turn a message earns a chat. The messages wait in the notice store and the turn's preamble
+ * takes them (`NoticeNotes`), as a person's own prompt does, so a message is heard once either way.
  *
- * One attempt, never `wait`. A chat that turned out to be in a turn reads the message in front of its
- * next one, which is what a message to a busy chat has always done; holding the entry instead would
- * make the host start turns nobody asked for long after the news was worth anything.
+ * One attempt, never `wait`: a chat already in a turn reads the message in front of its next one, and
+ * holding the entry would start turns nobody asked for long after the news mattered.
  */
 export function deliverMessageHandler(deps: DeliverMessageDeps) {
     return async (entry: DeliverMessageEntry): Promise<OutboxOutcome> => {
@@ -46,11 +44,8 @@ export function deliverMessageHandler(deps: DeliverMessageDeps) {
         if (chat === null) {
             return;
         }
-        /*
-         * No note of its own, and the preamble stays off the thread. A person read the message as it
-         * landed (`showNotices`), so anything the turn adds about it only says the same thing again;
-         * the label on the turn already names who it came from.
-         */
+        // No note and no preamble on the thread: a person read the message as it landed (`showNotices`),
+        // and the label on the turn names who it came from.
         chat.wake({
             text: deps.words.prompt(waiting.length),
             label: deps.words.label(waiting),

package/src/messages/deliver-notice.ts

@@ -33,11 +33,10 @@ export interface ChatDelivery {
 }
 
 /*
- * Whether the turn a chat is running was itself opened by a message. This is the whole of the stop:
- * two agents that read each other would otherwise wake each other for as long as they kept writing,
- * and nothing about that started with a person. It rides on the turn, so it survives a restart.
+ * Whether the turn a chat is running was itself opened by a message, which stops two agents that
+ * read each other from waking each other forever. It rides on the turn, so it survives a restart.
  * Between turns the last one counts, since work it left running (a background subagent) may still
- * write, and a turn the CLI opened by itself goes on with the step of the turn before it.
+ * write, and a turn the CLI opened by itself takes the step of the turn before it.
  */
 export function turnFromMessage(items: readonly ChatItem[], activeTurnId: string | null): boolean {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
@@ -76,10 +75,9 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
 
 /*
  * One message on its way to a chat, and whether the chat owes a turn on it. A chat between turns gets
- * one, the way a settled task gives one: a person watching two agents cannot tell a message from an
- * assignment, and a message nobody starts a turn for sits there until someone happens to prompt that
- * chat. One step deep, so the turn a message opened wakes nobody with a message of its own. A node the
- * host runs something else in, such as a terminal, is the host's to deliver to before this.
+ * one, as for a settled task, or the message sits there until someone happens to prompt that chat.
+ * One step deep: the turn a message opened wakes nobody with a message of its own. A node that runs
+ * something else, such as a terminal, is the host's to deliver to before this.
  */
 export async function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery> {
     const waiting = await store.put(notice);
@@ -105,10 +103,8 @@ export interface NoticeChat {
 }
 
 /*
- * What a chat has to show a person, in its thread, the moment a message lands and not when the model
- * gets round to it: without this a message left for a busy node is a file on disk and nothing else.
- * An id no chat holds shows nothing and marks nothing, so the chat that opens on that id later still
- * has all of it.
+ * Shows a person the message in the chat's thread the moment it lands, not when the model gets round
+ * to it. An id no chat holds shows and marks nothing, so a chat that opens on it later still has all of it.
  */
 export async function showNotices(store: Pick<NoticeStore, 'show'>, chat: NoticeChat, words: Pick<MessageWords, 'shown'>, targetId: string): Promise<void> {
     if (!(await chat.has(targetId))) {

package/src/messages/notice-store.ts

@@ -7,10 +7,8 @@ import { RecordDirectory } from '../record-directory.ts';
 export const MAX_NOTICES = 10;
 
 /*
- * A message nobody picked up in this long is dropped rather than delivered. It is news about work
- * happening now ("the build is green"), and a model reading it six hours late would act on
- * something that has moved on. The cap alone would not do it: one message in a queue of one waits
- * for ever.
+ * A message is news about work happening now ("the build is green"), and a model reading it six hours
+ * late would act on something that moved on. The cap alone would leave a queue of one waiting forever.
  */
 export const NOTICE_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 
@@ -131,7 +129,7 @@ export class NoticeStore {
         return this.now() - notice.createdAt < NOTICE_MAX_AGE_MS;
     }
 
-    /* The queue of one node, emptied here and on disk both; an empty one leaves no file behind. */
+    /* In memory and on disk both; an empty queue leaves no file behind. */
     private async persist(targetId: string, queue: Notice[]): Promise<void> {
         if (queue.length === 0) {
             await this.queues.remove(targetId);

package/src/outbox/outbox-worker.ts

@@ -115,6 +115,9 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
         const now = this.clock.now();
         const busy = new Set(this.running);
         let nextDue: number | null = null;
+        const dueAt = (at: number): void => {
+            nextDue = nextDue === null ? at : Math.min(nextDue, at);
+        };
         for (const entry of this.store.list()) {
             // A waiting entry holds no lane. The resume of a chat must not queue behind a wake that waits for it.
             if (busy.has(entry.target) || this.waiting.has(entry.id)) {
@@ -122,7 +125,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
             }
             // Nor does work due at a later time, which nothing owed before it has to wait for.
             if (entry.attempts === 0 && entry.notBefore > now) {
-                nextDue = nextDue === null ? entry.notBefore : Math.min(nextDue, entry.notBefore);
+                dueAt(entry.notBefore);
                 continue;
             }
             const lanes = this.store.lanesOf(entry);
@@ -135,7 +138,7 @@ export class OutboxWorker<Work extends OutboxWorkShape> {
                 continue;
             }
             if (entry.notBefore > now) {
-                nextDue = nextDue === null ? entry.notBefore : Math.min(nextDue, entry.notBefore);
+                dueAt(entry.notBefore);
                 continue;
             }
             void this.run(entry);

package/src/providers/accounts/service.ts

@@ -13,6 +13,7 @@ import {
     type ProviderAccountVariable,
     type ProviderInfo
 } from '@adecore/agent-contracts';
+import { DEFAULT_CODEX_CLIENT, type CodexClientInfo } from '../../chat/codex-transport.ts';
 import { ClientSinks } from '../../client-sinks.ts';
 import { errorText } from '../../error-text.ts';
 import type { AgentEvent, AgentSink } from '../../events.ts';
@@ -23,7 +24,6 @@ import { prepareShadowHome, type ShadowHomeReport } from './shadow-home.ts';
 import { askAccountAs, type AskAccount } from './status.ts';
 import { acceptAccounts, accountsPath, InvalidAccountError, readAccounts, wireAccounts, writeAccounts, type StoredAccounts } from './store.ts';
 import { DEFAULT_ACCOUNTS_HOST, platformSecrets, secretKey, SecretsUnavailableError, type AccountsHost, type SecretStore } from './variables.ts';
-import { DEFAULT_CODEX_CLIENT, type CodexClientInfo } from '../../chat/codex-transport.ts';
 
 /* Who is signed in changes by hand and rarely; often enough to notice, rarely enough not to start CLIs all day. */
 const CHECK_INTERVAL_MS = 15 * 60_000;
@@ -223,21 +223,11 @@ export class ProviderAccountsService implements AccountLaunches {
     }
 
     transcriptFolder(kind: AgentKind, id: string | undefined): string | null {
-        const key = id ?? kind;
-        const account = this.accounts[key];
-        if (account === undefined || account.kind !== kind) {
-            return null;
-        }
-        return transcriptFolder(key, account, this.providers.get(kind), this.env);
+        return this.folderOf(kind, id, transcriptFolder);
     }
 
     homeFolder(kind: AgentKind, id: string | undefined): string | null {
-        const key = id ?? kind;
-        const account = this.accounts[key];
-        if (account === undefined || account.kind !== kind) {
-            return null;
-        }
-        return accountFolder(key, account, this.providers.get(kind), this.env);
+        return this.folderOf(kind, id, accountFolder);
     }
 
     canContinue(kind: AgentKind, from: string | undefined, to: string | undefined): boolean {
@@ -343,6 +333,15 @@ export class ProviderAccountsService implements AccountLaunches {
         return this.snapshot();
     }
 
+    private folderOf(kind: AgentKind, id: string | undefined, folder: typeof accountFolder): string | null {
+        const key = id ?? kind;
+        const account = this.accounts[key];
+        if (account === undefined || account.kind !== kind) {
+            return null;
+        }
+        return folder(key, account, this.providers.get(kind), this.env);
+    }
+
     private async runWatch(id: string, watch: LoginWatch): Promise<void> {
         while (this.now() < watch.deadline) {
             await this.sleep(LOGIN_POLL_MS);

package/src/providers/accounts/variables.ts

@@ -84,6 +84,7 @@ export function redactVariables(variables: readonly ProviderAccountVariable[]):
 export function keychainService(host: AccountsHost, home: string): string {
     return `${host.keychainPrefix}-provider-env-${createHash('sha256').update(resolve(home)).digest('hex').slice(0, 12)}`;
 }
+
 // `security` exits with this when no item matches.
 const NOT_FOUND = 44;
 

package/src/providers/claude.ts

@@ -39,7 +39,6 @@ interface ClaudeLaunch {
     folders?: readonly string[];
 }
 
-/* The argument list for one Claude Code chat process. */
 export function claudeArgs(launch: ClaudeLaunch): string[] {
     // The `=` form matters, since the flag is variadic and would swallow a prompt argument after it (measured on Claude Code 2.1.274).
     const args = [

package/src/providers/detect.ts

@@ -1,20 +1,11 @@
 import { spawnChatProcess, type SpawnChatProcess } from '../chat/chat-process.ts';
+import { definedEnv } from './accounts/launch.ts';
 
 export interface CliDetection {
     installed: boolean;
     version: string | null;
 }
 
-function definedOnly(env: Record<string, string | undefined>): Record<string, string> {
-    const defined: Record<string, string> = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (value !== undefined) {
-            defined[key] = value;
-        }
-    }
-    return defined;
-}
-
 /* Asks a CLI for its version; a missing binary is a plain "not installed", never an error. */
 export async function detectCli(
     command: string,
@@ -26,7 +17,7 @@ export async function detectCli(
         const code = new Promise<number | null>((resolve) => {
             exited = resolve;
         });
-        const proc = spawn({ command: [command, '--version'], cwd: process.cwd(), env: definedOnly(env), onExit: (exitCode) => exited(exitCode) });
+        const proc = spawn({ command: [command, '--version'], cwd: process.cwd(), env: definedEnv(env), onExit: (exitCode) => exited(exitCode) });
         proc.stdin.end();
         const output = await new Response(proc.stdout).text();
         if ((await code) !== 0) {

package/src/record-directory.ts

@@ -121,7 +121,6 @@ export class RecordDirectory<T> {
         return rm(this.pathOf(id), { force: true });
     }
 
-    /* Drops every record the predicate says is gone. */
     async prune(drop: (record: T) => boolean): Promise<void> {
         for (const record of this.all()) {
             if (drop(record)) {

package/src/skills.ts

@@ -5,7 +5,6 @@ import { dirname, join, parse } from 'node:path';
 import type { AgentKind, ChatSkill, ChatSkillSource } from '@adecore/agent-contracts';
 import { isNotFound } from './fs.ts';
 
-// One folder full of skill folders, and what the CLI calls the skills it finds there.
 export interface SkillRoot {
     dir: string;
     source: ChatSkillSource;

package/src/tasks/task-coordinator.ts

@@ -116,7 +116,6 @@ export class TaskCoordinator {
         await this.deps.tasks.settled();
     }
 
-    /* For `chats.observe()`. */
     chatEvent(event: AgentEvent): void {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -255,37 +254,7 @@ export class TaskCoordinator {
                 return;
             }
             if (after === 'gone') {
-                if (task.background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
-                    return;
-                }
-                const lost = task.background.itemIds.filter((id) => {
-                    const item = items.find((item) => item.id === id);
-                    return !item || (item.kind === 'subagent' ? item.status !== 'done' : item.kind !== 'tool' || item.state !== 'done');
-                });
-                if (lost.length > 0 || task.background.commands.length > 0) {
-                    this.settle(task, 'failed', {
-                        text: `The agent ended before its background work completed: ${[
-                            ...lost.map((id) => {
-                                const row = items.find((item) => item.id === id);
-                                return row?.kind === 'subagent' ? row.description || row.toolUseId : row?.kind === 'tool' ? row.name : id;
-                            }),
-                            ...task.background.commands
-                        ].join(', ')}. This work will not send a result.`,
-                        source: 'exit',
-                        at: this.deps.now()
-                    });
-                } else {
-                    const reports = task.background.itemIds.flatMap((id) => {
-                        const row = items.find((item) => item.id === id);
-                        const report = row?.kind === 'subagent' ? row.result : row?.kind === 'tool' ? row.output : null;
-                        return report ? [report] : [];
-                    });
-                    this.settle(task, 'done', {
-                        text: reports.join('\n\n') || resultOfTurn(turn, items, this.deps.now()).result.text,
-                        source: 'turn',
-                        at: this.deps.now()
-                    });
-                }
+                this.settleGone(task, task.background, turn, items);
                 return;
             }
         } else if (turn.state === 'done' && this.deps.limit.owed(task.id) && this.deps.afterBackgroundWork(chatId) === 'gone') {
@@ -296,6 +265,39 @@ export class TaskCoordinator {
         this.settle(task, status, result);
     }
 
+    /* The child's process went after its turn was held for background work; what that work left decides the task. */
+    private settleGone(task: Task, background: NonNullable<Task['background']>, turn: ChatTurnItem, items: readonly ChatItem[]): void {
+        if (background.itemIds.length === 0 && this.deps.limit.owed(task.id)) {
+            return;
+        }
+        const lost = background.itemIds.filter((id) => {
+            const item = items.find((item) => item.id === id);
+            return !item || (item.kind === 'subagent' ? item.status !== 'done' : item.kind !== 'tool' || item.state !== 'done');
+        });
+        if (lost.length > 0 || background.commands.length > 0) {
+            const names = lost.map((id) => {
+                const row = items.find((item) => item.id === id);
+                return row?.kind === 'subagent' ? row.description || row.toolUseId : row?.kind === 'tool' ? row.name : id;
+            });
+            this.settle(task, 'failed', {
+                text: `The agent ended before its background work completed: ${[...names, ...background.commands].join(', ')}. This work will not send a result.`,
+                source: 'exit',
+                at: this.deps.now()
+            });
+            return;
+        }
+        const reports = background.itemIds.flatMap((id) => {
+            const row = items.find((item) => item.id === id);
+            const report = row?.kind === 'subagent' ? row.result : row?.kind === 'tool' ? row.output : null;
+            return report ? [report] : [];
+        });
+        this.settle(task, 'done', {
+            text: reports.join('\n\n') || resultOfTurn(turn, items, this.deps.now()).result.text,
+            source: 'turn',
+            at: this.deps.now()
+        });
+    }
+
     /*
      * Whether work in the background keeps this task open past the turn. Commands and monitors alone hold
      * it only until the limit, owed from the moment they are all that is left; a subagent or a workflow
@@ -354,7 +356,7 @@ export class TaskCoordinator {
         if (!task || items === null || this.delegating(chatId)) {
             return;
         }
-        const last = [...items].reverse().find((item): item is ChatTurnItem => item.kind === 'turn');
+        const last = items.findLast((item): item is ChatTurnItem => item.kind === 'turn');
         if (last && last.state !== 'running' && last.createdAt >= task.createdAt) {
             this.turnEnded(chatId, last);
         }

package/src/tasks/task-store.ts

@@ -108,7 +108,7 @@ export class TaskStore {
     }
 
     /*
-     * Ends an open task with its result; false when it was not open any more, which is how the first of
+     * Ends an open task with its result; null when it was not open any more, which is how the first of
      * `done`, the end of a turn and an exit wins. A cancelled task wakes nobody.
      */
     async settle(id: string, status: 'done' | 'failed' | 'cancelled', result: TaskResult | null, now: number): Promise<Task | null> {

package/src/tasks/task-work.ts

@@ -3,8 +3,8 @@ import type { OutboxEntryOf, OutboxWorkShape } from '../outbox/outbox.ts';
 
 export const BackgroundLimitWorkSchema = z.object({
     kind: z.literal('background-limit'),
-    // The target is the child; the task its background commands hold open, and what they were when the limit started, for a child whose process went since.
-    // `restarted` marks an entry an earlier run of the host owed, whose commands went down with it.
+    // The target is the child. `commands` are what held its task open when the limit started, for a child whose
+    // process went since; `restarted` marks an entry an earlier run of the host owed, whose commands went down with it.
     payload: z.object({ taskId: z.string().min(1), commands: z.array(z.string()), restarted: z.literal(true).optional() })
 });
 

package/src/tasks/waiting-child.ts

@@ -82,7 +82,6 @@ export class WaitingObserver {
         this.stopped = true;
     }
 
-    /* For `chats.observe()`. */
     chatEvent(event: AgentEvent): void {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -108,15 +107,19 @@ export class WaitingObserver {
     }
 }
 
+function oneLine(text: string): string {
+    return text.replace(/\s+/g, ' ').trim();
+}
+
 function quoted(text: string): string {
-    return JSON.stringify(text.replace(/\s+/g, ' ').trim());
+    return JSON.stringify(oneLine(text));
 }
 
 /* The one line a note shows before "Show more": a question longer than that is read in the node. */
 const NOTE_QUESTION_LENGTH = 200;
 
 function quotedShort(text: string): string {
-    const line = text.replace(/\s+/g, ' ').trim();
+    const line = oneLine(text);
     return JSON.stringify(line.length > NOTE_QUESTION_LENGTH ? `${clipText(line, NOTE_QUESTION_LENGTH - 1)}…` : line);
 }
 

package/src/tasks/wake-parent.ts

@@ -1,4 +1,4 @@
-import type { Task } from '@adecore/agent-contracts';
+import type { ChatItem, Task } from '@adecore/agent-contracts';
 import type { WakeChat } from '../chat/wake-chat.ts';
 import type { OutboxOutcome } from '../outbox/outbox-worker.ts';
 import type { TaskStore } from './task-store.ts';
@@ -56,6 +56,24 @@ export function wakeNote(tasks: readonly Task[]): string {
     return `Woken by ${tasks.length} finished ${tasks.length === 1 ? 'task' : 'tasks'}`;
 }
 
+/* An unacknowledged attempt waits for a person's next turn, rather than retrying on every chat event. */
+function deliveryBlocked(items: readonly ChatItem[], tasks: readonly Task[]): boolean {
+    return items.some(
+        (item, index) =>
+            item.kind === 'turn' &&
+            item.deliveryPending &&
+            item.taskIds?.some((id) => tasks.some((task) => task.id === id)) &&
+            (item.state === 'running' || !items.slice(index + 1).some((later) => later.kind === 'turn' && later.origin !== 'agent'))
+    );
+}
+
+function deliveryPending(items: readonly ChatItem[], tasks: readonly Task[]): boolean {
+    return tasks.some((task) => {
+        const turn = items.findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
+        return turn?.kind === 'turn' && turn.deliveryPending;
+    });
+}
+
 export interface WakeParentDeps {
     tasks: Pick<TaskStore, 'pendingWake' | 'readyWake' | 'openBatches' | 'markWoken' | 'dropWake'>;
     /* The chat as it is now, loading it from disk when nobody has; null for a chat that has no thread any more. */
@@ -96,15 +114,7 @@ export function wakeParentHandler(deps: WakeParentDeps) {
         if (tasks.length === 0) {
             return held();
         }
-        // An unacknowledged attempt waits for a person's next turn, rather than retrying on every chat event.
-        const blocked = items.some(
-            (item, index) =>
-                item.kind === 'turn' &&
-                item.deliveryPending &&
-                item.taskIds?.some((id) => tasks.some((task) => task.id === id)) &&
-                (item.state === 'running' || !items.slice(index + 1).some((later) => later.kind === 'turn' && later.origin !== 'agent'))
-        );
-        if (blocked) {
+        if (deliveryBlocked(items, tasks)) {
             return 'wait';
         }
         const teamsOut = deps.tasks.openBatches(parentId).length;
@@ -119,12 +129,7 @@ export function wakeParentHandler(deps: WakeParentDeps) {
             return 'wait';
         }
         await chat.persist?.();
-        if (
-            tasks.some((task) => {
-                const turn = chat.items().findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
-                return turn?.kind === 'turn' && turn.deliveryPending;
-            })
-        ) {
+        if (deliveryPending(chat.items(), tasks)) {
             return 'wait';
         }
         await deps.tasks.markWoken(tasks.map((task) => task.id));

package/src/tasks/wiring.ts

@@ -3,6 +3,7 @@ import { reportsOnBackgroundWork } from '../chat/background-work.ts';
 import type { ChatCore } from '../chat/chat-core.ts';
 import { chatOpener, loadChat } from '../chat/wake-chat.ts';
 import { errorText } from '../error-text.ts';
+import { chatNoticeTargets } from '../messages/deliver-notice.ts';
 import type { OutboxHandlers } from '../outbox/outbox-worker.ts';
 import { backgroundLimitHandler, backgroundLimits } from './background-limit.ts';
 import { giveTaskHandler } from './give-task.ts';
@@ -85,6 +86,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
     const enqueue = (projectId: string, target: string, work: TaskWork, notBefore?: number): Promise<void> =>
         outbox.enqueue(projectId, target, work, notBefore);
     const limit = backgroundLimits(outbox);
+    const owesGiveTask = (taskId: string): boolean => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId);
     const coordinator = new TaskCoordinator({
         tasks: deps.tasks,
         now,
@@ -92,7 +94,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
         placed: (nodeId) => deps.placed(nodeId),
         loading: (chatId) => chats.isLoading(chatId),
         // Until the turn that carries a task ran, no turn of the child is its answer.
-        owedTurn: (taskId) => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId),
+        owedTurn: owesGiveTask,
         oweWake: (task) => oweWake({ enqueue }, task),
         alert: (nodeId, title, body) => deps.alert(nodeId, title, body),
         ...(deps.retryAt ? { retryAt: deps.retryAt } : {}),
@@ -131,43 +133,40 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
     });
 
     const chatFor = chatOpener({ chats, placed: deps.placed });
+    const targets = chatNoticeTargets(chats);
+
+    /* Owes again what an earlier run left of an open task, and lets its child's last turn settle it. */
+    const recoverOpen = async (task: Task): Promise<void> => {
+        if (task.requiresTaskTurn === true && deps.placed(task.childId) && !owesGiveTask(task.id)) {
+            await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
+        }
+        const stored = await chats.storedBackground(task.childId);
+        const storedWork = stored.items.length > 0 || stored.commands.length > 0;
+        if (!deps.placed(task.childId) || (task.background === undefined && task.requiresTaskTurn !== true && !storedWork)) {
+            return;
+        }
+        if (task.background === undefined && stored.turnId !== null && storedWork) {
+            await deps.tasks.holdBackground(task.id, {
+                turnId: stored.turnId,
+                itemIds: stored.items.map((item) => item.id),
+                commands: stored.commands
+            });
+        }
+        const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
+        if (chat && chat.info.activeTurnId === null) {
+            const last = chat.thread.list().findLast((item) => item.kind === 'turn');
+            if (last?.kind === 'turn') {
+                coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
+            }
+        }
+    };
 
     return {
         coordinator,
         recover: async () => {
             for (const task of deps.tasks.all()) {
-                if (task.status === 'open' && task.requiresTaskTurn === true && deps.placed(task.childId)) {
-                    if (!outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === task.id)) {
-                        await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
-                    }
-                }
-                const storedBackground = task.status === 'open' ? await chats.storedBackground(task.childId) : { turnId: null, items: [], commands: [] };
-                if (
-                    task.status === 'open' &&
-                    deps.placed(task.childId) &&
-                    (task.background !== undefined ||
-                        task.requiresTaskTurn === true ||
-                        storedBackground.items.length > 0 ||
-                        storedBackground.commands.length > 0)
-                ) {
-                    if (
-                        task.background === undefined &&
-                        storedBackground.turnId !== null &&
-                        (storedBackground.items.length > 0 || storedBackground.commands.length > 0)
-                    ) {
-                        await deps.tasks.holdBackground(task.id, {
-                            turnId: storedBackground.turnId,
-                            itemIds: storedBackground.items.map((item) => item.id),
-                            commands: storedBackground.commands
-                        });
-                    }
-                    const chat = await loadChat({ chats, placed: deps.placed }, task.childId);
-                    if (chat && chat.info.activeTurnId === null) {
-                        const last = chat.thread.list().findLast((item) => item.kind === 'turn');
-                        if (last?.kind === 'turn') {
-                            coordinator.chatEvent({ event: 'chat.event', payload: { chatId: task.childId, event: { type: 'item', item: last } } });
-                        }
-                    }
+                if (task.status === 'open') {
+                    await recoverOpen(task);
                 }
             }
             await coordinator.settled();
@@ -190,14 +189,7 @@ export function wireTasks(deps: TaskWiringDeps): TaskWiring {
                 await enqueue(task.projectId, task.childId, { kind: 'give-task', payload: { taskId: task.id } });
                 return task;
             },
-            chatState: async (nodeId) => {
-                const session = chats.get(nodeId);
-                if (session) {
-                    return session.info.activeTurnId === null ? 'idle' : 'running';
-                }
-                // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
-                return (await chats.hasStored(nodeId)) ? 'idle' : 'none';
-            },
+            chatState: (nodeId) => targets.chat(nodeId),
             done: (childId, text) => coordinator.done(childId, text),
             involving: (nodeId) => deps.tasks.involving(nodeId)
         },