@adecore/agents 0.49.4 → 0.49.5

package/dist/chat/chat-core.d.ts

@@ -182,6 +182,15 @@ export declare class ChatCore {
     writeRecord(chatId: string, info: ChatInfo, items: ChatItem[], preambles?: string[]): Promise<void>;
     deleteRecord(chatId: string): Promise<boolean>;
     lastTurn(chatId: string): Promise<ChatTurnItem | null>;
+    settleMessages(chatId: string, messages: ReadonlyArray<{
+        from: string;
+        text: string;
+    }>, state: 'heard' | 'dropped'): void;
+    steerMessages(chatId: string, steer: {
+        text: string;
+        preamble: string;
+        messageHop: number;
+    }): Promise<boolean>;
     addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): Promise<void>;
     deliverNote(chatId: string, delivery: {
         noteId: string;

package/dist/chat/chat-core.js

@@ -647,6 +647,14 @@ export class ChatCore {
         const stored = await this.store?.read(chatId);
         return stored?.items.findLast((item) => item.kind === 'turn') ?? null;
     }
+    /* What became of messages shown as waiting in a chat. One nobody has loaded catches up when it next takes a turn. */
+    settleMessages(chatId, messages, state) {
+        this.chats.get(chatId)?.settleMessages(messages, state);
+    }
+    /* Lets messages join a chat's running turn; false when it holds none that can take them. */
+    steerMessages(chatId, steer) {
+        return this.chats.get(chatId)?.steerMessages(steer) ?? Promise.resolve(false);
+    }
     /* A line from the host in a chat's thread, loading the chat when nobody has; nothing for a chat that is gone. */
     async addNote(chatId, level, text, message) {
         await this.loaded(chatId);

package/dist/chat/chat-session.d.ts

@@ -191,6 +191,7 @@ export declare class ChatSession {
         taskIds: string[];
         summaryFor?: string;
         messageFrom?: string[];
+        messageHop?: number;
         mentions?: string[];
         skills?: string[];
     }): string | null;
@@ -210,6 +211,15 @@ export declare class ChatSession {
         from?: string;
         preamble: string;
     }): boolean;
+    settleMessages(messages: ReadonlyArray<{
+        from: string;
+        text: string;
+    }>, state: 'heard' | 'dropped'): void;
+    steerMessages(steer: {
+        text: string;
+        preamble: string;
+        messageHop: number;
+    }): Promise<boolean>;
     upsertItems(items: readonly ChatItem[]): void;
     addNote(level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): void;
     end(reason: string): void;

package/dist/chat/chat-session.js

@@ -6,6 +6,7 @@ import { ChatError } from './errors.js';
 import { limitedTurn, limitResumeAt, limitResumeWake } from './limit-resume.js';
 import { isMainAgentOutput, ThreadProjector } from './projector.js';
 import { readableAssistantText } from './readable-text.js';
+import { turnHop } from '../messages/deliver-notice.js';
 import { ChatThread } from './thread.js';
 import { UiReplies } from './ui-replies.js';
 import { asError, errorText } from '../error-text.js';
@@ -897,6 +898,7 @@ export class ChatSession {
                 label: wake.label,
                 ...(wake.taskIds.length === 0 ? {} : { taskIds: wake.taskIds }),
                 ...(wake.messageFrom === undefined || wake.messageFrom.length === 0 ? {} : { messageFrom: wake.messageFrom }),
+                ...(wake.messageHop === undefined ? {} : { messageHop: wake.messageHop }),
                 ...(wake.summaryFor === undefined ? {} : { summaryFor: wake.summaryFor }),
                 endedAt: null,
                 costUsd: 0
@@ -937,7 +939,8 @@ export class ChatSession {
         const opened = this.wake({
             ...wake,
             taskIds: turn.taskIds ?? [],
-            ...(turn.messageFrom === undefined ? {} : { messageFrom: turn.messageFrom })
+            ...(turn.messageFrom === undefined ? {} : { messageFrom: turn.messageFrom }),
+            ...(turn.messageHop === undefined ? {} : { messageHop: turn.messageHop })
         });
         if (opened === null) {
             return 'wait';
@@ -1051,6 +1054,49 @@ export class ChatSession {
         this.options.persist();
         return true;
     }
+    /*
+     * What became of messages that were shown as waiting: the oldest line of each that still says so.
+     * Dropped stays on the line, heard is the plain line it is for every message from before this.
+     */
+    settleMessages(messages, state) {
+        const items = messages.flatMap(({ from, text }) => {
+            const line = this.thread
+                .list()
+                .find((item) => item.kind === 'note' && item.message?.state === 'waiting' && item.message.from === from && item.message.text === text);
+            if (line?.kind !== 'note' || line.message === undefined) {
+                return [];
+            }
+            const { state: _waiting, ...message } = line.message;
+            return [this.thread.upsert({ ...line, message: state === 'dropped' ? { ...message, state } : message })];
+        });
+        if (items.length > 0) {
+            this.emit(items);
+            this.options.persist();
+        }
+    }
+    /*
+     * Lets messages join the running turn, under the same limits as a person's steer. The turn then
+     * stands as far along the chain as they do, so what it sends next counts on from there.
+     */
+    async steerMessages(steer) {
+        const backend = this.backend;
+        const turnId = this.info.activeTurnId;
+        if (this.info.queuePaused || this.goalWorks() || !this.busy || !turnId || !backend?.steerTurn || this.pendingStart || this.replacementWaits()) {
+            return false;
+        }
+        const accepted = await backend
+            .steerTurn({ promptId: newId('steer'), text: steer.text, preamble: steer.preamble, attachments: [], mentions: [], skills: [] })
+            // A lost acknowledgement proves nothing. The message waits on, and is at worst heard twice rather than never.
+            .catch(() => false);
+        const turn = this.thread.get(turnId);
+        if (!accepted || turn?.kind !== 'turn') {
+            return accepted;
+        }
+        // Only the hop: `messageFrom` says what woke a turn, and this one was running already.
+        this.emit([this.thread.upsert({ ...turn, messageHop: Math.max(turnHop(this.thread.list(), turnId), steer.messageHop) })]);
+        this.options.persist();
+        return true;
+    }
     /* Writes items a host draws in the thread itself (a row for work it delegated), leaving the ones that did not change alone. */
     upsertItems(items) {
         const changed = items.filter((item) => JSON.stringify(this.thread.get(item.id)) !== JSON.stringify(item));

package/dist/chat/wake-chat.d.ts

@@ -10,6 +10,7 @@ export interface WakeChat {
         note?: string;
         taskIds: string[];
         messageFrom?: string[];
+        messageHop?: number;
     }): boolean;
     relocating?(): boolean;
 }

package/dist/coordination/index.d.ts

@@ -9,7 +9,7 @@ export { type ChatRequests, chatRequests, WAITING_GRACE_MS, WaitingObserver, typ
 export { RESULT_PREVIEW_BYTES, wakePrompt } from '../tasks/wake-parent.ts';
 export { type TaskVerbs, type TaskWords, wireTasks, type TaskChats, type TaskRecord, type TaskWiringDeps, type TaskWiring } from '../tasks/wiring.ts';
 export { DeliverMessageWorkSchema, deliverMessageHandler, type DeliverMessageWork, type DeliverMessageEntry, type DeliverMessageDeps } from '../messages/deliver-message.ts';
-export { type MessageWords, type ChatNoticeTargets, type ChatDelivery, chatNoticeTargets, deliverToChat, showNotices, type NoticeChat } from '../messages/deliver-notice.ts';
+export { type MessageWords, type ChatNoticeTargets, type ChatDelivery, chatNoticeTargets, MAX_MESSAGE_HOPS, steerNotices, withinHops, type SteerChat, deliverToChat, showNotices, type NoticeChat } from '../messages/deliver-notice.ts';
 export { NoticeNotes, unshownNotes } from '../messages/notice-notes.ts';
 export { MAX_NOTICES, NOTICE_MAX_AGE_MS, type Notice, NoticeStore } from '../messages/notice-store.ts';
 export { AgentLineageStore } from '../lineage.ts';

package/dist/coordination/index.js

@@ -10,7 +10,7 @@ export { chatRequests, WAITING_GRACE_MS, WaitingObserver } from '../tasks/waitin
 export { RESULT_PREVIEW_BYTES, wakePrompt } from '../tasks/wake-parent.js';
 export { wireTasks } from '../tasks/wiring.js';
 export { DeliverMessageWorkSchema, deliverMessageHandler } from '../messages/deliver-message.js';
-export { chatNoticeTargets, deliverToChat, showNotices } from '../messages/deliver-notice.js';
+export { chatNoticeTargets, MAX_MESSAGE_HOPS, steerNotices, withinHops, deliverToChat, showNotices } from '../messages/deliver-notice.js';
 export { NoticeNotes, unshownNotes } from '../messages/notice-notes.js';
 export { MAX_NOTICES, NOTICE_MAX_AGE_MS, NoticeStore } from '../messages/notice-store.js';
 export { AgentLineageStore } from '../lineage.js';

package/dist/messages/deliver-message.js

@@ -35,7 +35,8 @@ export function deliverMessageHandler(deps) {
             text: deps.words.prompt(waiting.length),
             label: deps.words.label(waiting),
             taskIds: [],
-            messageFrom: [...new Set(waiting.map((notice) => notice.from))]
+            messageFrom: [...new Set(waiting.map((notice) => notice.from))],
+            messageHop: Math.max(...waiting.map((notice) => notice.hop ?? 0))
         });
     };
 }

package/dist/messages/deliver-notice.d.ts

@@ -9,15 +9,25 @@ export interface MessageWords {
 }
 export interface ChatNoticeTargets {
     chat(id: string): Promise<'idle' | 'running' | 'none'>;
-    wokenBy(id: string): readonly string[];
+    hop(id: string): number;
 }
+export declare const MAX_MESSAGE_HOPS = 4;
 export interface ChatDelivery {
-    outcome: 'wake' | 'no-chat' | 'in-turn' | 'from-message';
+    outcome: 'wake' | 'no-chat' | 'in-turn' | 'hop-limit';
     waiting: number;
 }
-export declare function turnWokenBy(items: readonly ChatItem[], activeTurnId: string | null): readonly string[];
+export declare function turnHop(items: readonly ChatItem[], activeTurnId: string | null): number;
+export declare function withinHops(notice: Pick<Notice, 'hop'>): boolean;
 export declare function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): ChatNoticeTargets;
