@adecore/agents 0.21.0 → 0.21.2

package/dist/host/wiring.js

@@ -6,10 +6,10 @@ import { suggestChatTitle } from '../chat/chat-title.js';
 import { VisualStore } from '../chat/visual-store.js';
 import { ClaudeTitleReader } from '../chat/claude-title.js';
 import { DEFAULT_CODEX_CLIENT } from '../chat/codex-transport.js';
+import { errorText } from '../error-text.js';
 import { definedEnv } from '../providers/accounts/launch.js';
 import { ProviderAccountsService } from '../providers/accounts/service.js';
 import { createClaudeProvider } from '../providers/claude-provider.js';
-import { errorText } from '../error-text.js';
 import { createCodexProvider } from '../providers/codex-provider.js';
 import { codexRulesPathIn, defaultCodexHome, installCodexRules } from '../providers/codex-rules.js';
 import { ProviderRegistry } from '../providers/registry.js';

package/dist/lineage.js

@@ -25,8 +25,8 @@ function openedByAgent(entry) {
     return entry.agent && entry.relation !== 'fork';
 }
 /*
- * Lineage lives in `lineage` under the host's data folder, outside the agent-writable project, so agents
- * cannot reset their own depth. Persisting it also prevents a restart of the host from resetting recursion limits.
+ * Lives under the host's data folder, outside the agent-writable project, so an agent cannot reset its
+ * own depth; on disk, so a restart of the host does not reset it either.
  */
 export class AgentLineageStore {
     dir;
@@ -117,7 +117,6 @@ export class AgentLineageStore {
         const entry = this.opened.get(nodeId);
         return entry?.relation === 'fork' ? entry.openedBy : null;
     }
-    /* The forks made from a chat. */
     forksOf(nodeId) {
         return [...this.opened.all()].filter((entry) => entry.relation === 'fork' && entry.openedBy === nodeId).map((entry) => entry.nodeId);
     }

package/dist/messages/deliver-message.js

@@ -5,13 +5,11 @@ export const DeliverMessageWorkSchema = z.object({
     payload: z.object({ from: z.string().min(1) })
 });
 /*
- * 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) {
     return async (entry) => {
@@ -27,11 +25,8 @@ export function deliverMessageHandler(deps) {
         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/dist/messages/deliver-notice.js

@@ -1,9 +1,8 @@
 /*
- * 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, activeTurnId) {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
@@ -40,10 +39,9 @@ export function chatNoticeTargets(chats) {
 }
 /*
  * 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, targets, notice) {
     const waiting = await store.put(notice);
@@ -60,10 +58,8 @@ export async function deliverToChat(store, targets, notice) {
     return { outcome: 'wake', waiting };
 }
 /*
- * 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, chat, words, targetId) {
     if (!(await chat.has(targetId))) {

package/dist/messages/notice-store.js

@@ -5,10 +5,8 @@ import { RecordDirectory } from '../record-directory.js';
 // Per receiver. Past this the oldest goes: an agent in a loop must not fill a queue nobody reads.
 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;
 const NoticeSchema = z.object({
@@ -109,7 +107,7 @@ export class NoticeStore {
     fresh(notice) {
         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. */
     async persist(targetId, queue) {
         if (queue.length === 0) {
             await this.queues.remove(targetId);

package/dist/outbox/outbox-worker.js

@@ -80,6 +80,9 @@ export class OutboxWorker {
         const now = this.clock.now();
         const busy = new Set(this.running);
         let nextDue = null;
+        const dueAt = (at) => {
+            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)) {
@@ -87,7 +90,7 @@ export class OutboxWorker {
             }
             // 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);
@@ -100,7 +103,7 @@ export class OutboxWorker {
                 continue;
             }
             if (entry.notBefore > now) {
-                nextDue = nextDue === null ? entry.notBefore : Math.min(nextDue, entry.notBefore);
+                dueAt(entry.notBefore);
                 continue;
             }
             void this.run(entry);

package/dist/providers/accounts/service.d.ts

@@ -1,4 +1,5 @@
 import { type AgentKind, type ProviderAccount, type ProviderAccountCreatePayload, type ProviderAccountCreateResult, type ProviderAccountMap, type ProviderAccounts, type ProviderInfo } from '@adecore/agent-contracts';
+import { type CodexClientInfo } from '../../chat/codex-transport.ts';
 import type { AgentSink } from '../../events.ts';
 import type { ChatProvider } from '../provider.ts';
 import { type Env } from './accounts.ts';
@@ -6,7 +7,6 @@ import { type AccountLaunches } from './launch.ts';
 import { type ShadowHomeReport } from './shadow-home.ts';
 import { type AskAccount } from './status.ts';
 import { type AccountsHost, type SecretStore } from './variables.ts';
-import { type CodexClientInfo } from '../../chat/codex-transport.ts';
 export interface ProviderAccountsOptions {
     home: string;
     host?: AccountsHost;
@@ -68,6 +68,7 @@ export declare class ProviderAccountsService implements AccountLaunches {
     create(payload: ProviderAccountCreatePayload): Promise<ProviderAccountCreateResult>;
     watchLogin(id: string): Promise<void>;
     refresh(): Promise<ProviderAccounts>;
+    private folderOf;
     private runWatch;
     private serial;
     private commit;

package/dist/providers/accounts/service.js

@@ -2,6 +2,7 @@ import { existsSync, statSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AgentKindSchema } from '@adecore/agent-contracts';
+import { DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
 import { ClientSinks } from '../../client-sinks.js';
 import { errorText } from '../../error-text.js';
 import { accountEnv, accountFolder, canContinue, defaultFolder, expandHome, isDefaultAccount, isKnownKind, transcriptFolder } from './accounts.js';
@@ -10,7 +11,6 @@ import { prepareShadowHome } from './shadow-home.js';
 import { askAccountAs } from './status.js';
 import { acceptAccounts, accountsPath, InvalidAccountError, readAccounts, wireAccounts, writeAccounts } from './store.js';
 import { DEFAULT_ACCOUNTS_HOST, platformSecrets, secretKey, SecretsUnavailableError } from './variables.js';
-import { DEFAULT_CODEX_CLIENT } from '../../chat/codex-transport.js';
 /* 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;
 const MAX_BACKOFF_MS = 60 * 60_000;
@@ -161,20 +161,10 @@ export class ProviderAccountsService {
         return accountEnv(key, account, provider, baseEnv, variables(account));
     }
     transcriptFolder(kind, id) {
-        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, id) {
-        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, from, to) {
         const fromId = from ?? kind;
@@ -268,6 +258,14 @@ export class ProviderAccountsService {
         await this.queue(true);
         return this.snapshot();
     }
+    folderOf(kind, id, folder) {
+        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);
+    }
     async runWatch(id, watch) {
         while (this.now() < watch.deadline) {
             await this.sleep(LOGIN_POLL_MS);

package/dist/providers/claude.js

@@ -25,7 +25,6 @@ export function claudeRuntimeMode(mode) {
     }
     return Object.keys(PERMISSION_MODE).find((key) => PERMISSION_MODE[key] === mode);
 }
-/* The argument list for one Claude Code chat process. */
 export function claudeArgs(launch) {
     // 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/dist/providers/detect.js

@@ -1,13 +1,5 @@
 import { spawnChatProcess } from '../chat/chat-process.js';
-function definedOnly(env) {
-    const defined = {};
-    for (const [key, value] of Object.entries(env)) {
-        if (value !== undefined) {
-            defined[key] = value;
-        }
-    }
-    return defined;
-}
+import { definedEnv } from './accounts/launch.js';
 /* Asks a CLI for its version; a missing binary is a plain "not installed", never an error. */
 export async function detectCli(command, env = process.env, spawn = spawnChatProcess) {
     try {
@@ -15,7 +7,7 @@ export async function detectCli(command, env = process.env, spawn = spawnChatPro
         const code = new Promise((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/dist/record-directory.js

@@ -100,7 +100,6 @@ export class RecordDirectory {
         this.records.delete(id);
         return rm(this.pathOf(id), { force: true });
     }
-    /* Drops every record the predicate says is gone. */
     async prune(drop) {
         for (const record of this.all()) {
             if (drop(record)) {

package/dist/tasks/task-coordinator.d.ts

@@ -40,6 +40,7 @@ export declare class TaskCoordinator {
     private failed;
     private answers;
     private turnEnded;
+    private settleGone;
     private heldInBackground;
     private pauseFor;
     private turnStarted;

package/dist/tasks/task-coordinator.js

@@ -1,12 +1,16 @@
 import { abortedByMachine, clipText } from '@adecore/agent-contracts';
 import { BACKGROUND_COMMAND_LIMIT_MS, commandLabel, isBackgroundWork, runningInBackground, runsInBackground } from '../chat/background-work.js';
+import { readableAssistantText } from '../chat/readable-text.js';
 import { errorText } from '../error-text.js';
 // A child's answer is its last word of the turn; the thinking and the tools before it are not the result.
 function answerOf(items, turnId) {
     for (let i = items.length - 1; i >= 0; i--) {
         const item = items[i];
-        if (item.kind === 'assistant' && item.turnId === turnId && !item.parentToolUseId && item.text.trim() !== '') {
-            return item.text.trim();
+        if (item.kind === 'assistant' && item.turnId === turnId && !item.parentToolUseId) {
+            const text = readableAssistantText(item).trim();
+            if (text !== '') {
+                return text;
+            }
         }
     }
     return null;
@@ -67,7 +71,6 @@ export class TaskCoordinator {
         }
         await this.deps.tasks.settled();
     }
-    /* For `chats.observe()`. */
     chatEvent(event) {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -197,38 +200,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;
             }
         }
@@ -239,6 +211,38 @@ export class TaskCoordinator {
         const { status, result } = resultOfTurn(turn, items, this.deps.now());
         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. */
+    settleGone(task, background, turn, items) {
+        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
@@ -293,7 +297,7 @@ export class TaskCoordinator {
         if (!task || items === null || this.delegating(chatId)) {
             return;
         }
-        const last = [...items].reverse().find((item) => item.kind === 'turn');
+        const last = items.findLast((item) => item.kind === 'turn');
         if (last && last.state !== 'running' && last.createdAt >= task.createdAt) {
             this.turnEnded(chatId, last);
         }

package/dist/tasks/task-store.js

@@ -80,7 +80,7 @@ export class TaskStore {
         return this.sorted().filter((task) => task.projectId === projectId);
     }
     /*
-     * 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, status, result, now) {

package/dist/tasks/task-work.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 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() })
 });
 export const WakeParentWorkSchema = z.object({

package/dist/tasks/waiting-child.js

@@ -51,7 +51,6 @@ export class WaitingObserver {
     stop() {
         this.stopped = true;
     }
-    /* For `chats.observe()`. */
     chatEvent(event) {
         if (this.stopped || event.event !== 'chat.event') {
             return;
@@ -71,13 +70,16 @@ export class WaitingObserver {
             .catch((e) => (this.deps.log ?? console.error)(`Owing a note about ${chatId} failed: ${errorText(e)}`));
     }
 }
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
 function quoted(text) {
-    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) {
-    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);
 }
 /* One question as the parent's CLI reads it, with the choices it may pick from. */

package/dist/tasks/wake-parent.js

@@ -43,6 +43,19 @@ export function wakeLabel(tasks) {
 export function wakeNote(tasks) {
     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, tasks) {
+    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, tasks) {
+    return tasks.some((task) => {
+        const turn = items.findLast((item) => item.kind === 'turn' && item.taskIds?.includes(task.id));
+        return turn?.kind === 'turn' && turn.deliveryPending;
+    });
+}
 /*
  * CLI acceptance lives in the saved turn before the task store consumes its result, so a restart
  * between those writes can finish delivery without opening another turn.
@@ -75,12 +88,7 @@ export function wakeParentHandler(deps) {
         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;
@@ -93,10 +101,7 @@ export function wakeParentHandler(deps) {
             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/dist/tasks/wiring.js

@@ -1,6 +1,7 @@
 import { reportsOnBackgroundWork } from '../chat/background-work.js';
 import { chatOpener, loadChat } from '../chat/wake-chat.js';
 import { errorText } from '../error-text.js';
+import { chatNoticeTargets } from '../messages/deliver-notice.js';
 import { backgroundLimitHandler, backgroundLimits } from './background-limit.js';
 import { giveTaskHandler } from './give-task.js';
 import { TaskCoordinator } from './task-coordinator.js';
@@ -16,6 +17,7 @@ export function wireTasks(deps) {
     const { chats, outbox } = deps;
     const enqueue = (projectId, target, work, notBefore) => outbox.enqueue(projectId, target, work, notBefore);
     const limit = backgroundLimits(outbox);
+    const owesGiveTask = (taskId) => outbox.list().some((entry) => isGiveTask(entry) && entry.payload.taskId === taskId);
     const coordinator = new TaskCoordinator({
         tasks: deps.tasks,
         now,
@@ -23,7 +25,7 @@ export function wireTasks(deps) {
         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 } : {}),
@@ -58,38 +60,38 @@ export function wireTasks(deps) {
         }
     });
     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) => {
+        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();
@@ -110,14 +112,7 @@ export function wireTasks(deps) {
                 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)
         },