@adecore/agents 0.24.2 → 0.25.1

package/dist/messages/deliver-message.js

@@ -8,8 +8,9 @@ export const DeliverMessageWorkSchema = z.object({
  * 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 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.
+ * One attempt: 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. The one exception is a chat
+ * being moved to another folder, which has no turn and turns every wake away until the move ends.
  */
 export function deliverMessageHandler(deps) {
     return async (entry) => {
@@ -25,6 +26,9 @@ export function deliverMessageHandler(deps) {
         if (chat === null) {
             return;
         }
+        if (chat.relocating?.() === true) {
+            return 'wait';
+        }
         // 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({

package/dist/record-directory.js

@@ -101,9 +101,12 @@ export class RecordDirectory {
         return rm(this.pathOf(id), { force: true });
     }
     async prune(drop) {
-        for (const record of this.all()) {
-            if (drop(record)) {
-                await this.remove(this.idOf(record));
+        for (const listed of this.all()) {
+            const id = this.idOf(listed);
+            // Read again after each await: a record written meanwhile may no longer be one to drop.
+            const current = this.records.get(id);
+            if (current !== undefined && drop(current)) {
+                await this.remove(id);
             }
         }
     }

package/dist/testing/index.d.ts

@@ -1,6 +1,6 @@
 export { type FakeIo, type FakeProgram, type FakeCli, type StartedFake, type InProcessCli, inProcess, runOverStdio } from './fake-cli.ts';
 export { fakeClaude, claudeStoppingOnResume } from './fake-claude.ts';
 export { FAKE_CHILD_STEPS, fakeCodexForks, type FakeCodexOptions, fakeCodexWith, fakeCodex } from './fake-codex.ts';
-export { memorySecrets, testAccounts } from './accounts.ts';
+export { testAccounts } from './accounts.ts';
 export { ManualClock } from './manual-clock.ts';
-export { FakeDirectoryWatcher, FakeWatch, EventLog } from './watch.ts';
+export { FakeWatch, EventLog } from './watch.ts';

package/dist/testing/index.js

@@ -2,6 +2,6 @@
 export { inProcess, runOverStdio } from './fake-cli.js';
 export { fakeClaude, claudeStoppingOnResume } from './fake-claude.js';
 export { FAKE_CHILD_STEPS, fakeCodexForks, fakeCodexWith, fakeCodex } from './fake-codex.js';
-export { memorySecrets, testAccounts } from './accounts.js';
+export { testAccounts } from './accounts.js';
 export { ManualClock } from './manual-clock.js';
-export { FakeDirectoryWatcher, FakeWatch, EventLog } from './watch.js';
+export { FakeWatch, EventLog } from './watch.js';

package/package.json

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

package/src/chat/chat-core.ts

@@ -227,6 +227,8 @@ export class ChatCore {
     private readonly hooks: ChatCoreHooks;
     private readonly chats = new Map<string, ChatSession>();
     private readonly creating = new Map<string, Promise<ChatInfo>>();
+    // The relocations under way, settled (never rejected) when each ends.
+    private readonly relocations = new Map<string, Promise<void>>();
     private readonly sinks = new ClientSinks<AgentEvent>((clientId) => this.composerPreferences.forget(clientId));
     private readonly attached = new Map<string, Set<string>>();
     // How often a chat's bookmarks or visuals changed, so an attach can tell that its read went stale before it joined.
@@ -540,6 +542,7 @@ export class ChatCore {
     configure(payload: ChatConfigurePayload): ChatInfo {
         const session = this.require(payload.chatId);
         if (payload.account !== undefined) {
+            this.refuseWhileRelocating(payload.chatId);
             this.switchAccount(session, payload.account);
         }
         return session.configure(payload);
@@ -942,6 +945,7 @@ export class ChatCore {
     /* Ends the chat's CLI and keeps its conversation; the next message resumes it in a process that reads its skills and plugins again. */
     async restart(chatId: string): Promise<void> {
         const session = this.require(chatId);
+        this.refuseWhileRelocating(chatId);
         const ended = session.restart();
         this.skillIndex.forget(session.info.provider, session.info.cwd);
         await ended;
@@ -949,6 +953,7 @@ export class ChatCore {
 
     compact(chatId: string): void {
         const session = this.require(chatId);
+        this.refuseWhileRelocating(chatId);
         if (session.busy) {
             throw new ChatError('chat-busy', `Chat ${chatId} is still working on the previous message`);
         }
@@ -958,6 +963,7 @@ export class ChatCore {
     /* Empties the thread and drops the CLI's session and the chat's bookmarks and visuals; `force` stops a turn that is in the way. */
     async clear(chatId: string, force = false): Promise<void> {
         const session = this.require(chatId);
+        this.refuseWhileRelocating(chatId);
         if (session.busy && !force) {
             throw new ChatError('chat-busy', `Chat ${chatId} is still working on the previous message`);
         }
@@ -1020,9 +1026,80 @@ export class ChatCore {
         this.chats.get(chatId)?.releaseHold(key);
     }
 
+    /*
+     * Moves a loaded chat to another working folder. `during` is the host's own work and runs with the CLI
+     * already ended; messages sent meanwhile queue and go out in the new folder. Any throw keeps the old folder.
+     */
+    async relocate(chatId: string, cwd: string, during?: () => Promise<void>): Promise<ChatInfo> {
+        const session = this.require(chatId);
+        this.refuseUnlessRelocatable(session);
+        const running = this.relocateNow(session, cwd, during);
+        const tracked = running.then(
+            () => undefined,
+            () => undefined
+        );
+        this.relocations.set(chatId, tracked);
+        try {
+            return await running;
+        } finally {
+            if (this.relocations.get(chatId) === tracked) {
+                this.relocations.delete(chatId);
+            }
+        }
+    }
+
+    /* Whether a relocation of the chat is under way, which a host that forks or copies the chat has to refuse. */
+    isRelocating(chatId: string): boolean {
+        return this.relocations.has(chatId);
+    }
+
+    private async relocateNow(session: ChatSession, cwd: string, during: (() => Promise<void>) | undefined): Promise<ChatInfo> {
+        const chatId = session.id;
+        await this.hooks.admit?.(chatId, cwd);
+        // A message sent while the folder was asked about may have opened a turn.
+        if (!session.relocatable) {
+            throw this.busyRelocating(chatId);
+        }
+        const previous = session.info.cwd;
+        session.beginRelocate();
+        try {
+            await session.dropProcess();
+            await during?.();
+            session.setCwd(cwd);
+            await this.persistNow(chatId, true);
+        } catch (e) {
+            session.setCwd(previous);
+            throw e;
+        } finally {
+            session.endRelocate();
+        }
+        this.skillIndex.forget(session.info.provider, previous);
+        return session.info;
+    }
+
+    private refuseUnlessRelocatable(session: ChatSession): void {
+        if (this.relocations.has(session.id) || !session.relocatable) {
+            throw this.busyRelocating(session.id);
+        }
+    }
+
+    private busyRelocating(chatId: string): ChatError {
+        return new ChatError('chat-busy', `Chat ${chatId} is still working; stop it before moving it to another folder`);
+    }
+
+    private refuseWhileRelocating(chatId: string): void {
+        if (this.relocations.has(chatId)) {
+            throw new ChatError('chat-busy', `Chat ${chatId} is being moved to another folder`);
+        }
+    }
+
     /* Removes a chat: its CLI, its record, its log, its attachments, its bookmarks and its visuals. */
     async kill(chatId: string): Promise<void> {
         await this.loaded(chatId);
+        const moving = this.relocations.get(chatId);
+        if (moving) {
+            await moving;
+        }
         const session = this.require(chatId);
         // A write already out would put the record back after the delete.
         const writing = this.writes.get(chatId);

package/src/chat/chat-session.ts

@@ -19,7 +19,7 @@ import type {
     ModelSelection,
     RuntimeMode
 } from '@adecore/agent-contracts';
-import { HOST_TASK_ORIGIN, notResumedNote } from '@adecore/agent-contracts';
+import { ENDED_NOTE_PREFIX, HOST_TASK_ORIGIN, notResumedNote } from '@adecore/agent-contracts';
 import { resolveUiChoice, UI_FENCE_LANGUAGE, UiFailure } from '@adecore/intelligent-ui';
 import type { ChatProvider } from '../providers/provider.ts';
 import type { LimitsUpdate } from '../usage/limits/normalize.ts';
@@ -179,6 +179,9 @@ export class ChatSession {
     private launchedSelection: ModelSelection | null = null;
     // The account the running CLI was started under, which what it reports about a plan belongs to.
     private launchedAccount: string | undefined = undefined;
+    private launchedCwd: string | null = null;
+    // Set while the host moves the chat's folder: messages queue and nothing starts a process until it ends.
+    private relocating = false;
     private launchedRuntimeMode: RuntimeMode | null = null;
     private launchedFolders: readonly string[] = [];
     // The checkpoint of the turn in flight; everything queued for that turn waits for it.
@@ -327,6 +330,46 @@ export class ChatSession {
         return this.thread.info;
     }
 
+    /* The next process starts in this folder; the host moves the chat through `ChatCore.relocate`, which has already ended the old one. */
+    setCwd(cwd: string): ChatInfo {
+        if (cwd === this.thread.info.cwd) {
+            return this.thread.info;
+        }
+        this.emit([this.thread.patchInfo({ cwd })]);
+        this.options.persist();
+        return this.thread.info;
+    }
+
+    get relocatable(): boolean {
+        return (
+            !this.frozen &&
+            !this.relocating &&
+            this.thread.info.activeTurnId === null &&
+            !this.processInUse() &&
+            this.pendingStart === null &&
+            !this.thread.held
+        );
+    }
+
+    get isRelocating(): boolean {
+        return this.relocating;
+    }
+
+    /* Messages sent from here on queue, and the queue stays put until `endRelocate`. */
+    beginRelocate(): void {
+        this.relocating = true;
+    }
+
+    /*
+     * Lets the queue go, in whichever folder the chat has now. A wake that found the chat relocating
+     * was turned away and waits for an event of this chat, so one goes out even when the queue was empty.
+     */
+    endRelocate(): void {
+        this.relocating = false;
+        this.drainQueue();
+        this.emit([this.thread.patchInfo({})]);
+    }
+
     /*
      * Internal follow-ups wait for a new turn. User input goes through `sendInput`, which can steer native work.
      */
@@ -334,7 +377,7 @@ export class ChatSession {
         const extras = this.vetted(sent);
         const turnId = newId('turn');
         // Behind whatever still waits (a CLI that crashed leaves its queue), so everything goes out in the order it was sent.
-        if (this.busy || this.queue.length > 0 || this.replacementWaits()) {
+        if (this.busy || this.queue.length > 0 || this.replacementWaits() || this.relocating) {
             if (this.busy && this.info.queuePaused) {
                 this.sendAfterStop = true;
             }
@@ -579,6 +622,7 @@ export class ChatSession {
             !next ||
             this.steering.size > 0 ||
             this.busy ||
+            this.relocating ||
             (!explicit && (this.info.queuePaused || (limited !== null && (limited.limit.kind === 'usage' || this.info.resumeAt !== undefined))))
         ) {
             return;
@@ -969,7 +1013,7 @@ export class ChatSession {
      * with `origin: 'agent'` and close the wake it just made.
      */
     wake(wake: { text: string; label: string; note?: string; taskIds: string[]; summaryFor?: string; messageFrom?: string[] }): string | null {
-        if (this.frozen || this.thread.info.activeTurnId !== null || this.replacementWaits()) {
+        if (this.frozen || this.relocating || this.thread.info.activeTurnId !== null || this.replacementWaits()) {
             return null;
         }
         this.turnOpened();
@@ -1200,7 +1244,7 @@ export class ChatSession {
             }
         }
         if (turnId !== null) {
-            events.push(this.thread.upsert({ id: newId('note'), kind: 'note', createdAt: now, turnId, level: 'warning', text: reason }));
+            events.push(this.thread.upsert({ id: newId(`${ENDED_NOTE_PREFIX}note`), kind: 'note', createdAt: now, turnId, level: 'warning', text: reason }));
         }
         events.push(
             this.thread.patchInfo({
@@ -1226,6 +1270,14 @@ export class ChatSession {
         if (this.thread.info.activeTurnId !== null || this.processInUse()) {
             throw new ChatError('chat-busy', `Chat ${this.id} is still working; stop it before restarting its agent session`);
         }
+        return this.dropProcess();
+    }
+
+    /*
+     * Ends the CLI and keeps the conversation, like `restart` without its refusal: the caller has
+     * checked `relocatable` and holds the queue. Settles once the process exited or was sent the SIGKILL.
+     */
+    dropProcess(): Promise<void> {
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         const backend = this.backend;
@@ -1707,6 +1759,7 @@ export class ChatSession {
             (JSON.stringify(this.info.selection) !== JSON.stringify(this.launchedSelection) ||
                 this.info.runtimeMode !== this.launchedRuntimeMode ||
                 this.info.account !== this.launchedAccount ||
+                this.info.cwd !== this.launchedCwd ||
                 !sameFolders(this.options.folders?.() ?? [], this.launchedFolders))
         );
     }
@@ -1748,6 +1801,7 @@ export class ChatSession {
         const info = this.thread.info;
         this.launchedSelection = info.selection;
         this.launchedRuntimeMode = info.runtimeMode;
+        this.launchedCwd = info.cwd;
         const folders = this.options.folders?.() ?? [];
         this.launchedFolders = folders;
         const launch: BackendLaunch = {

package/src/chat/index.ts

@@ -30,7 +30,7 @@ export { type ChatRecordExtras, type ChatRecord, ChatStore, type ChatSeq, type C
 export { suggestChatTitle, type ChatTitleInput } from './chat-title.ts';
 export type { ClaudeBackendOptions } from './claude-backend.ts';
 export { ClaudeTitleReader } from './claude-title.ts';
-export { spokenText, claudeProjectSlug, findClaudeSession } from './claude-transcript.ts';
+export { claudeProjectSlug, findClaudeSession } from './claude-transcript.ts';
 export type { CodexBackendOptions } from './codex-backend.ts';
 export { forkThreadOnce, type ThreadItemsParams, type CodexProcessSpec, type ThreadForkParams } from './codex-thread.ts';
 export type { CodexClientInfo } from './codex-transport.ts';
@@ -46,4 +46,4 @@ export { ChatThread } from './thread.ts';
 export { type ChatUiSource, type ChatUiHost, ChatUiRefusal } from './ui-queries.ts';
 export { visualFileName, VisualStore, type VisualInput, type VisualStoreOptions, type VisualListener } from './visual-store.ts';
 export { type WakeChat, chatOpener, type ChatOpenerDeps } from './wake-chat.ts';
-export { type SkillRootOptions, SkillIndex } from '../skills.ts';
+export { type SkillRootOptions } from '../skills.ts';

package/src/chat/thread.ts

@@ -79,6 +79,10 @@ export class ChatThread {
         return { type: 'info', info: this.info };
     }
 
+    get held(): boolean {
+        return this.holds.size > 0;
+    }
+
     /* False when the key held the chat already. */
     hold(key: string): boolean {
         if (this.holds.has(key)) {

package/src/chat/ui-queries.ts

@@ -3,13 +3,17 @@ import type { z } from 'zod';
 import type {
     ChatUiLinkPayload,
     ChatUiLinkReading,
+    ChatUiPlaceReading,
+    ChatUiQueryState,
     ChatAssistantItem,
     ChatInfo,
     ChatUiChoicePayload,
     ChatUiQueryPayload,
     ChatUiQueryReading
 } from '@adecore/agent-contracts';
+import { ChatUiPlaceReadingSchema } from '@adecore/agent-contracts';
 import { copyUiValue, UI_HOST_LIMITS, UiBudget, uiMayReferenceHost, type UiValue } from '@adecore/intelligent-ui';
+import { uiPlaceQueries, type UiPlaceQuery } from '@adecore/intelligent-ui/places';
 import { UiLinkResolutionSchema, uiLinkTargets, type UiLinkTarget } from '@adecore/intelligent-ui/links';
 import { uiQueryArguments, uiQueryFallback } from '@adecore/intelligent-ui/query';
 import type { UiBlock } from '@adecore/intelligent-ui/compiler';
@@ -27,6 +31,12 @@ export interface ChatUiHost {
     capture(info: ChatInfo): Promise<unknown>;
     sources: Readonly<Record<string, ChatUiSource>>;
     link?(info: ChatInfo, access: unknown, target: UiLinkTarget): Promise<ChatUiLinkReading>;
+    /*
+     * Looks up the point of a Place that names an address, once, when its reply settles; the reading is
+     * frozen beside the block for every client. `signal` aborts after five seconds. A host without it
+     * freezes nothing, and such a place reads as not found.
+     */
+    place?(info: ChatInfo, query: UiPlaceQuery, signal: AbortSignal): Promise<Omit<ChatUiPlaceReading, 'address'>>;
 }
 
 interface CachedReading {
@@ -63,13 +73,20 @@ export class ChatUiRefusal extends UiQueryError {
 const MAX_QUERY_BYTES = 64 * 1024;
 const MAX_SNAPSHOT_BYTES = 128 * 1024;
 const READ_TIMEOUT_MS = 8_000;
+const PLACE_TIMEOUT_MS = 5_000;
+// Lookups run a few at a time, share one budget per block, and stop trying once the host keeps timing out.
+const PLACE_PARALLEL = 4;
+const PLACE_BLOCK_BUDGET_MS = 15_000;
+const PLACE_TIMEOUTS_IN_A_ROW = 3;
 // A changed input reads at once, but a query never reads more often than this across its inputs.
 const INPUT_READ_MS = 250;
 
 export class ChatUiQueries {
     readonly schemas: Record<string, z.ZodType>;
     private readonly captures = new Map<string, Promise<unknown>>();
-    private readonly freezing = new Set<string>();
+    private readonly freezing = new Map<string, Promise<void>>();
+    // Ends with the chat, so a lookup that is under way stops when its chat does.
+    private readonly lives = new Map<string, AbortController>();
     private readonly cache = new Map<string, CachedReading>();
     // The read id of the newest reading per cache key, which a remount or a second client is answered with.
     private readonly latest = new Map<string, string>();
@@ -101,8 +118,7 @@ export class ChatUiQueries {
         if (this.freezing.has(key)) {
             return;
         }
-        this.freezing.add(key);
-        void capture
+        const frozen = capture
             .then(async () => {
                 for (const block of (item.ui ?? []).slice(0, 16)) {
                     const current = session.thread.get(item.id);
@@ -139,6 +155,10 @@ export class ChatUiQueries {
                             }
                         }
                     }
+                    const { places, found, ended } = await this.lookUpPlaces(session, item.id, block, values);
+                    if (ended) {
+                        return;
+                    }
                     const latest = session.thread.get(item.id);
                     if (latest?.kind !== 'assistant' || !latest.uiQueries || latest.ui?.find((entry) => entry.id === block.id)?.revision !== block.revision) {
                         return;
@@ -150,11 +170,12 @@ export class ChatUiQueries {
                         .filter(([, reading]) => reading.state !== 'fresh')
                         .map(([name, reading]) => `${name}: ${reading.reason}`)
                         .join('\n');
-                    const frozen = {
+                    const frozen: ChatUiQueryState['blocks'][string] = {
                         revision: block.revision!,
                         readings,
                         links,
-                        fallback: `${uiQueryFallback(block, values).slice(0, 8192)}${names ? `\nSources: ${names}` : ''}${failures ? `\n${failures}` : ''}`
+                        ...(Object.keys(places).length > 0 ? { places } : {}),
+                        fallback: `${uiQueryFallback(block, values).slice(0, 8192)}${names ? `\nSources: ${names}` : ''}${failures ? `\n${failures}` : ''}${found.length > 0 ? `\nPlaces: ${found.join('; ')}` : ''}`
                     };
                     const blocks = { ...latest.uiQueries.blocks, [block.id]: frozen };
                     if (Buffer.byteLength(JSON.stringify(blocks)) > MAX_SNAPSHOT_BYTES) {
@@ -167,16 +188,140 @@ export class ChatUiQueries {
                         frozen.links = Object.fromEntries(
                             Object.keys(links).map((id) => [id, { state: 'plain', code: 'link-unchecked', reason: 'This link must be checked again.' }])
                         );
+                        if (frozen.places) {
+                            frozen.places = Object.fromEntries(
+                                Object.entries(places).map(([id, reading]) => [
+                                    id,
+                                    { state: 'missing', address: reading.address, code: 'snapshot-too-large', reason: 'The frozen places are too large.' }
+                                ])
+                            );
+                        }
                         frozen.fallback = `${block.fallback.slice(0, 2048)}\nSources: ${names}\nThe frozen query values are too large.`;
                     }
                     if (Buffer.byteLength(JSON.stringify(blocks)) > MAX_SNAPSHOT_BYTES) {
-                        delete blocks[block.id];
+                        // The block stays marked as frozen with nothing in it, so a reader stops waiting for readings that will not come.
+                        blocks[block.id] = { revision: block.revision!, readings: {}, fallback: '' };
                     }
                     session.updateUiQueries(item.id, { ...latest.uiQueries, blocks });
                 }
             })
             .catch(() => {})
             .finally(() => this.freezing.delete(key));
+        this.freezing.set(key, frozen);
+    }
+
+    /* Settles once the reply's readings, links and places are frozen, or at once where nothing is being frozen. */
+    async whenFrozen(session: ChatSession, itemId: string): Promise<void> {
+        await this.freezing.get(`${session.id}:${itemId}`);
+    }
+
+    /*
+     * The places of a block that name an address, looked up four at a time within one budget for the block.
+     * Past the budget, or after the host timed out three times in a row, the rest freeze as missing without
+     * asking. Nothing is asked once the chat ended, the reply is gone or the block changed; the caller then
+     * drops the write.
+     */
+    private async lookUpPlaces(
+        session: ChatSession,
+        itemId: string,
+        block: UiBlock,
+        values: Record<string, unknown>
+    ): Promise<{ places: Record<string, ChatUiPlaceReading>; found: string[]; ended: boolean }> {
+        const places: Record<string, ChatUiPlaceReading> = Object.create(null);
+        const found: string[] = [];
+        if (!this.host.place) {
+            return { places, found, ended: false };
+        }
+        let queries: Array<[string, UiPlaceQuery]>;
+        try {
+            queries = Object.entries(uiPlaceQueries(block, {}, values)).slice(0, UI_HOST_LIMITS.places);
+        } catch {
+            return { places, found, ended: false };
+        }
+        const life = this.lifeOf(session.id).signal;
+        const budget = new AbortController();
+        const timer = setTimeout(() => budget.abort(), PLACE_BLOCK_BUDGET_MS);
+        timer.unref?.();
+        const signal = AbortSignal.any([life, budget.signal]);
+        const readings = new Map<string, ChatUiPlaceReading>();
+        let timeouts = 0;
+        let next = 0;
+        const stillThere = (): boolean => {
+            const current = session.thread.get(itemId);
+            return !life.aborted && current?.kind === 'assistant' && current.ui?.find((entry) => entry.id === block.id)?.revision === block.revision;
+        };
+        const worker = async (): Promise<void> => {
+            for (let index = next++; index < queries.length; index = next++) {
+                const [id, query] = queries[index]!;
+                if (!stillThere()) {
+                    return;
+                }
+                if (budget.signal.aborted || timeouts >= PLACE_TIMEOUTS_IN_A_ROW) {
+                    readings.set(id, { state: 'missing', address: query.address, code: 'timed-out', reason: 'The place lookup timed out.' });
+                    continue;
+                }
+                const reading = await this.placeReading(session.info, query, signal);
+                timeouts = reading.code === 'timed-out' ? timeouts + 1 : 0;
+                readings.set(id, reading);
+            }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(PLACE_PARALLEL, queries.length) }, worker));
+        } finally {
+            clearTimeout(timer);
+        }
+        for (const [id, query] of queries) {
+            const reading = readings.get(id);
+            if (reading === undefined) {
+                continue;
+            }
+            places[id] = reading;
+            if (reading.state === 'found') {
+                found.push(`${query.name || query.address}: ${reading.lat}, ${reading.lon}`);
+            }
+        }
+        return { places, found, ended: life.aborted };
+    }
+
+    private lifeOf(chatId: string): AbortController {
+        let life = this.lives.get(chatId);
+        if (life === undefined) {
+            life = new AbortController();
+            this.lives.set(chatId, life);
+        }
+        return life;
+    }
+
+    /*
+     * One lookup, cut off after five seconds or when `outer` aborts. Whatever goes wrong is a reading that says
+     * the place is missing. Only a refusal the host chose its words for (`ChatUiRefusal`) carries them: any
+     * other error stays out of the shared record, which every client reads.
+     */
+    private async placeReading(info: ChatInfo, query: UiPlaceQuery, outer: AbortSignal): Promise<ChatUiPlaceReading> {
+        const timeout = new AbortController();
+        const timer = setTimeout(() => timeout.abort(), PLACE_TIMEOUT_MS);
+        timer.unref?.();
+        const signal = AbortSignal.any([timeout.signal, outer]);
+        try {
+            const reading = await Promise.race([
+                this.host.place!(info, query, signal),
+                new Promise<never>((_, reject) =>
+                    signal.addEventListener('abort', () => reject(new UiQueryError('refused-query', 'timed-out', 'The place lookup timed out.')), {
+                        once: true
+                    })
+                )
+            ]);
+            const parsed = ChatUiPlaceReadingSchema.parse({ ...(copyUiValue(reading, new UiBudget()) as object), address: query.address });
+            return parsed.state === 'found' && (parsed.lat === undefined || parsed.lon === undefined)
+                ? { state: 'missing', address: query.address, code: 'place-unreadable', reason: 'The host found no point for this address.' }
+                : parsed;
+        } catch (error) {
+            return error instanceof UiQueryError
+                ? { state: 'missing', address: query.address, ...this.failure(error) }
+                : { state: 'missing', address: query.address, code: 'lookup-failed', reason: 'The place could not be looked up.' };
+        } finally {
+            clearTimeout(timer);
+        }
     }
 
     /* The writer's access for a reply, captured once; null where it was denied or is unavailable. */
@@ -408,6 +553,8 @@ export class ChatUiQueries {
     }
 
     forget(chatId: string): void {
+        this.lives.get(chatId)?.abort();
+        this.lives.delete(chatId);
         for (const [id, cached] of this.cache) {
             if (cached.chatId === chatId) {
                 this.evict(id);
@@ -451,7 +598,7 @@ export class ChatUiQueries {
     }
 
     private failure(error: unknown): { reason: string; code?: string } {
-        const reason = (error instanceof Error ? error.message : 'This query could not be read.').slice(0, 240);
-        return error instanceof UiQueryError ? { reason, code: error.reason } : { reason };
+        // The reason is frozen into a record every client reads, so a message the host did not choose for that stays out of it.
+        return error instanceof UiQueryError ? { reason: error.message.slice(0, 240), code: error.reason } : { reason: 'This query could not be read.' };
     }
 }

package/src/chat/wake-chat.ts

@@ -10,6 +10,8 @@ export interface WakeChat {
     items(): ChatItem[];
     persist?(): Promise<void>;
     wake(wake: { text: string; label: string; note?: string; taskIds: string[]; messageFrom?: string[] }): boolean;
+    /* Whether the host is moving the chat to another folder, which turns every wake away until it ends. */
+    relocating?(): boolean;
 }
 
 export interface ChatOpenerDeps {
@@ -39,6 +41,7 @@ export function chatOpener(deps: ChatOpenerDeps) {
         return session
             ? {
                   items: () => session.thread.list(),
+                  relocating: () => session.isRelocating,
                   persist: () => deps.chats.save(chatId),
                   // A turn before the reset would stop on the same limit and spend one of the resume's tries, so it waits for the resume turn.
                   wake: (wake) => session.info.resumeAt === undefined && session.wake(wake) !== null

package/src/index.ts

@@ -3,7 +3,7 @@ export { wait, withTimeout } from './async.ts';
 export { CodedError } from './coded-error.ts';
 export { describeError, setErrorStacks, errorText } from './error-text.ts';
 export { tempNameFor, writeAtomic, replaceSync, writeAtomicSync, isNotFound, fileExists, type WriteAtomicOptions } from './fs.ts';
-export { recordFileName, RecordDirectory, type RecordDirectoryOptions } from './record-directory.ts';
+export { RecordDirectory, type RecordDirectoryOptions } from './record-directory.ts';
 export { runProcess, type ProcessResult, type RunProcessOptions } from './run-process.ts';
 export { Serializer, KeyedSerializer } from './serializer.ts';
 export { cleanTitle, readLines } from './title-file.ts';

package/src/lineage.ts

@@ -70,6 +70,15 @@ export class AgentLineageStore {
         return found;
     }
 
+    /* Moves a node's record to another project with its dates as they were; false when nothing was written down for it or a prune took it meanwhile. */
+    async rehome(nodeId: string, projectId: string): Promise<boolean> {
+        const entry = this.opened.get(nodeId);
+        if (entry === undefined) {
+            return false;
+        }
+        return this.opened.write({ ...entry, projectId });
+    }
+
     /* The project a node was made in, for work owed about it after the node that opened it is gone. */
     projectOf(nodeId: string): string | null {
         return this.opened.get(nodeId)?.projectId ?? null;