@adecore/agents 0.24.2 → 0.25.0

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

@@ -92,6 +92,7 @@ export declare class ChatCore {
     private readonly hooks;
     private readonly chats;
     private readonly creating;
+    private readonly relocations;
     private readonly sinks;
     private readonly attached;
     private readonly listChanges;
@@ -236,6 +237,12 @@ export declare class ChatCore {
     dismiss(chatId: string, itemId: string): void;
     holdForPerson(chatId: string, key: string): boolean;
     releaseHold(chatId: string, key: string): void;
+    relocate(chatId: string, cwd: string, during?: () => Promise<void>): Promise<ChatInfo>;
+    isRelocating(chatId: string): boolean;
+    private relocateNow;
+    private refuseUnlessRelocatable;
+    private busyRelocating;
+    private refuseWhileRelocating;
     kill(chatId: string): Promise<void>;
     stop(chatId: string, reason: string): Promise<void>;
     processTargets(): {

package/dist/chat/chat-core.js

@@ -57,6 +57,8 @@ export class ChatCore {
     hooks;
     chats = new Map();
     creating = new Map();
+    // The relocations under way, settled (never rejected) when each ends.
+    relocations = new Map();
     sinks = new ClientSinks((clientId) => this.composerPreferences.forget(clientId));
     attached = new Map();
     // How often a chat's bookmarks or visuals changed, so an attach can tell that its read went stale before it joined.
@@ -350,6 +352,7 @@ export class ChatCore {
     configure(payload) {
         const session = this.require(payload.chatId);
         if (payload.account !== undefined) {
+            this.refuseWhileRelocating(payload.chatId);
             this.switchAccount(session, payload.account);
         }
         return session.configure(payload);
@@ -712,12 +715,14 @@ 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) {
         const session = this.require(chatId);
+        this.refuseWhileRelocating(chatId);
         const ended = session.restart();
         this.skillIndex.forget(session.info.provider, session.info.cwd);
         await ended;
     }
     compact(chatId) {
         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`);
         }
@@ -726,6 +731,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, force = false) {
         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`);
         }
@@ -780,9 +786,74 @@ export class ChatCore {
     releaseHold(chatId, key) {
         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, cwd, during) {
+        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) {
+        return this.relocations.has(chatId);
+    }
+    async relocateNow(session, cwd, during) {
+        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;
+    }
+    refuseUnlessRelocatable(session) {
+        if (this.relocations.has(session.id) || !session.relocatable) {
+            throw this.busyRelocating(session.id);
+        }
+    }
+    busyRelocating(chatId) {
+        return new ChatError('chat-busy', `Chat ${chatId} is still working; stop it before moving it to another folder`);
+    }
+    refuseWhileRelocating(chatId) {
+        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) {
         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/dist/chat/chat-session.d.ts

@@ -92,6 +92,8 @@ export declare class ChatSession {
     private awaitingBackgroundReport;
     private launchedSelection;
     private launchedAccount;
+    private launchedCwd;
+    private relocating;
     private launchedRuntimeMode;
     private launchedFolders;
     private turnReady;
@@ -125,6 +127,11 @@ export declare class ChatSession {
         resumeAtReset?: boolean;
     }): ChatInfo;
     setAccount(account: string | undefined): ChatInfo;
+    setCwd(cwd: string): ChatInfo;
+    get relocatable(): boolean;
+    get isRelocating(): boolean;
+    beginRelocate(): void;
+    endRelocate(): void;
     send(text: string, sent?: ChatSendExtras): {
         queued: boolean;
         turnId: string;
@@ -190,6 +197,7 @@ export declare class ChatSession {
     addNote(level: 'info' | 'warning' | 'error', text: string): void;
     end(reason: string): void;
     restart(): Promise<void>;
+    dropProcess(): Promise<void>;
     freeze(): void;
     dispose(): Promise<void>;
     turnDiff(turnId: string): Promise<ChatCheckpointDiff | null>;

package/dist/chat/chat-session.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-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 { commandLabel, isBackgroundWork, reportsOnBackgroundWork, runningInBackground } from './background-work.js';
 import { ChatError } from './errors.js';
@@ -55,6 +55,9 @@ export class ChatSession {
     launchedSelection = null;
     // The account the running CLI was started under, which what it reports about a plan belongs to.
     launchedAccount = undefined;
+    launchedCwd = null;
+    // Set while the host moves the chat's folder: messages queue and nothing starts a process until it ends.
+    relocating = false;
     launchedRuntimeMode = null;
     launchedFolders = [];
     // The checkpoint of the turn in flight; everything queued for that turn waits for it.
@@ -189,6 +192,39 @@ export class ChatSession {
         this.drainQueue();
         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) {
+        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() {
+        return (!this.frozen &&
+            !this.relocating &&
+            this.thread.info.activeTurnId === null &&
+            !this.processInUse() &&
+            this.pendingStart === null &&
+            !this.thread.held);
+    }
+    get isRelocating() {
+        return this.relocating;
+    }
+    /* Messages sent from here on queue, and the queue stays put until `endRelocate`. */
+    beginRelocate() {
+        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() {
+        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.
      */
@@ -196,7 +232,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;
             }
@@ -422,6 +458,7 @@ export class ChatSession {
         if (!next ||
             this.steering.size > 0 ||
             this.busy ||
+            this.relocating ||
             (!explicit && (this.info.queuePaused || (limited !== null && (limited.limit.kind === 'usage' || this.info.resumeAt !== undefined))))) {
             return;
         }
@@ -790,7 +827,7 @@ export class ChatSession {
      * with `origin: 'agent'` and close the wake it just made.
      */
     wake(wake) {
-        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();
@@ -1007,7 +1044,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({
             running: false,
@@ -1030,6 +1067,13 @@ 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() {
         this.clearStartWarning();
         this.clearWorkflowWarnings();
         const backend = this.backend;
@@ -1482,6 +1526,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)));
     }
     hasNativeWork() {
@@ -1519,6 +1564,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 = {

package/dist/chat/index.d.ts

@@ -10,7 +10,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';
@@ -26,4 +26,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/dist/chat/index.js

@@ -9,7 +9,7 @@ export { ChatSession } from './chat-session.js';
 export { ChatStore } from './chat-store.js';
 export { suggestChatTitle } from './chat-title.js';
 export { ClaudeTitleReader } from './claude-title.js';
-export { spokenText, claudeProjectSlug, findClaudeSession } from './claude-transcript.js';
+export { claudeProjectSlug, findClaudeSession } from './claude-transcript.js';
 export { forkThreadOnce } from './codex-thread.js';
 export { ChatError } from './errors.js';
 export { listClaudeSessions, listCodexSessions, nodeSessionFs } from './external-sessions.js';
@@ -20,4 +20,4 @@ export { ChatThread } from './thread.js';
 export { ChatUiRefusal } from './ui-queries.js';
 export { visualFileName, VisualStore } from './visual-store.js';
 export { chatOpener } from './wake-chat.js';
-export { SkillIndex } from '../skills.js';
+export {} from '../skills.js';

package/dist/chat/thread.d.ts

@@ -17,6 +17,7 @@ export declare class ChatThread {
     upsert(item: ChatItem): ChatEvent;
     appendText(itemId: string, text: string): ChatEvent | null;
     patchInfo(patch: Partial<ChatInfo>): ChatEvent;
+    get held(): boolean;
     hold(key: string): boolean;
     release(key: string): boolean;
     reset(patch: Partial<ChatInfo>): ChatEvent;

package/dist/chat/thread.js

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

package/dist/chat/ui-queries.d.ts

@@ -1,6 +1,7 @@
 import type { z } from 'zod';
-import type { ChatUiLinkPayload, ChatUiLinkReading, ChatAssistantItem, ChatInfo, ChatUiChoicePayload, ChatUiQueryPayload, ChatUiQueryReading } from '@adecore/agent-contracts';
+import type { ChatUiLinkPayload, ChatUiLinkReading, ChatUiPlaceReading, ChatAssistantItem, ChatInfo, ChatUiChoicePayload, ChatUiQueryPayload, ChatUiQueryReading } from '@adecore/agent-contracts';
 import { type UiValue } from '@adecore/intelligent-ui';
+import { type UiPlaceQuery } from '@adecore/intelligent-ui/places';
 import { type UiLinkTarget } from '@adecore/intelligent-ui/links';
 import type { ChatSession } from './chat-session.ts';
 import { ChatError } from './errors.ts';
@@ -14,6 +15,7 @@ export interface ChatUiHost {
     capture(info: ChatInfo): Promise<unknown>;
     sources: Readonly<Record<string, ChatUiSource>>;
     link?(info: ChatInfo, access: unknown, target: UiLinkTarget): Promise<ChatUiLinkReading>;
+    place?(info: ChatInfo, query: UiPlaceQuery, signal: AbortSignal): Promise<Omit<ChatUiPlaceReading, 'address'>>;
 }
 declare class UiQueryError extends ChatError<string> {
     readonly reason: string;
@@ -26,6 +28,7 @@ export declare class ChatUiQueries {
     readonly schemas: Record<string, z.ZodType>;
     private readonly captures;
     private readonly freezing;
+    private readonly lives;
     private readonly cache;
     private readonly latest;
     private readonly newest;
@@ -36,6 +39,10 @@ export declare class ChatUiQueries {
     private readonly host;
     constructor(host: ChatUiHost);
     observe(session: ChatSession, item: ChatAssistantItem, final: boolean): void;
+    whenFrozen(session: ChatSession, itemId: string): Promise<void>;
+    private lookUpPlaces;
+    private lifeOf;
+    private placeReading;
     private access;
     private storedBlock;
     private stored;

package/dist/chat/ui-queries.js

@@ -1,5 +1,7 @@
 import { randomUUID } from 'node:crypto';
+import { ChatUiPlaceReadingSchema } from '@adecore/agent-contracts';
 import { copyUiValue, UI_HOST_LIMITS, UiBudget, uiMayReferenceHost } from '@adecore/intelligent-ui';
+import { uiPlaceQueries } from '@adecore/intelligent-ui/places';
 import { UiLinkResolutionSchema, uiLinkTargets } from '@adecore/intelligent-ui/links';
 import { uiQueryArguments, uiQueryFallback } from '@adecore/intelligent-ui/query';
 import { ChatError } from './errors.js';
@@ -26,12 +28,19 @@ 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 {
     schemas;
     captures = new Map();
-    freezing = new Set();
+    freezing = new Map();
+    // Ends with the chat, so a lookup that is under way stops when its chat does.
+    lives = new Map();
     cache = new Map();
     // The read id of the newest reading per cache key, which a remount or a second client is answered with.
     latest = new Map();
@@ -60,8 +69,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);
@@ -99,6 +107,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;
@@ -114,7 +126,8 @@ export class ChatUiQueries {
                     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) {
@@ -123,16 +136,131 @@ export class ChatUiQueries {
                         { state: 'failed', readAt: Date.now(), code: 'snapshot-too-large', reason: 'The frozen query values are too large.' }
                     ]));
                     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, itemId) {
+        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.
+     */
+    async lookUpPlaces(session, itemId, block, values) {
+        const places = Object.create(null);
+        const found = [];
+        if (!this.host.place) {
+            return { places, found, ended: false };
+        }
+        let queries;
+        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();
+        let timeouts = 0;
+        let next = 0;
+        const stillThere = () => {
+            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 () => {
+            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 };
+    }
+    lifeOf(chatId) {
+        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.
+     */
+    async placeReading(info, query, outer) {
+        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((_, 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()), 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. */
     access(session, item) {
@@ -349,6 +477,8 @@ export class ChatUiQueries {
         }
     }
     forget(chatId) {
+        this.lives.get(chatId)?.abort();
+        this.lives.delete(chatId);
         for (const [id, cached] of this.cache) {
             if (cached.chatId === chatId) {
                 this.evict(id);
@@ -387,7 +517,7 @@ export class ChatUiQueries {
         return reading;
     }
     failure(error) {
-        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/dist/chat/wake-chat.d.ts

@@ -11,6 +11,7 @@ export interface WakeChat {
         taskIds: string[];
         messageFrom?: string[];
     }): boolean;
+    relocating?(): boolean;
 }
 export interface ChatOpenerDeps {
     chats: Pick<ChatCore, 'get' | 'hasStored' | 'create' | 'save'>;

package/dist/chat/wake-chat.js

@@ -18,6 +18,7 @@ export function chatOpener(deps) {
         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/dist/index.d.ts

@@ -2,7 +2,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/dist/index.js

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

package/dist/lineage.d.ts

@@ -24,6 +24,7 @@ export declare class AgentLineageStore {
     load(): Promise<void>;
     put(record: Omit<Lineage, 'createdAt' | 'endedAt'>): Promise<void>;
     descendants(nodeId: string): string[];
+    rehome(nodeId: string, projectId: string): Promise<boolean>;
     projectOf(nodeId: string): string | null;
     endedAt(nodeId: string): number | null;
     markEnded(nodeIds: readonly string[]): Promise<void>;

package/dist/lineage.js

@@ -60,6 +60,14 @@ 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, projectId) {
+        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) {
         return this.opened.get(nodeId)?.projectId ?? null;