-export declare function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt'>): Promise<ChatDelivery>;
+export declare function deliverToChat(store: Pick<NoticeStore, 'put'>, targets: ChatNoticeTargets, notice: Omit<Notice, 'createdAt' | 'hop'>): Promise<ChatDelivery>;
+export interface SteerChat {
+    steer(chatId: string, steer: {
+        text: string;
+        preamble: string;
+        messageHop: number;
+    }): Promise<boolean>;
+}
+export declare function steerNotices(store: Pick<NoticeStore, 'waiting' | 'remove'>, chat: SteerChat, words: Pick<MessageWords, 'heard' | 'prompt'>, targetId: string): Promise<void>;
 export interface NoticeChat {
     has(id: string): Promise<boolean>;
     note(id: string, text: string, message: ChatNoteMessage): Promise<void>;

package/dist/messages/deliver-notice.js

@@ -1,26 +1,37 @@
 /*
- * Who sent the message that opened the turn a chat is running, empty when no message opened it,
- * 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 takes the step of the
- * turn before it.
+ * How far a chain of messages may wake chats: enough for a question, an answer and a report on each,
+ * and a bound on two agents reading each other, which nothing but a person should be able to keep going.
  */
-export function turnWokenBy(items, activeTurnId) {
+export const MAX_MESSAGE_HOPS = 4;
+/* Where a turn from before hops stood: its message and the answer it could still get. */
+const HOP_OF_OLDER_TURN = 2;
+/*
+ * How many messages led to the turn a chat is running. 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 takes the step of the turn before it.
+ */
+export function turnHop(items, activeTurnId) {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
     for (let i = from; i >= 0; i--) {
         const turn = items[i];
         if (turn.kind !== 'turn') {
             continue;
         }
-        const senders = turn.messageFrom ?? [];
-        if (senders.length > 0) {
-            return senders;
+        if (turn.messageHop !== undefined) {
+            return turn.messageHop;
+        }
+        if ((turn.messageFrom ?? []).length > 0) {
+            return HOP_OF_OLDER_TURN;
         }
         if (turn.origin !== 'agent' || turn.taskIds !== undefined || turn.summaryFor !== undefined) {
-            return [];
+            return 0;
         }
     }
-    return [];
+    return 0;
+}
+/* Whether a message may still move a chat. One of an older host has no hop and waits, as it always did. */
+export function withinHops(notice) {
+    return notice.hop !== undefined && notice.hop <= MAX_MESSAGE_HOPS;
 }
 /* The chats of a core as a message sees them. */
 export function chatNoticeTargets(chats) {
@@ -33,39 +44,65 @@ export function chatNoticeTargets(chats) {
             // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
             return (await chats.hasStored(id)) ? 'idle' : 'none';
         },
-        wokenBy: (id) => {
+        hop: (id) => {
             const session = chats.get(id);
-            return session === undefined ? [] : turnWokenBy(session.thread.list(), session.info.activeTurnId);
+            return session === undefined ? 0 : turnHop(session.thread.list(), session.info.activeTurnId);
         }
     };
 }
 /*
  * One message on its way to a chat, and whether the chat owes a turn on it. A chat between turns gets
  * one, as for a settled task, or the message sits there until someone happens to prompt that chat.
- * A turn a message opened wakes nobody with a message of its own, except the sender it answers,
- * once: only while that sender's own turn was opened by no message, so a question and its answer
- * take two steps and the turn the answer opens wakes nobody. A node that runs something else, such
- * as a terminal, is the host's to deliver to before this.
+ * Each message is one hop further than the turn that sent it, and past `MAX_MESSAGE_HOPS` it only
+ * waits. 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);
+    const hop = targets.hop(notice.from) + 1;
+    const waiting = await store.put({ ...notice, hop });
     const chat = await targets.chat(notice.targetId);
     if (chat === 'none') {
         return { outcome: 'no-chat', waiting };
     }
-    if (chat === 'running') {
-        return { outcome: 'in-turn', waiting };
+    if (hop > MAX_MESSAGE_HOPS) {
+        return { outcome: 'hop-limit', waiting };
+    }
+    return { outcome: chat === 'running' ? 'in-turn' : 'wake', waiting };
+}
+const steering = new Set();
+/*
+ * Hands what waits for a running chat to its running turn, one batch at a time per chat, so a message
+ * landing during a slow acknowledgement goes in the next batch and not twice. What the CLI did not take
+ * stays in the queue, for the turn that opens when this one ends.
+ */
+export async function steerNotices(store, chat, words, targetId) {
+    if (steering.has(targetId)) {
+        return;
+    }
+    steering.add(targetId);
+    try {
+        for (;;) {
+            const batch = store.waiting(targetId).filter(withinHops);
+            if (batch.length === 0) {
+                return;
+            }
+            const accepted = await chat.steer(targetId, {
+                text: words.prompt(batch.length),
+                preamble: batch.map((notice) => words.heard(notice)).join('\n\n'),
+                messageHop: Math.max(...batch.map((notice) => notice.hop ?? 0))
+            });
+            if (!accepted) {
+                return;
+            }
+            await store.remove(targetId, batch);
+        }
     }
-    const wokenBy = targets.wokenBy(notice.from);
-    const answer = wokenBy.includes(notice.targetId) && targets.wokenBy(notice.targetId).length === 0;
-    if (wokenBy.length > 0 && !answer) {
-        return { outcome: 'from-message', waiting };
+    finally {
+        steering.delete(targetId);
     }
-    return { outcome: 'wake', waiting };
 }
 /* The message itself on the line in the thread, so a client can draw it as said to the chat. */
 export function noticeMessage(notice) {
-    return { from: notice.from, title: notice.fromTitle, text: notice.text };
+    return { from: notice.from, title: notice.fromTitle, text: notice.text, state: 'waiting' };
 }
 /*
  * Shows a person the message in the chat's thread the moment it lands, not when the model gets round

package/dist/messages/notice-store.d.ts

@@ -9,6 +9,7 @@ declare const NoticeSchema: z.ZodObject<{
     text: z.ZodString;
     createdAt: z.ZodNumber;
     shown: z.ZodOptional<z.ZodBoolean>;
+    hop: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type Notice = z.infer<typeof NoticeSchema>;
 export declare class NoticeStore {
@@ -16,9 +17,14 @@ export declare class NoticeStore {
     private readonly queues;
     private readonly now;
     private lastDrop;
+    private settledListener;
     constructor(dataDir: string, now?: () => number);
     load(): Promise<void>;
     put(notice: Omit<Notice, 'createdAt'>): Promise<number>;
+    onSettled(listener: (targetId: string, notices: readonly Notice[], state: 'heard' | 'dropped') => void): void;
+    remove(targetId: string, notices: readonly Notice[]): Promise<void>;
+    private tell;
+    private stale;
     take(targetId: string): Notice[];
     settled(): Promise<void>;
     show(targetId: string): Promise<Notice[]>;

package/dist/messages/notice-store.js

@@ -23,7 +23,9 @@ const NoticeSchema = z.object({
      * emptied by the model reading the message, and the two readers must not take it from each
      * other. Absent is unshown, so a message left by an older host is still shown once.
      */
-    shown: z.boolean().optional()
+    shown: z.boolean().optional(),
+    /* How many messages led here since a person or a task last started something; absent for a message of an older host. */
+    hop: z.number().optional()
 });
 /* A queue waits in the file of the node it is for, so the first message in it names that node. */
 const FileSchema = z.object({ notices: z.array(NoticeSchema).min(1) });
@@ -37,6 +39,7 @@ export class NoticeStore {
     queues;
     now;
     lastDrop = Promise.resolve();
+    settledListener = null;
     constructor(dataDir, now = Date.now) {
         this.dir = join(dataDir, 'notices');
         this.now = now;
@@ -56,10 +59,31 @@ export class NoticeStore {
     }
     /* Puts one message in a node's queue and answers how many now wait for it. */
     async put(notice) {
-        const queue = [...this.waiting(notice.targetId), { ...notice, createdAt: this.now() }].slice(-MAX_NOTICES);
+        const before = this.waiting(notice.targetId);
+        const queue = [...before, { ...notice, createdAt: this.now() }].slice(-MAX_NOTICES);
+        const dropped = [...this.stale(notice.targetId), ...before.slice(0, Math.max(0, before.length + 1 - MAX_NOTICES))];
         await this.persist(notice.targetId, queue);
+        this.tell(notice.targetId, dropped, 'dropped');
         return queue.length;
     }
+    /* Who hears that a message left the queue, read or not, so a thread can say what became of it. */
+    onSettled(listener) {
+        this.settledListener = listener;
+    }
+    /* Takes these messages out of the queue once their model heard them while others stay behind. */
+    async remove(targetId, notices) {
+        const gone = new Set(notices.map((notice) => notice.createdAt));
+        await this.persist(targetId, this.waiting(targetId).filter((notice) => !gone.has(notice.createdAt)));
+        this.tell(targetId, notices, 'heard');
+    }
+    tell(targetId, notices, state) {
+        if (notices.length > 0) {
+            this.settledListener?.(targetId, notices, state);
+        }
+    }
+    stale(targetId) {
+        return (this.queues.get(targetId)?.notices ?? []).filter((notice) => !this.fresh(notice));
+    }
     /*
      * Everything waiting for a node, gone the moment it is asked for. Synchronous, because the
      * callers are: a shell's first screen and a hook's answer are both written before anything can
@@ -68,9 +92,11 @@ export class NoticeStore {
      */
     take(targetId) {
         const queue = this.waiting(targetId);
+        this.tell(targetId, this.stale(targetId), 'dropped');
         if (queue.length === 0) {
             return [];
         }
+        this.tell(targetId, queue, 'heard');
         this.lastDrop = this.persist(targetId, []).catch((e) => console.error(`Dropping the messages of ${targetId} failed:`, errorText(e)));
         return queue;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.49.4",
+  "version": "0.49.5",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -93,8 +93,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.49.4",
-    "@adecore/intelligent-ui": "0.49.4",
+    "@adecore/agent-contracts": "0.49.5",
+    "@adecore/intelligent-ui": "0.49.5",
     "zod": "^4.6.7"
   },
   "devDependencies": {

package/src/chat/chat-core.ts

@@ -985,6 +985,16 @@ export class ChatCore {
         return stored?.items.findLast((item): item is ChatTurnItem => item.kind === 'turn') ?? null;
     }
 
+    /* What became of messages shown as waiting in a chat. One nobody has loaded catches up when it next takes a turn. */
+    settleMessages(chatId: string, messages: ReadonlyArray<{ from: string; text: string }>, state: 'heard' | 'dropped'): void {
+        this.chats.get(chatId)?.settleMessages(messages, state);
+    }
+
+    /* Lets messages join a chat's running turn; false when it holds none that can take them. */
+    steerMessages(chatId: string, steer: { text: string; preamble: string; messageHop: number }): Promise<boolean> {
+        return this.chats.get(chatId)?.steerMessages(steer) ?? Promise.resolve(false);
+    }
+
     /* A line from the host in a chat's thread, loading the chat when nobody has; nothing for a chat that is gone. */
     async addNote(chatId: string, level: 'info' | 'warning' | 'error', text: string, message?: ChatNoteMessage): Promise<void> {
         await this.loaded(chatId);

package/src/chat/chat-session.ts

@@ -34,6 +34,7 @@ import { limitedTurn, limitResumeAt, limitResumeWake } from './limit-resume.ts';
 import { isMainAgentOutput, ThreadProjector } from './projector.ts';
 import { readableAssistantText } from './readable-text.ts';
 import type { SubagentSettlement } from './subagent-settlement.ts';
+import { turnHop } from '../messages/deliver-notice.ts';
 import { ChatThread } from './thread.ts';
 import { UiReplies, type UiReplyHost } from './ui-replies.ts';
 import { asError, errorText } from '../error-text.ts';
@@ -1246,6 +1247,7 @@ export class ChatSession {
         taskIds: string[];
         summaryFor?: string;
         messageFrom?: string[];
+        messageHop?: number;
         mentions?: string[];
         skills?: string[];
     }): string | null {
@@ -1270,6 +1272,7 @@ export class ChatSession {
                 label: wake.label,
                 ...(wake.taskIds.length === 0 ? {} : { taskIds: wake.taskIds }),
                 ...(wake.messageFrom === undefined || wake.messageFrom.length === 0 ? {} : { messageFrom: wake.messageFrom }),
+                ...(wake.messageHop === undefined ? {} : { messageHop: wake.messageHop }),
                 ...(wake.summaryFor === undefined ? {} : { summaryFor: wake.summaryFor }),
                 endedAt: null,
                 costUsd: 0
@@ -1317,7 +1320,8 @@ export class ChatSession {
         const opened = this.wake({
             ...wake,
             taskIds: turn.taskIds ?? [],
-            ...(turn.messageFrom === undefined ? {} : { messageFrom: turn.messageFrom })
+            ...(turn.messageFrom === undefined ? {} : { messageFrom: turn.messageFrom }),
+            ...(turn.messageHop === undefined ? {} : { messageHop: turn.messageHop })
         });
 
         if (opened === null) {
@@ -1464,6 +1468,61 @@ export class ChatSession {
         return true;
     }
 
+    /*
+     * What became of messages that were shown as waiting: the oldest line of each that still says so.
+     * Dropped stays on the line, heard is the plain line it is for every message from before this.
+     */
+    settleMessages(messages: ReadonlyArray<{ from: string; text: string }>, state: 'heard' | 'dropped'): void {
+        const items = messages.flatMap(({ from, text }) => {
+            const line = this.thread
+                .list()
+                .find((item) => item.kind === 'note' && item.message?.state === 'waiting' && item.message.from === from && item.message.text === text);
+
+            if (line?.kind !== 'note' || line.message === undefined) {
+                return [];
+            }
+
+            const { state: _waiting, ...message } = line.message;
+
+            return [this.thread.upsert({ ...line, message: state === 'dropped' ? { ...message, state } : message })];
+        });
+
+        if (items.length > 0) {
+            this.emit(items);
+            this.options.persist();
+        }
+    }
+
+    /*
+     * Lets messages join the running turn, under the same limits as a person's steer. The turn then
+     * stands as far along the chain as they do, so what it sends next counts on from there.
+     */
+    async steerMessages(steer: { text: string; preamble: string; messageHop: number }): Promise<boolean> {
+        const backend = this.backend;
+        const turnId = this.info.activeTurnId;
+
+        if (this.info.queuePaused || this.goalWorks() || !this.busy || !turnId || !backend?.steerTurn || this.pendingStart || this.replacementWaits()) {
+            return false;
+        }
+
+        const accepted = await backend
+            .steerTurn({ promptId: newId('steer'), text: steer.text, preamble: steer.preamble, attachments: [], mentions: [], skills: [] })
+            // A lost acknowledgement proves nothing. The message waits on, and is at worst heard twice rather than never.
+            .catch(() => false);
+
+        const turn = this.thread.get(turnId);
+
+        if (!accepted || turn?.kind !== 'turn') {
+            return accepted;
+        }
+
+        // Only the hop: `messageFrom` says what woke a turn, and this one was running already.
+        this.emit([this.thread.upsert({ ...turn, messageHop: Math.max(turnHop(this.thread.list(), turnId), steer.messageHop) })]);
+        this.options.persist();
+
+        return true;
+    }
+
     /* Writes items a host draws in the thread itself (a row for work it delegated), leaving the ones that did not change alone. */
     upsertItems(items: readonly ChatItem[]): void {
         const changed = items.filter((item) => JSON.stringify(this.thread.get(item.id)) !== JSON.stringify(item));

package/src/chat/wake-chat.ts

@@ -9,7 +9,7 @@ import type { ChatSession } from './chat-session.ts';
 export interface WakeChat {
     items(): ChatItem[];
     persist?(): Promise<void>;
-    wake(wake: { text: string; label: string; note?: string; taskIds: string[]; messageFrom?: string[] }): boolean;
+    wake(wake: { text: string; label: string; note?: string; taskIds: string[]; messageFrom?: string[]; messageHop?: number }): boolean;
     /* Whether the host is moving the chat to another folder, which turns every wake away until it ends. */
     relocating?(): boolean;
 }

package/src/coordination/index.ts

@@ -67,6 +67,10 @@ export {
     type ChatNoticeTargets,
     type ChatDelivery,
     chatNoticeTargets,
+    MAX_MESSAGE_HOPS,
+    steerNotices,
+    withinHops,
+    type SteerChat,
     deliverToChat,
     showNotices,
     type NoticeChat

package/src/messages/deliver-message.ts

@@ -60,7 +60,8 @@ export function deliverMessageHandler(deps: DeliverMessageDeps) {
             text: deps.words.prompt(waiting.length),
             label: deps.words.label(waiting),
             taskIds: [],
-            messageFrom: [...new Set(waiting.map((notice) => notice.from))]
+            messageFrom: [...new Set(waiting.map((notice) => notice.from))],
+            messageHop: Math.max(...waiting.map((notice) => notice.hop ?? 0))
         });
     };
 }

package/src/messages/deliver-notice.ts

@@ -18,28 +18,35 @@ export interface MessageWords {
 export interface ChatNoticeTargets {
     /* What the host holds under this id: a chat between turns, one that is in a turn, or no chat at all. */
     chat(id: string): Promise<'idle' | 'running' | 'none'>;
-    /* The senders whose message opened the turn this node is running, empty for a turn no message opened. */
-    wokenBy(id: string): readonly string[];
+    /* How many messages led to the turn this node is running; 0 for a turn no message opened. */
+    hop(id: string): number;
 }
 
 /*
- * Where a message for a chat went, and how many now wait for it. Only `wake` owes the chat a turn,
- * which the host opens through a `deliver-message` entry; every other outcome waits in the queue for
- * the chat's next turn.
+ * How far a chain of messages may wake chats: enough for a question, an answer and a report on each,
+ * and a bound on two agents reading each other, which nothing but a person should be able to keep going.
+ */
+export const MAX_MESSAGE_HOPS = 4;
+
+/* Where a turn from before hops stood: its message and the answer it could still get. */
+const HOP_OF_OLDER_TURN = 2;
+
+/*
+ * Where a message for a chat went, and how many now wait for it. Only `wake` owes the chat a turn now,
+ * which the host opens through a `deliver-message` entry; `in-turn` is owed one when that turn ends,
+ * or may join it; every other outcome waits in the queue for the chat's next turn.
  */
 export interface ChatDelivery {
-    outcome: 'wake' | 'no-chat' | 'in-turn' | 'from-message';
+    outcome: 'wake' | 'no-chat' | 'in-turn' | 'hop-limit';
     waiting: number;
 }
 
 /*
- * Who sent the message that opened the turn a chat is running, empty when no message opened it,
- * 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 takes the step of the
- * turn before it.
+ * How many messages led to the turn a chat is running. 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 takes the step of the turn before it.
  */
-export function turnWokenBy(items: readonly ChatItem[], activeTurnId: string | null): readonly string[] {
+export function turnHop(items: readonly ChatItem[], activeTurnId: string | null): number {
     const from = activeTurnId === null ? items.findLastIndex((item) => item.kind === 'turn') : items.findIndex((item) => item.id === activeTurnId);
 
     for (let i = from; i >= 0; i--) {
@@ -49,18 +56,25 @@ export function turnWokenBy(items: readonly ChatItem[], activeTurnId: string | n
             continue;
         }
 
-        const senders = turn.messageFrom ?? [];
+        if (turn.messageHop !== undefined) {
+            return turn.messageHop;
+        }
 
-        if (senders.length > 0) {
-            return senders;
+        if ((turn.messageFrom ?? []).length > 0) {
+            return HOP_OF_OLDER_TURN;
         }
 
         if (turn.origin !== 'agent' || turn.taskIds !== undefined || turn.summaryFor !== undefined) {
-            return [];
+            return 0;
         }
     }
 
-    return [];
+    return 0;
+}
+
+/* Whether a message may still move a chat. One of an older host has no hop and waits, as it always did. */
+export function withinHops(notice: Pick<Notice, 'hop'>): boolean {
+    return notice.hop !== undefined && notice.hop <= MAX_MESSAGE_HOPS;
 }
 
 /* The chats of a core as a message sees them. */
@@ -76,10 +90,10 @@ export function chatNoticeTargets(chats: Pick<ChatCore, 'get' | 'hasStored'>): C
             // A chat nobody has loaded is idle: the turn opens on the thread the host reads back from disk.
             return (await chats.hasStored(id)) ? 'idle' : 'none';
         },
-        wokenBy: (id) => {
+        hop: (id) => {
             const session = chats.get(id);
 
-            return session === undefined ? [] : turnWokenBy(session.thread.list(), session.info.activeTurnId);
+            return session === undefined ? 0 : turnHop(session.thread.list(), session.info.activeTurnId);
         }
     };
 }
@@ -87,31 +101,76 @@ 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, as for a settled task, or the message sits there until someone happens to prompt that chat.
- * A turn a message opened wakes nobody with a message of its own, except the sender it answers,
- * once: only while that sender's own turn was opened by no message, so a question and its answer
- * take two steps and the turn the answer opens wakes nobody. A node that runs something else, such
- * as a terminal, is the host's to deliver to before this.
+ * Each message is one hop further than the turn that sent it, and past `MAX_MESSAGE_HOPS` it only
+ * waits. 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);
+export async function deliverToChat(
+    store: Pick<NoticeStore, 'put'>,
+    targets: ChatNoticeTargets,
+    notice: Omit<Notice, 'createdAt' | 'hop'>
+): Promise<ChatDelivery> {
+    const hop = targets.hop(notice.from) + 1;
+    const waiting = await store.put({ ...notice, hop });
     const chat = await targets.chat(notice.targetId);
 
     if (chat === 'none') {
         return { outcome: 'no-chat', waiting };
     }
 
-    if (chat === 'running') {
-        return { outcome: 'in-turn', waiting };
+    if (hop > MAX_MESSAGE_HOPS) {
+        return { outcome: 'hop-limit', waiting };
     }
 
-    const wokenBy = targets.wokenBy(notice.from);
-    const answer = wokenBy.includes(notice.targetId) && targets.wokenBy(notice.targetId).length === 0;
+    return { outcome: chat === 'running' ? 'in-turn' : 'wake', waiting };
+}
+
+/* The chat a message may join while it runs. False when it cannot take one now, which leaves the message waiting. */
+export interface SteerChat {
+    steer(chatId: string, steer: { text: string; preamble: string; messageHop: number }): Promise<boolean>;
+}
+
+const steering = new Set<string>();
 
-    if (wokenBy.length > 0 && !answer) {
-        return { outcome: 'from-message', waiting };
+/*
+ * Hands what waits for a running chat to its running turn, one batch at a time per chat, so a message
+ * landing during a slow acknowledgement goes in the next batch and not twice. What the CLI did not take
+ * stays in the queue, for the turn that opens when this one ends.
+ */
+export async function steerNotices(
+    store: Pick<NoticeStore, 'waiting' | 'remove'>,
+    chat: SteerChat,
+    words: Pick<MessageWords, 'heard' | 'prompt'>,
+    targetId: string
+): Promise<void> {
+    if (steering.has(targetId)) {
+        return;
     }
 
-    return { outcome: 'wake', waiting };
+    steering.add(targetId);
+
+    try {
+        for (;;) {
+            const batch = store.waiting(targetId).filter(withinHops);
+
+            if (batch.length === 0) {
+                return;
+            }
+
+            const accepted = await chat.steer(targetId, {
+                text: words.prompt(batch.length),
+                preamble: batch.map((notice) => words.heard(notice)).join('\n\n'),
+                messageHop: Math.max(...batch.map((notice) => notice.hop ?? 0))
+            });
+
+            if (!accepted) {
+                return;
+            }
+
+            await store.remove(targetId, batch);
+        }
+    } finally {
+        steering.delete(targetId);
+    }
 }
 
 /* The chat a message was left for, as the two things showing it needs: whether it is there, and a line in its thread. */
@@ -124,7 +183,7 @@ export interface NoticeChat {
 
 /* The message itself on the line in the thread, so a client can draw it as said to the chat. */
 export function noticeMessage(notice: Notice): ChatNoteMessage {
-    return { from: notice.from, title: notice.fromTitle, text: notice.text };
+    return { from: notice.from, title: notice.fromTitle, text: notice.text, state: 'waiting' };
 }
 
 /*

package/src/messages/notice-store.ts

@@ -26,7 +26,9 @@ const NoticeSchema = z.object({
      * emptied by the model reading the message, and the two readers must not take it from each
      * other. Absent is unshown, so a message left by an older host is still shown once.
      */
-    shown: z.boolean().optional()
+    shown: z.boolean().optional(),
+    /* How many messages led here since a person or a task last started something; absent for a message of an older host. */
+    hop: z.number().optional()
 });
 
 export type Notice = z.infer<typeof NoticeSchema>;
@@ -46,6 +48,7 @@ export class NoticeStore {
     private readonly queues: RecordDirectory<NoticeFile>;
     private readonly now: () => number;
     private lastDrop: Promise<void> = Promise.resolve();
+    private settledListener: ((targetId: string, notices: readonly Notice[], state: 'heard' | 'dropped') => void) | null = null;
 
     constructor(dataDir: string, now: () => number = Date.now) {
         this.dir = join(dataDir, 'notices');
@@ -70,12 +73,40 @@ export class NoticeStore {
 
     /* Puts one message in a node's queue and answers how many now wait for it. */
     async put(notice: Omit<Notice, 'createdAt'>): Promise<number> {
-        const queue = [...this.waiting(notice.targetId), { ...notice, createdAt: this.now() }].slice(-MAX_NOTICES);
+        const before = this.waiting(notice.targetId);
+        const queue = [...before, { ...notice, createdAt: this.now() }].slice(-MAX_NOTICES);
+        const dropped = [...this.stale(notice.targetId), ...before.slice(0, Math.max(0, before.length + 1 - MAX_NOTICES))];
         await this.persist(notice.targetId, queue);
+        this.tell(notice.targetId, dropped, 'dropped');
 
         return queue.length;
     }
 
+    /* Who hears that a message left the queue, read or not, so a thread can say what became of it. */
+    onSettled(listener: (targetId: string, notices: readonly Notice[], state: 'heard' | 'dropped') => void): void {
+        this.settledListener = listener;
+    }
+
+    /* Takes these messages out of the queue once their model heard them while others stay behind. */
+    async remove(targetId: string, notices: readonly Notice[]): Promise<void> {
+        const gone = new Set(notices.map((notice) => notice.createdAt));
+        await this.persist(
+            targetId,
+            this.waiting(targetId).filter((notice) => !gone.has(notice.createdAt))
+        );
+        this.tell(targetId, notices, 'heard');
+    }
+
+    private tell(targetId: string, notices: readonly Notice[], state: 'heard' | 'dropped'): void {
+        if (notices.length > 0) {
+            this.settledListener?.(targetId, notices, state);
+        }
+    }
+
+    private stale(targetId: string): Notice[] {
+        return (this.queues.get(targetId)?.notices ?? []).filter((notice) => !this.fresh(notice));
+    }
+
     /*
      * Everything waiting for a node, gone the moment it is asked for. Synchronous, because the
      * callers are: a shell's first screen and a hook's answer are both written before anything can
@@ -84,11 +115,13 @@ export class NoticeStore {
      */
     take(targetId: string): Notice[] {
         const queue = this.waiting(targetId);
+        this.tell(targetId, this.stale(targetId), 'dropped');
 
         if (queue.length === 0) {
             return [];
         }
 
+        this.tell(targetId, queue, 'heard');
         this.lastDrop = this.persist(targetId, []).catch((e) => console.error(`Dropping the messages of ${targetId} failed:`, errorText(e)));
 
         return queue;