@agentshouse/mdruntime 0.1.0-c97456d63baba → 0.1.0-c9873d788cfb6

package/dist/conversation.js

@@ -1,15 +1,15 @@
+import { cursorOf, decodedCursor } from '@agentshouse/mdmodel';
 import { conversationChangeSet } from './change-set.js';
+import { FACTS, QUIET, } from './conversation-live.js';
+import { heldFacts } from './conversation-row.js';
 import { runtimeError } from './failure.js';
-import { declaredFile } from './file.js';
+import { refusedForSpace } from './durability.js';
 import { changeBatchIdentity, chatDraftRevision } from './identity.js';
 import { OFFLINE } from './outcome.js';
-const QUIET = {
-    turn: null,
-    questions: [],
-    process: null,
-    commands: [],
-    options: [],
-};
+import { jobsOf, runningLine } from './parts.js';
+import { openQuestion, questionAsked } from './questions.js';
+import { untilAnswered } from './recovery.js';
+import { capped, FROM_START, messageOrder, precedes } from './windows.js';
 export function unheldView(conversation) {
     return {
         conversation,
@@ -17,13 +17,20 @@ export function unheldView(conversation) {
         turn: null,
         questions: [],
         process: null,
+        processEnded: null,
         commands: [],
         options: [],
+        starting: null,
+        subagents: [],
+        link: null,
+        deliveryUnknown: [],
         chatDraft: null,
+        jobs: [],
     };
 }
 export const SESSION_STARTED = 'Session started';
 const NEW_CHAT = 'new:';
+export const HISTORY_CONVERSATIONS = 64;
 export function newChat(agent) {
     return `${NEW_CHAT}${agent}`;
 }
@@ -82,19 +89,25 @@ function appliedTurn(held, operation) {
         parts: held.parts.map((kept, at) => (at === operation.index ? changed : kept)),
     };
 }
-function ordered(left, right) {
-    if (left.position !== right.position)
-        return left.position < right.position ? -1 : 1;
-    if (left.identity !== right.identity)
-        return left.identity < right.identity ? -1 : 1;
-    return 0;
-}
 function windowOf(held, arriving, limit) {
     const byIdentity = new Map(held.map((message) => [message.identity, message]));
     for (const message of arriving)
         byIdentity.set(message.identity, message);
-    const next = [...byIdentity.values()].sort(ordered);
-    return limit === undefined ? next : next.slice(Math.max(0, next.length - limit));
+    const next = [...byIdentity.values()].sort(messageOrder);
+    const start = Math.max(0, next.length - limit);
+    return { messages: next.slice(start), dropped: start > 0 };
+}
+function frameOf(asked, messages, more, total) {
+    const oldest = messages[0];
+    const next = !more
+        ? undefined
+        : oldest === undefined
+            ? (asked.after ?? FROM_START)
+            : cursorOf([oldest.position, oldest.identity]);
+    return {
+        ...(next === undefined ? {} : { next }),
+        ...(total === null ? {} : { total }),
+    };
 }
 function newestOf(arriving, from) {
     return arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from);
@@ -165,18 +178,41 @@ function answered(result, field) {
     const value = answer[field];
     return typeof value === 'string' ? value : null;
 }
-function limitOf(options) {
-    const { limit } = options;
-    if (limit === undefined)
-        return undefined;
-    if (!Number.isInteger(limit) || limit < 0) {
+function beforeOf(after) {
+    if (after === undefined)
+        return null;
+    const decoded = typeof after === 'string' ? decodedCursor(after) : null;
+    if (decoded?.length === 0)
+        return null;
+    const [position, identity] = decoded ?? [];
+    if (decoded?.length !== 2 || typeof position !== 'string' || typeof identity !== 'string') {
+        throw runtimeError('invalid-after', `conversation after must be the next an earlier view returned, got ${String(after)}`);
+    }
+    return [position, identity];
+}
+function askedOf(options) {
+    const { limit, after, total } = options;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 0)) {
         throw runtimeError('invalid-limit', `conversation limit must be a non-negative integer, got ${String(limit)}`);
     }
-    return limit;
+    return { limit: capped(limit), after, before: beforeOf(after), total: total === true };
+}
+function phraseOf(text) {
+    if (text === undefined)
+        return null;
+    if (typeof text !== 'string' || text === '') {
+        throw runtimeError('invalid-text', 'a conversation is found by a phrase');
+    }
+    return text;
 }
-const EXPIRED = { kind: 'rejected', code: 'expired', fields: {}, retryable: false };
+const DURABLE_WRITE = {
+    kind: 'rejected',
+    code: 'durable-write',
+    fields: {},
+    retryable: true,
+};
 function unwritten(draft) {
-    return draft.text === '' && draft.files.length === 0;
+    return draft.text === '';
 }
 function pending(draft) {
     return {
@@ -191,743 +227,965 @@ function withSubmitted(draft, submitted) {
     const { submitted: _held, ...unsent } = draft;
     return submitted.length === 0 ? unsent : { ...unsent, submitted };
 }
+function prepended(draft, said) {
+    return { text: [said.text, draft.text].filter((one) => one !== '').join('\n') };
+}
 function returned(draft, submission, others) {
     return withSubmitted({
         conversation: draft.conversation,
-        text: [submission.text, draft.text].filter((one) => one !== '').join('\n'),
-        files: [...submission.files, ...draft.files],
+        ...prepended(draft, submission),
         revision: chatDraftRevision(),
     }, others);
 }
-export function createConversationStore(deps) {
-    const stored = new Set();
-    const reads = new Map();
-    const partials = new Set();
-    const drafts = new Map();
-    const sending = new Map();
-    const behind = new Set();
-    const gaps = new Map();
-    const lives = new Map();
-    const views = new Map();
-    const listing = new Map();
-    const creations = new Set();
-    const listWatchers = new Set();
-    let listKnown = false;
-    const agentWatchers = new Set();
-    let agentNames = new Map();
-    let retiredAgents = new Set();
-    let agentsRead = null;
-    let replicated = new Set();
-    let handedReplicated;
-    function liveOf(conversation) {
-        return lives.get(conversation) ?? QUIET;
-    }
-    function viewOf(conversation, held) {
-        const draft = drafts.get(conversation);
-        const facts = liveOf(conversation);
-        return {
-            conversation,
-            messages: held.map(({ identity, turn, text, message }) => ({
-                identity,
-                turn,
-                text,
-                message,
-            })),
-            turn: structuredClone(facts.turn),
-            questions: structuredClone(facts.questions),
-            process: facts.process === null ? null : { ...facts.process },
-            commands: structuredClone(facts.commands),
-            options: structuredClone(facts.options),
-            chatDraft: draft === undefined || unwritten(draft)
-                ? null
-                : { text: draft.text, files: [...draft.files], revision: draft.revision },
-        };
+function viewOf(alive, conversation, held, frame, draft, ended, marked) {
+    const facts = alive.liveOf(conversation);
+    return {
+        conversation,
+        messages: held.map(({ identity, turn, text, message }) => ({
+            identity,
+            turn,
+            text,
+            message,
+        })),
+        ...frame,
+        turn: structuredClone(facts.turn),
+        questions: structuredClone(facts.questions),
+        process: facts.process === null ? null : { ...facts.process },
+        processEnded: ended,
+        commands: structuredClone(facts.commands),
+        options: structuredClone(facts.options),
+        starting: facts.starting,
+        subagents: structuredClone(facts.subagents),
+        link: facts.link === null ? null : { ...facts.link },
+        deliveryUnknown: [...facts.deliveryUnknown],
+        chatDraft: draft === null || unwritten(draft) ? null : { text: draft.text, revision: draft.revision },
+        jobs: facts.process?.running === false
+            ? []
+            : jobsOf(marked.filter(({ at }) => ended === null || at > ended), facts.turn),
+    };
+}
+function emit(alive, conversation) {
+    if (alive.deps.closed())
+        return;
+    for (const view of alive.views()) {
+        const { window, draft, ended, marked } = view.held.now();
+        if (view.conversation !== conversation || window === null)
+            continue;
+        const ready = view.ready();
+        if (ready.length === 0)
+            continue;
+        const value = viewOf(alive, conversation, window, sharedFrame(view, window), draft, ended, marked);
+        for (const watcher of ready)
+            watcher.notify(value);
     }
-    function emit(conversation) {
-        if (deps.closed())
-            return;
-        for (const view of views.values()) {
-            if (view.conversation !== conversation || view.window === null)
-                continue;
-            const ready = [...view.watchers].filter((watcher) => watcher.ready);
-            if (ready.length === 0)
-                continue;
-            const value = viewOf(conversation, view.window);
-            for (const watcher of ready)
-                watcher.notify(value);
+}
+function sharedFrame(view, window) {
+    const { more, total } = view.held.now();
+    return frameOf(view.asked, window, more, total);
+}
+async function slide(alive, local, conversation, arriving) {
+    let count;
+    let marked;
+    for (const view of alive.views()) {
+        const { held } = view;
+        const { window, total } = held.now();
+        if (view.conversation !== conversation || window === null)
+            continue;
+        if (arriving === null) {
+            held.set({ window: [], marked: [], more: false, total: total === null ? null : 0 });
+            continue;
         }
-    }
-    function slide(conversation, arriving) {
-        for (const view of views.values()) {
-            if (view.conversation !== conversation || view.window === null)
-                continue;
-            view.window = arriving === null ? [] : windowOf(view.window, arriving, view.limit);
+        const joining = arriving.filter((message) => precedes(message, view.asked.before));
+        const next = windowOf(window, joining, view.asked.limit);
+        held.set({ window: next.messages, more: held.now().more || next.dropped });
+        if (arriving.length > 0) {
+            marked ??= await local.jobMarkers(conversation);
+            held.set({ marked });
+        }
+        if (held.now().total !== null && arriving.length > 0) {
+            count ??= await local.messageCount(conversation);
+            held.set({ total: count });
         }
     }
-    function changesOf(conversation, arriving) {
-        return arriving.map(({ identity, text }) => ({ conversation, identity, text }));
-    }
-    function stateOf(conversation) {
-        const facts = liveOf(conversation);
-        if (facts.questions.length > 0)
-            return 'asking';
-        return facts.turn === null ? 'idle' : 'working';
-    }
-    function entries() {
-        return [...listing.values()].map((entry) => ({
-            conversation: entry.conversation,
-            agent: { identity: entry.agent, name: agentNames.get(entry.agent) ?? null },
-            name: entry.name,
-            created: entry.created,
-            finished: entry.finished,
-            outcome: entry.outcome,
-            state: stateOf(entry.conversation),
-            started: lives.get(entry.conversation)?.turn?.started ?? null,
-        }));
-    }
-    function emitList() {
-        if (deps.closed() || listWatchers.size === 0)
-            return;
-        const value = entries();
-        for (const watcher of listWatchers)
-            watcher(value);
-    }
-    function agents() {
-        return [...agentNames]
-            .filter(([identity]) => !retiredAgents.has(identity))
-            .map(([identity, name]) => ({ identity, name }))
-            .sort((left, right) => left.name === right.name
-            ? left.identity.localeCompare(right.identity)
-            : left.name.localeCompare(right.name));
-    }
-    function emitAgents() {
-        if (deps.closed() || agentWatchers.size === 0)
+}
+function stateOf(alive, conversation) {
+    const facts = alive.liveOf(conversation);
+    if (facts.questions.length > 0)
+        return 'asking';
+    return facts.turn === null ? 'idle' : 'working';
+}
+function rowOf(alive, conversation) {
+    const { turn, questions } = alive.liveOf(conversation);
+    return {
+        state: stateOf(alive, conversation),
+        started: turn?.started ?? null,
+        line: turn === null ? null : runningLine(turn.parts),
+        question: openQuestion(questions),
+        asked: questionAsked(questions),
+    };
+}
+async function entries(alive) {
+    const list = await heldList(alive);
+    if (list === null)
+        return null;
+    const held = list.length === 0
+        ? []
+        : await alive.deps.durably((local) => local.conversationRows(list.map(({ conversation }) => conversation)));
+    const rows = new Map(held.map((one) => [one.conversation, one]));
+    return list.map((entry) => ({
+        conversation: entry.conversation,
+        agent: { identity: entry.agent, name: entry.agentName, retired: entry.agentRetired },
+        name: entry.name,
+        created: entry.created,
+        finished: entry.finished,
+        outcome: entry.outcome,
+        waiting: entry.waiting,
+        ...rowOf(alive, entry.conversation),
+        ...heldFacts(rows.get(entry.conversation), entry),
+    }));
+}
+async function heldList(alive) {
+    const stored = (await (await alive.deps.local()).facts()).conversationList;
+    if (stored !== null)
+        return stored;
+    return !alive.known() && alive.deps.stream() !== undefined && alive.deps.online() ? null : [];
+}
+async function endedIn(alive, conversation) {
+    const list = await heldList(alive);
+    return list?.find((entry) => entry.conversation === conversation)?.processEnded ?? null;
+}
+function listChanged(alive, change) {
+    void alive.deps
+        .durably(async (local) => {
+        const { conversationList, conversationCursor } = await local.facts();
+        const kept = change.replacing ? [] : (conversationList ?? []);
+        const held = new Map(kept.map((entry) => [entry.conversation, entry]));
+        for (const entry of change.set) {
+            held.set(entry.conversation, { ...entry });
+            alive.created(entry.conversation);
+        }
+        if (change.gone !== null)
+            held.delete(change.gone);
+        const list = [...held.values()];
+        if (JSON.stringify(list) !== JSON.stringify(conversationList)) {
+            await local.fact('conversationList', list);
+        }
+        if (change.cursor !== undefined) {
+            if (change.cursor !== conversationCursor) {
+                await local.fact('conversationCursor', change.cursor);
+            }
+            alive.deps.stream()?.hold(change.cursor);
+        }
+        return list;
+    })
+        .catch(async () => (await (await alive.deps.local()).facts()).conversationList ?? [])
+        .then((list) => {
+        if (alive.deps.closed() || change.paged === true)
             return;
-        const value = agents();
-        for (const watcher of agentWatchers)
-            watcher(value);
-    }
-    function setLive(conversation, next) {
-        const before = stateOf(conversation);
-        const began = lives.get(conversation)?.turn?.started;
-        if (next === null)
-            lives.delete(conversation);
-        else
-            lives.set(conversation, next);
-        if (!listing.has(conversation))
+        endedAnew(alive, list);
+        if (change.cursor !== undefined) {
+            alive.held.set({ listKnown: true });
+            settleBehind(alive, list);
+            openingEnded(alive);
+            alive.deps.settled();
+        }
+        emitList(alive);
+        if (!alive.known())
             return;
-        if (stateOf(conversation) !== before || next?.turn?.started !== began)
-            emitList();
+        retiredDrafts(alive, list);
+        const { replicated } = alive.held.now();
+        if (change.cursor === undefined &&
+            (list.length !== replicated.size ||
+                list.some(({ conversation }) => !replicated.has(conversation)))) {
+            alive.deps.again();
+        }
+    }, () => { });
+}
+function endedAnew(alive, list) {
+    const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+    for (const view of alive.views()) {
+        const ended = entries.get(view.conversation)?.processEnded ?? null;
+        const held = view.held.now();
+        if (held.window === null || ended === held.ended)
+            continue;
+        view.held.set({ ended });
+        emit(alive, view.conversation);
     }
-    async function readAgents() {
-        const declaration = deps.agents();
-        if (declaration === undefined)
-            return;
-        const held = await deps.documents(declaration);
-        if ('pending' in held)
+}
+function shownList(alive, work) {
+    const reading = heldList(alive);
+    alive.inOrder(async () => {
+        const list = await reading.catch(() => null);
+        if (list === null || alive.deps.closed())
             return;
-        const { documents } = held;
-        const names = new Map();
-        const retired = new Set();
-        for (const document of documents) {
-            if (document.type !== declaration.type)
-                continue;
-            const identity = document.fields?.[declaration.identity];
-            const name = document.fields?.[declaration.name];
-            if (typeof identity !== 'string' || typeof name !== 'string')
+        work(list);
+    });
+}
+async function told(alive) {
+    try {
+        while (alive.held.now().listOwed && !alive.deps.closed()) {
+            alive.held.set({ listOwed: false });
+            const value = await untilAnswered(() => entries(alive), alive.closing);
+            if (alive.deps.closed())
+                return;
+            if (value === null)
                 continue;
-            names.set(identity, name);
-            const ended = declaration.retired === undefined ? null : document.fields?.[declaration.retired];
-            if (ended !== undefined && ended !== null)
-                retired.add(identity);
+            alive.listeners.tell(value);
+            alive.listeners.welcome(value);
         }
-        const named = JSON.stringify([...names]) !== JSON.stringify([...agentNames]);
-        if (!named && JSON.stringify([...retired]) === JSON.stringify([...retiredAgents]))
-            return;
-        agentNames = names;
-        retiredAgents = retired;
-        if (named)
-            emitList();
-        emitAgents();
-        const ended = [...drafts.keys()].filter(retiredChat);
-        if (ended.length > 0)
-            await remove(ended);
-    }
-    function retiredChat(conversation) {
-        return (conversation.startsWith(NEW_CHAT) && retiredAgents.has(conversation.slice(NEW_CHAT.length)));
-    }
-    function agentsReady() {
-        agentsRead ??= readAgents().catch(() => {
-            agentsRead = null;
-        });
-        return agentsRead;
-    }
-    function live(conversation, change) {
-        setLive(conversation, { ...liveOf(conversation), ...change });
-        emit(conversation);
-    }
-    function relayed(conversation, turn, operation) {
-        const held = liveOf(conversation).turn;
-        const next = held?.turn === turn ? appliedTurn(held, operation) : startedTurn(turn, operation);
-        if (next !== null)
-            live(conversation, { turn: next });
-    }
-    function sealTurns(conversation, turns) {
-        const held = lives.get(conversation);
-        if (held?.turn == null || !turns.has(held.turn.turn))
-            return false;
-        setLive(conversation, { ...held, turn: null });
-        return true;
-    }
-    function handReplicated() {
-        const stream = deps.stream();
-        if (stream === undefined)
-            return;
-        const held = [...replicated].sort();
-        const named = JSON.stringify(held);
-        if (named === handedReplicated)
-            return;
-        handedReplicated = named;
-        stream.replicate(held);
-    }
-    async function remove(leaving) {
-        await deps.durably(async (local) => {
-            const removed = [];
-            for (const conversation of leaving) {
-                for (const identity of await local.messageIdentities(conversation)) {
-                    removed.push({ conversation, identity, text: null });
-                }
-            }
-            await local.dropConversations(leaving);
-            const changed = [];
-            for (const conversation of leaving) {
-                if (stored.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
-                    changed.push(conversation);
-                }
-                stored.delete(conversation);
-                reads.delete(conversation);
-                partials.delete(conversation);
-                drafts.delete(conversation);
-                behind.delete(conversation);
-                setLive(conversation, null);
-                slide(conversation, null);
-            }
-            if (changed.length > 0)
-                deps.publish(conversationChangeSet(removed, changed));
-        });
     }
-    function gap(conversation) {
-        gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
-        behind.add(conversation);
+    finally {
+        alive.held.set({ listTelling: false });
     }
-    function keep(conversation, message) {
-        return deps.durably(async (local) => {
-            if (!replicated.has(conversation))
-                return;
-            const read = reads.get(conversation);
-            const advances = read !== undefined &&
-                !behind.has(conversation) &&
-                (read === null || message.position > read);
-            await sealed(local, conversation, new Set([message.turn]));
-            await local.keepMessages({
-                conversation,
-                messages: [message],
-                ...(advances ? { read: { at: message.position, partial: false } } : {}),
-            });
-            stored.add(conversation);
-            if (advances)
-                reads.set(conversation, message.position);
-            sealTurns(conversation, new Set([message.turn]));
-            slide(conversation, [message]);
-            deps.publish(conversationChangeSet(changesOf(conversation, [message]), [conversation]));
-        });
+}
+function tellList(alive) {
+    const { listeners } = alive;
+    if (alive.deps.closed() || (!listeners.told() && !listeners.waiting()))
+        return;
+    alive.held.set({ listOwed: true });
+    if (alive.held.now().listTelling)
+        return;
+    alive.held.set({ listTelling: true });
+    void told(alive).catch(() => { });
+}
+function tellSoon(alive) {
+    alive.rowSoon(() => tellList(alive));
+}
+function emitList(alive) {
+    if (alive.deps.closed())
+        return;
+    tellList(alive);
+    emitAgents(alive);
+    conversationsLearned(alive);
+}
+export function conversationsLearned(alive) {
+    if (alive.deps.closed())
+        return;
+    if (alive.listeners.waiting())
+        tellList(alive);
+    if (!alive.agentListeners.waiting())
+        return;
+    shownList(alive, (list) => alive.agentListeners.welcome(agents(alive, list)));
+}
+function agents(alive, list) {
+    const named = new Map();
+    for (const agent of alive.held.now().listedAgents ?? [])
+        named.set(agent.agent, agent);
+    for (const entry of list) {
+        named.set(entry.agent, { name: entry.agentName, retired: entry.agentRetired });
     }
-    async function readHistories(conversations) {
-        const generations = new Map(conversations.map((one) => [one, gaps.get(one) ?? 0]));
-        let asking = conversations.map((conversation) => ({
-            conversation,
-            after: reads.get(conversation) ?? undefined,
-        }));
-        while (asking.length > 0) {
-            const result = await deps.call('conversation.history', {
-                conversations: asking.map(({ conversation, after }) => ({
-                    conversation,
-                    ...(after === undefined ? {} : { after }),
-                })),
-            });
-            const pages = historyPages(result);
-            if (pages === null)
-                return result;
-            const asked = new Map(asking.map(({ conversation, after }) => [conversation, after]));
-            const following = [];
-            for (const page of pages) {
-                if (!asked.has(page.conversation))
-                    continue;
-                await keepPage(page.conversation, page.messages, asked.get(page.conversation) ?? null, page.next, generations.get(page.conversation) ?? 0);
-                if (page.next !== undefined) {
-                    following.push({ conversation: page.conversation, after: page.next });
-                }
-            }
-            asking = following;
+    return [...named]
+        .filter(([, agent]) => !agent.retired)
+        .map(([identity, agent]) => ({ identity, name: agent.name }))
+        .sort((left, right) => left.name === right.name
+        ? left.identity.localeCompare(right.identity)
+        : left.name.localeCompare(right.name));
+}
+function readAgents(alive) {
+    const stream = alive.deps.stream();
+    if (stream?.agents === undefined || !alive.deps.online() || alive.held.now().agentsReading)
+        return;
+    const { agents: read } = stream;
+    const { agentListeners } = alive;
+    alive.held.set({ agentsReading: true });
+    void alive.deps.recovery
+        .attempt('agents', async () => {
+        if (!alive.deps.online() || (!agentListeners.waiting() && !agentListeners.told())) {
+            return 'done';
         }
-        return null;
-    }
-    function keepPage(conversation, arriving, from, next, generation) {
-        return deps.durably(async (local) => {
-            if (!replicated.has(conversation))
-                return;
-            const whole = next === undefined;
-            const cursor = next ?? newestOf(arriving, from);
-            const partial = !whole && (partials.has(conversation) || !reads.has(conversation));
-            const sealing = await sealed(local, conversation, new Set(arriving.map((message) => message.turn)));
-            await local.keepMessages({ conversation, messages: arriving, read: { at: cursor, partial } });
-            stored.add(conversation);
-            reads.set(conversation, cursor);
-            if (partial)
-                partials.add(conversation);
-            else
-                partials.delete(conversation);
-            sealTurns(conversation, new Set(arriving.map((message) => message.turn)));
-            if (whole && (gaps.get(conversation) ?? 0) === generation)
-                behind.delete(conversation);
-            slide(conversation, arriving);
-            if (arriving.length > 0 || sealing || whole) {
-                deps.publish(conversationChangeSet(changesOf(conversation, arriving), [conversation]));
-            }
+        const listed = await read();
+        if (listed === null)
+            return 'done';
+        alive.held.set({ listedAgents: listed });
+        emitAgents(alive);
+        return 'done';
+    })
+        .finally(() => {
+        alive.held.set({ agentsReading: false });
+    });
+}
+function emitAgents(alive) {
+    if (alive.deps.closed() || !alive.agentListeners.told())
+        return;
+    shownList(alive, (list) => {
+        const value = agents(alive, list);
+        const shown = JSON.stringify(value);
+        if (shown === alive.held.now().agentsShown)
+            return;
+        alive.held.set({ agentsShown: shown });
+        alive.agentListeners.tell(value);
+    });
+}
+function setLive(alive, conversation, next) {
+    const before = rowOf(alive, conversation);
+    alive.holdLive(conversation, next);
+    const after = rowOf(alive, conversation);
+    if (after.state !== before.state || after.started !== before.started)
+        emitList(alive);
+    else if (after.line !== before.line ||
+        after.question !== before.question ||
+        after.asked !== before.asked)
+        tellSoon(alive);
+}
+function retiredChat(conversation, list) {
+    if (!conversation.startsWith(NEW_CHAT))
+        return false;
+    const agent = conversation.slice(NEW_CHAT.length);
+    return list.some((entry) => entry.agent === agent && entry.agentRetired);
+}
+function live(alive, conversation, change) {
+    alive.factsHeard(conversation, FACTS.filter((one) => one in change));
+    setLive(alive, conversation, { ...alive.liveOf(conversation), ...change });
+    emit(alive, conversation);
+}
+function openingEnded(alive) {
+    for (const [conversation, facts] of alive.factsTaken()) {
+        const held = alive.liveHeld(conversation);
+        if (held === undefined || facts.size === 0)
+            continue;
+        setLive(alive, conversation, {
+            turn: held.turn,
+            questions: facts.has('questions') ? QUIET.questions : held.questions,
+            process: facts.has('process') ? QUIET.process : held.process,
+            commands: facts.has('commands') ? QUIET.commands : held.commands,
+            options: facts.has('options') ? QUIET.options : held.options,
+            starting: facts.has('starting') ? QUIET.starting : held.starting,
+            subagents: facts.has('subagents') ? QUIET.subagents : held.subagents,
+            link: facts.has('link') ? QUIET.link : held.link,
+            deliveryUnknown: facts.has('deliveryUnknown') ? QUIET.deliveryUnknown : held.deliveryUnknown,
         });
+        emit(alive, conversation);
     }
-    function heard(event) {
-        const { conversation } = event;
-        if (event.kind === 'gap') {
-            if (replicated.has(conversation))
-                gap(conversation);
-            const held = lives.get(conversation);
-            if (held === undefined)
-                return;
-            setLive(conversation, { ...QUIET, turn: held.turn });
-            emit(conversation);
-            return;
+}
+function relayed(alive, conversation, turn, operation) {
+    const held = alive.liveOf(conversation).turn;
+    const next = held?.turn === turn ? appliedTurn(held, operation) : startedTurn(turn, operation);
+    if (next !== null)
+        live(alive, conversation, { turn: next });
+}
+function sealTurns(alive, conversation, turns) {
+    const held = alive.liveHeld(conversation);
+    if (held?.turn == null || !turns.has(held.turn.turn))
+        return false;
+    setLive(alive, conversation, { ...held, turn: null });
+    return true;
+}
+function handReplicated(alive) {
+    const stream = alive.deps.stream();
+    if (stream === undefined)
+        return;
+    const held = [...alive.held.now().replicated].sort();
+    const named = JSON.stringify(held);
+    if (named === alive.held.now().handedReplicated)
+        return;
+    alive.held.set({ handedReplicated: named });
+    stream.replicate(held);
+}
+async function remove(alive, leaving) {
+    await alive.deps.durably(async (local) => {
+        const kept = new Set([
+            ...(await local.conversations(leaving)).map(({ conversation }) => conversation),
+            ...(await local.chatDrafts())
+                .filter(({ conversation }) => leaving.includes(conversation))
+                .map(({ conversation }) => conversation),
+        ]);
+        await local.dropConversations(leaving);
+        const changed = [];
+        for (const conversation of leaving) {
+            if (kept.has(conversation) || alive.liveHeld(conversation) !== undefined) {
+                changed.push(conversation);
+            }
+            shownDraft(alive, conversation, null);
+            alive.forget(conversation);
+            setLive(alive, conversation, null);
+            await slide(alive, local, conversation, null);
         }
-        if (event.kind === 'turn') {
-            relayed(conversation, event.turn, event.operation);
-            return;
+        if (changed.length > 0)
+            alive.deps.publish(conversationChangeSet(changed));
+    });
+}
+function newestOfListed(alive, entry) {
+    if (entry === undefined)
+        return undefined;
+    const heard = alive.newestHeard(entry.conversation);
+    if (heard === undefined)
+        return entry.newest;
+    return entry.newest === null || heard > entry.newest ? heard : entry.newest;
+}
+function missed(alive, conversation, held, entry) {
+    const read = held?.read;
+    const newest = newestOfListed(alive, entry);
+    return (read === undefined ||
+        newest === undefined ||
+        held?.partial === true ||
+        (newest !== null && (read === null || newest > read)));
+}
+async function readsOf(local, conversations) {
+    return new Map((await local.conversations(conversations)).map((held) => [held.conversation, held]));
+}
+function retiredDrafts(alive, list) {
+    if (!list.some((entry) => entry.agentRetired))
+        return;
+    void alive.deps
+        .local()
+        .then((local) => local.chatDrafts())
+        .then((held) => {
+        if (!alive.deps.closed() &&
+            held.some(({ conversation }) => retiredChat(conversation, list))) {
+            alive.deps.again();
         }
-        if (event.kind === 'questions') {
-            live(conversation, { questions: structuredClone(event.questions) });
-            return;
+    }, () => { });
+}
+function settleBehind(alive, list) {
+    void alive.deps
+        .durably(async (local) => {
+        const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+        const named = [...alive.held.now().replicated].filter((conversation) => entries.has(conversation));
+        const held = await readsOf(local, named);
+        let owed = false;
+        for (const conversation of named) {
+            if (!missed(alive, conversation, held.get(conversation), entries.get(conversation))) {
+                alive.caughtUpTo(conversation);
+            }
+            else if (!alive.behind(conversation)) {
+                alive.gapOpened(conversation);
+                owed = true;
+            }
         }
-        if (event.kind === 'process') {
-            live(conversation, { process: { running: event.running } });
+        return owed;
+    })
+        .then((owed) => {
+        if (alive.deps.closed())
             return;
-        }
-        if (event.kind === 'commands') {
-            live(conversation, { commands: structuredClone(event.commands) });
+        alive.deps.settled();
+        if (owed)
+            alive.deps.again();
+    }, () => { });
+}
+function keep(alive, conversation, message) {
+    return alive.deps.durably(async (local) => {
+        if (!alive.held.now().replicated.has(conversation))
             return;
+        const read = (await readsOf(local, [conversation])).get(conversation)?.read;
+        const advances = read !== undefined &&
+            !alive.behind(conversation) &&
+            (read === null || message.position > read);
+        await sealed(alive, local, conversation, new Set([message.turn]));
+        await local.keepMessages({
+            conversation,
+            messages: [message],
+            ...(advances ? { read: { at: message.position, partial: false } } : {}),
+        });
+        sealTurns(alive, conversation, new Set([message.turn]));
+        await slide(alive, local, conversation, [message]);
+        alive.deps.publish(conversationChangeSet([conversation]));
+        tellList(alive);
+    });
+}
+async function readHistories(alive, conversations, ended) {
+    const generations = new Map(conversations.map((one) => [one, alive.generation(one)]));
+    const held = await readsOf(await alive.deps.local(), conversations);
+    let waiting = conversations.map((conversation) => ({
+        conversation,
+        after: held.get(conversation)?.read ?? undefined,
+    }));
+    while (waiting.length > 0) {
+        const asking = waiting.slice(0, HISTORY_CONVERSATIONS);
+        const result = await alive.deps.history({
+            conversations: asking.map(({ conversation, after }) => ({
+                conversation,
+                ...(after === undefined ? {} : { after }),
+            })),
+        });
+        const pages = historyPages(result);
+        if (pages === null)
+            return result;
+        const asked = new Map(asking.map(({ conversation, after }) => [conversation, after]));
+        const following = [];
+        for (const page of pages) {
+            if (!asked.has(page.conversation))
+                continue;
+            await keepPage(alive, page.conversation, page.messages, asked.get(page.conversation) ?? null, page.next, generations.get(page.conversation) ?? 0);
+            if (page.next !== undefined) {
+                following.push({ conversation: page.conversation, after: page.next });
+            }
         }
-        if (event.kind === 'options') {
-            live(conversation, { options: structuredClone(event.options) });
-            return;
+        for (const { conversation } of asking) {
+            if (!following.some((next) => next.conversation === conversation))
+                ended(conversation);
         }
-        const arriving = acceptedMessage(event.message);
-        if (arriving === null)
-            return;
-        if (replicated.has(conversation)) {
-            void keep(conversation, arriving).catch(() => { });
+        waiting = [...waiting.slice(HISTORY_CONVERSATIONS), ...following];
+    }
+    return null;
+}
+function caughtUp(alive, conversations) {
+    const ends = new Map();
+    for (const conversation of conversations) {
+        alive.catchingUntil(conversation, new Promise((end) => ends.set(conversation, end)));
+    }
+    const ended = (conversation) => ends.get(conversation)?.();
+    const read = readHistories(alive, conversations, ended);
+    const endAll = () => {
+        for (const conversation of conversations)
+            ended(conversation);
+    };
+    read.then(endAll, endAll);
+    return read;
+}
+function keepPage(alive, conversation, arriving, from, next, generation) {
+    return alive.deps.durably(async (local) => {
+        if (!alive.held.now().replicated.has(conversation))
             return;
+        const whole = next === undefined;
+        const cursor = next ?? newestOf(arriving, from);
+        const held = (await readsOf(local, [conversation])).get(conversation);
+        const partial = !whole && (held?.partial === true || held?.read === undefined);
+        const sealing = await sealed(alive, local, conversation, new Set(arriving.map((message) => message.turn)));
+        await local.keepMessages({ conversation, messages: arriving, read: { at: cursor, partial } });
+        sealTurns(alive, conversation, new Set(arriving.map((message) => message.turn)));
+        if (whole && alive.generation(conversation) === generation)
+            alive.caughtUpTo(conversation);
+        await slide(alive, local, conversation, arriving);
+        if (arriving.length > 0 || sealing || whole) {
+            alive.deps.publish(conversationChangeSet([conversation]));
         }
-        if (sealTurns(conversation, new Set([arriving.turn])))
-            emit(conversation);
+        if (arriving.length > 0)
+            tellSoon(alive);
+    });
+}
+function heard(alive, event) {
+    const { conversation } = event;
+    if (event.kind === 'gap') {
+        if (alive.held.now().replicated.has(conversation))
+            alive.gapOpened(conversation);
+        if (alive.liveHeld(conversation) !== undefined)
+            alive.factsOwed(conversation);
+        return;
     }
-    async function kept(local, conversation, following) {
-        if (following === null || empty(following)) {
-            await local.dropChatDraft(conversation);
-            drafts.delete(conversation);
-        }
-        else {
-            await local.keepChatDrafts([following]);
-            drafts.set(conversation, following);
-        }
+    if (event.kind === 'turn') {
+        relayed(alive, conversation, event.turn, event.operation);
+        return;
     }
-    async function sealed(local, conversation, turns) {
-        const held = drafts.get(conversation);
-        const submitted = held?.submitted ?? [];
-        const left = submitted.filter((one) => one.turn === null || !turns.has(one.turn));
-        if (held === undefined || left.length === submitted.length)
-            return false;
-        await kept(local, conversation, withSubmitted(held, left));
-        return true;
-    }
-    function moved(agent, operation, to) {
-        const from = newChat(agent);
-        return deps.durably(async (local) => {
-            const held = drafts.get(from);
-            const earlier = (held?.moves ?? []).filter((one) => !deps.expired(one));
-            if (earlier.includes(operation))
-                return;
-            const blank = {
-                conversation: from,
-                text: '',
-                files: [],
-                revision: chatDraftRevision(),
-            };
-            const { moves: _answered, ...unsent } = held ?? blank;
-            const taken = drafts.has(to) || empty(unsent) ? [] : [{ ...unsent, conversation: to }];
-            const left = { ...(taken.length === 0 ? unsent : blank), moves: [...earlier, operation] };
-            await local.keepChatDrafts([left, ...taken]);
-            drafts.set(from, left);
-            for (const one of taken)
-                drafts.set(to, one);
-            deps.publish(conversationChangeSet([], [from, to]));
-        });
+    if (event.kind === 'questions') {
+        live(alive, conversation, { questions: structuredClone(event.questions) });
+        return;
     }
-    function withDraft(conversation, next) {
-        return deps.durably(async (local) => {
-            const following = await next(drafts.get(conversation), local);
-            if (following === undefined)
-                return;
-            await kept(local, conversation, following);
-            deps.publish(conversationChangeSet([], [conversation]));
-        });
+    if (event.kind === 'process') {
+        live(alive, conversation, { process: { running: event.running } });
+        return;
     }
-    async function submitted(conversation, operation, draft) {
-        let submission;
-        let earlier = false;
-        await withDraft(conversation, (current) => {
-            submission = current?.submitted?.find((one) => one.operation === operation);
-            earlier = submission !== undefined;
-            if (submission !== undefined)
-                return undefined;
-            const said = draft ?? current;
-            submission = {
-                operation,
-                text: said?.text ?? '',
-                files: [...(said?.files ?? [])],
-                turn: null,
-            };
-            return {
-                conversation,
-                ...(draft === undefined || current === undefined
-                    ? { text: '', files: [], revision: chatDraftRevision() }
-                    : { text: current.text, files: current.files, revision: current.revision }),
-                submitted: [...(current?.submitted ?? []), submission],
-            };
-        });
-        return { submission: submission, earlier };
+    if (event.kind === 'commands') {
+        live(alive, conversation, { commands: structuredClone(event.commands) });
+        return;
     }
-    function forgotten(conversation, submission) {
-        return withDraft(conversation, (current) => {
-            const held = current?.submitted ?? [];
-            if (current === undefined || !held.includes(submission))
-                return undefined;
-            return withSubmitted(current, held.filter((one) => one !== submission));
+    if (event.kind === 'options') {
+        live(alive, conversation, { options: structuredClone(event.options) });
+        return;
+    }
+    if (event.kind === 'starting') {
+        live(alive, conversation, { starting: event.step });
+        return;
+    }
+    if (event.kind === 'subagents') {
+        live(alive, conversation, { subagents: structuredClone(event.subagents) });
+        return;
+    }
+    if (event.kind === 'link') {
+        live(alive, conversation, { link: { connected: event.connected } });
+        return;
+    }
+    if (event.kind === 'deliveries') {
+        live(alive, conversation, { deliveryUnknown: [...event.unknown] });
+        return;
+    }
+    const arriving = acceptedMessage(event.message);
+    if (arriving === null)
+        return;
+    alive.heardAt(conversation, arriving.position);
+    if (alive.held.now().replicated.has(conversation)) {
+        if (alive.deps.full()) {
+            alive.gapOpened(conversation);
+            return;
+        }
+        void keep(alive, conversation, arriving).catch((error) => {
+            if (refusedForSpace(error))
+                alive.gapOpened(conversation);
         });
+        return;
     }
-    async function dispatched(conversation, submission) {
-        const dispatch = {};
-        sending.set(submission.operation, dispatch);
-        try {
-            const files = await Promise.all(submission.files.map(async (file) => ({ ...(await declaredFile(file)), blob: file.blob })));
-            const result = await invoke('conversation.send', conversation, {
-                text: submission.text,
-                files,
-                operation_id: submission.operation,
-            });
-            if (result.kind === 'revoked-authorization')
-                return result;
-            if (result.kind !== 'action' && result.retryable) {
-                deps.unanswered();
-                return result;
-            }
-            const turn = answered(result, 'turn');
-            await withDraft(conversation, async (current, local) => {
-                const held = current?.submitted?.find((one) => one.operation === submission.operation);
-                if (current === undefined || held === undefined || held.turn !== null)
-                    return undefined;
-                const others = current.submitted.filter((one) => one !== held);
-                if (result.kind !== 'action')
-                    return returned(current, held, others);
-                const arrived = turn !== null && (await local.turnArrived(conversation, turn));
-                return withSubmitted(current, turn === null || arrived
-                    ? others
-                    : current.submitted.map((one) => (one === held ? { ...held, turn } : one)));
-            });
+    if (sealTurns(alive, conversation, new Set([arriving.turn])))
+        emit(alive, conversation);
+}
+async function kept(alive, local, conversation, following) {
+    const shown = following === null || empty(following) ? null : following;
+    if (shown === null)
+        await local.dropChatDraft(conversation);
+    else
+        await local.keepChatDrafts([shown]);
+    shownDraft(alive, conversation, shown);
+}
+function shownDraft(alive, conversation, draft) {
+    for (const view of alive.views()) {
+        if (view.conversation === conversation)
+            view.held.set({ draft });
+    }
+}
+async function draftAt(local, conversation) {
+    return (await local.chatDraft(conversation)) ?? undefined;
+}
+async function sealed(alive, local, conversation, turns) {
+    const held = await draftAt(local, conversation);
+    const submitted = held?.submitted ?? [];
+    const left = submitted.filter((one) => one.turn === null || !turns.has(one.turn));
+    if (held === undefined || left.length === submitted.length)
+        return false;
+    await kept(alive, local, conversation, withSubmitted(held, left));
+    return true;
+}
+function moved(alive, agent, operation, to) {
+    const from = newChat(agent);
+    return alive.deps.durably(async (local) => {
+        const held = await draftAt(local, from);
+        const earlier = held?.moves ?? [];
+        if (earlier.includes(operation))
+            return;
+        const blank = {
+            conversation: from,
+            text: '',
+            revision: chatDraftRevision(),
+        };
+        const { moves: _answered, ...unsent } = held ?? blank;
+        const taken = (await draftAt(local, to)) !== undefined || empty(unsent)
+            ? []
+            : [{ ...unsent, conversation: to }];
+        const left = { ...(taken.length === 0 ? unsent : blank), moves: [...earlier, operation] };
+        await local.keepChatDrafts([left, ...taken]);
+        shownDraft(alive, from, left);
+        for (const one of taken)
+            shownDraft(alive, to, one);
+        alive.deps.publish(conversationChangeSet([from, to]));
+    });
+}
+function withDraft(alive, conversation, next) {
+    return alive.deps.durably(async (local) => {
+        const following = await next(await draftAt(local, conversation), local);
+        if (following === undefined)
+            return;
+        await kept(alive, local, conversation, following);
+        alive.deps.publish(conversationChangeSet([conversation]));
+    });
+}
+async function submitted(alive, conversation, operation, draft) {
+    let submission;
+    await withDraft(alive, conversation, (current) => {
+        submission = current?.submitted?.find((one) => one.operation === operation);
+        if (submission !== undefined)
+            return undefined;
+        const said = draft ?? current;
+        submission = { operation, text: said?.text ?? '', turn: null };
+        return {
+            conversation,
+            ...(draft === undefined || current === undefined
+                ? { text: '', revision: chatDraftRevision() }
+                : { text: current.text, revision: current.revision }),
+            submitted: [...(current?.submitted ?? []), submission],
+        };
+    });
+    return submission;
+}
+async function dispatched(alive, conversation, submission) {
+    const dispatch = alive.sendingBegan(submission.operation);
+    try {
+        const result = await invoke(alive, 'conversations/send', conversation, {
+            operation_id: submission.operation,
+            text: submission.text,
+        });
+        dispatch.set({ answered: result.kind !== 'transport-uncertainty' });
+        if (result.kind === 'revoked-authorization')
+            return result;
+        if (result.kind !== 'action' && result.retryable) {
+            alive.deps.unanswered();
             return result;
         }
-        finally {
-            if (sending.get(submission.operation) === dispatch)
-                sending.delete(submission.operation);
-        }
+        const turn = answered(result, 'message_id');
+        await withDraft(alive, conversation, async (current, local) => {
+            const held = current?.submitted?.find((one) => one.operation === submission.operation);
+            if (current === undefined || held === undefined || held.turn !== null)
+                return undefined;
+            const others = current.submitted.filter((one) => one !== held);
+            if (result.kind !== 'action')
+                return returned(current, held, others);
+            const arrived = turn !== null && (await local.turnArrived(conversation, turn));
+            return withSubmitted(current, turn === null || arrived
+                ? others
+                : current.submitted.map((one) => (one === held ? { ...held, turn } : one)));
+        });
+        return result;
     }
-    function invoke(name, conversation, extra = {}) {
-        return deps.call(name, { conversation, ...extra });
+    finally {
+        alive.sendingEnded(submission.operation, dispatch);
     }
-    const surface = {
-        async list() {
-            await agentsReady();
-            return entries();
+}
+function invoke(alive, name, conversation, extra = { operation_id: changeBatchIdentity() }) {
+    return alive.deps.call(name, { conversation_id: conversation, ...extra });
+}
+export function conversationSurface(alive) {
+    return {
+        list() {
+            return new Promise((settle) => {
+                const answer = (listed) => {
+                    alive.listeners.leave(answer);
+                    settle(listed);
+                };
+                alive.listeners.join(answer);
+                conversationsLearned(alive);
+            });
         },
         async read(conversation, options = {}) {
-            const limit = limitOf(options);
-            return deps.durably(async (local) => structuredClone(viewOf(conversation, await local.messageWindow(conversation, limit))));
+            const { text, ...windowed } = options;
+            const asked = askedOf(windowed);
+            const phrase = phraseOf(text);
+            return alive.deps.durably(async (local) => {
+                const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before, phrase);
+                const total = asked.total ? await local.messageCount(conversation, phrase) : null;
+                const marked = await local.jobMarkers(conversation);
+                return structuredClone(viewOf(alive, conversation, messages, frameOf(asked, messages, more, total), (await local.chatDraft(conversation)) ?? null, await endedIn(alive, conversation), marked));
+            });
         },
         async create(input) {
-            const result = await deps.call('conversation.create', input);
-            const conversation = answered(result, 'conversation');
+            const result = await alive.deps.call('conversations/create', input);
+            const conversation = answered(result, 'conversation_id');
             if (conversation === null)
                 return result;
-            if (!listing.has(conversation))
-                creations.add(conversation);
+            const listed = (await heldList(alive)) ?? [];
+            if (!listed.some((entry) => entry.conversation === conversation)) {
+                alive.creating(conversation);
+            }
             const creation = creationOf(input);
             if (creation !== null)
-                await moved(creation.agent, creation.operation, conversation);
+                await moved(alive, creation.agent, creation.operation, conversation);
             return result;
         },
         async send(conversation, operation = changeBatchIdentity(), draft) {
-            if (deps.online()) {
-                const { submission, earlier } = await submitted(conversation, operation, draft);
-                if (!earlier || !deps.expired(operation))
-                    return dispatched(conversation, submission);
-                await forgotten(conversation, submission);
-                return EXPIRED;
+            if (alive.deps.full())
+                return DURABLE_WRITE;
+            if (alive.deps.online()) {
+                const held = await submitted(alive, conversation, operation, draft).catch((error) => {
+                    if (refusedForSpace(error))
+                        return null;
+                    throw error;
+                });
+                if (held === null)
+                    return DURABLE_WRITE;
+                return dispatched(alive, conversation, held);
             }
             if (draft !== undefined) {
-                await withDraft(conversation, (current) => current?.submitted?.some((one) => one.operation === operation) === true
+                await withDraft(alive, conversation, (current) => current?.submitted?.some((one) => one.operation === operation) === true
                     ? undefined
-                    : returned(current ?? { conversation, text: '', files: [], revision: '' }, { operation, ...draft, turn: null }, current?.submitted ?? []));
+                    : returned(current ?? { conversation, text: '', revision: '' }, { operation, ...draft, turn: null }, current?.submitted ?? []));
             }
             return OFFLINE;
         },
         answer(conversation, answer) {
-            return invoke('conversation.answer', conversation, { answer });
+            return invoke(alive, 'conversations/interaction/answer', conversation, {
+                operation_id: changeBatchIdentity(),
+                ...answer,
+            });
         },
         interrupt(conversation) {
-            return invoke('conversation.interrupt', conversation);
+            return invoke(alive, 'conversations/interrupt', conversation);
         },
         kill(conversation) {
-            return invoke('conversation.kill', conversation);
-        },
-        async cancel(conversation, turn) {
-            const result = await invoke('conversation.cancel', conversation, { turn });
-            if (result.kind !== 'action')
-                return result;
-            await withDraft(conversation, (current) => {
-                const held = current?.submitted?.find((one) => one.turn === turn);
-                if (current === undefined || held === undefined)
-                    return undefined;
-                return returned(current, held, current.submitted.filter((one) => one !== held));
-            });
-            return result;
+            return invoke(alive, 'conversations/kill', conversation);
         },
         delete(conversation) {
-            return invoke('conversation.delete', conversation);
+            return invoke(alive, 'conversations/delete', conversation);
         },
     };
-    const chatDraft = {
+}
+export function chatDraftSurface(alive) {
+    return {
         write(conversation, draft, revision = chatDraftRevision()) {
-            return withDraft(conversation, (current) => ({
+            return withDraft(alive, conversation, (current) => ({
                 conversation,
                 text: draft.text,
-                files: [...draft.files],
                 revision,
                 ...(current === undefined ? {} : pending(current)),
             }));
         },
+        prepend(conversation, draft) {
+            return withDraft(alive, conversation, (current) => ({
+                conversation,
+                ...(current === undefined ? { text: draft.text } : prepended(current, draft)),
+                revision: chatDraftRevision(),
+                ...(current === undefined ? {} : pending(current)),
+            }));
+        },
         discard(conversation) {
-            return withDraft(conversation, (current) => current === undefined
+            return withDraft(alive, conversation, (current) => current === undefined
                 ? undefined
-                : {
-                    conversation,
-                    text: '',
-                    files: [],
-                    revision: chatDraftRevision(),
-                    ...pending(current),
-                });
+                : { conversation, text: '', revision: chatDraftRevision(), ...pending(current) });
         },
     };
-    return {
-        surface,
-        chatDraft,
-        hydrate(held, kept) {
-            stored.clear();
-            reads.clear();
-            partials.clear();
-            for (const entry of held) {
-                stored.add(entry.conversation);
-                if (entry.read !== undefined)
-                    reads.set(entry.conversation, entry.read);
-                if (entry.partial)
-                    partials.add(entry.conversation);
-            }
-            drafts.clear();
-            for (const record of kept)
-                drafts.set(record.conversation, record);
-        },
-        async reconcile() {
-            if (!listKnown)
+}
+export async function conversationsOpened(alive, local) {
+    const { conversationList, conversationCursor } = await local.facts();
+    if (conversationList === null || alive.known())
+        return;
+    alive.deps.stream()?.hold(conversationCursor);
+    conversationsLearned(alive);
+}
+export async function reconcileConversations(alive) {
+    if (!alive.known())
+        return;
+    const local = await alive.deps.local();
+    const [held, kept, { conversationList }] = await Promise.all([
+        local.conversations(),
+        local.chatDrafts(),
+        local.facts(),
+    ]);
+    const list = conversationList ?? [];
+    const entries = new Map(list.map((entry) => [entry.conversation, entry]));
+    const named = new Set(entries.keys());
+    const reads = new Map(held.map((one) => [one.conversation, one]));
+    const { replicated } = alive.held.now();
+    const leaving = [
+        ...new Set([...replicated, ...reads.keys(), ...kept.map(({ conversation }) => conversation)]),
+    ].filter((conversation) => !named.has(conversation) &&
+        !alive.isCreating(conversation) &&
+        (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation, list)));
+    for (const conversation of named) {
+        if (!replicated.has(conversation) &&
+            missed(alive, conversation, reads.get(conversation), entries.get(conversation))) {
+            alive.fellBehind(conversation);
+        }
+    }
+    alive.held.set({ replicated: named });
+    handReplicated(alive);
+    if (leaving.length > 0)
+        await remove(alive, leaving);
+}
+export async function catchUpConversations(alive, progress) {
+    if (alive.deps.full()) {
+        if (!alive.current())
+            progress.complete = false;
+        return;
+    }
+    const owed = (conversation) => alive.behind(conversation) && alive.held.now().replicated.has(conversation);
+    const read = async (conversations) => {
+        if (conversations.length === 0 || alive.deps.closed())
+            return;
+        const failed = await caughtUp(alive, conversations);
+        if (failed?.kind === 'transport-uncertainty')
+            progress.reachable = false;
+    };
+    const asking = alive.behindAll().filter(owed).sort();
+    const awaited = asking.filter((conversation) => alive.catching(conversation) !== undefined);
+    await Promise.all([
+        read(asking.filter((conversation) => alive.catching(conversation) === undefined)),
+        Promise.all(awaited.map((conversation) => alive.catching(conversation))).then(() => read(awaited.filter((conversation) => owed(conversation) && alive.catching(conversation) === undefined))),
+    ]);
+    if (!alive.current())
+        progress.complete = false;
+}
+export async function resendConversations(alive, progress) {
+    const local = await alive.deps.local();
+    const tried = new Set();
+    for (const { conversation } of await local.chatDrafts()) {
+        for (;;) {
+            const submission = (await local.chatDraft(conversation))?.submitted?.find((one) => one.turn === null && !alive.sending(one.operation) && !tried.has(one.operation));
+            if (submission === undefined)
+                break;
+            if (alive.deps.closed())
+                return;
+            tried.add(submission.operation);
+            const result = await dispatched(alive, conversation, submission);
+            if (result.kind === 'revoked-authorization')
+                return;
+            if (result.kind === 'transport-uncertainty') {
+                progress.reachable = false;
                 return;
-            const named = new Set(listing.keys());
-            const leaving = [
-                ...new Set([...replicated, ...stored, ...reads.keys(), ...drafts.keys()]),
-            ].filter((conversation) => !named.has(conversation) &&
-                !creations.has(conversation) &&
-                (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation)));
-            for (const conversation of named) {
-                if (!replicated.has(conversation))
-                    behind.add(conversation);
-            }
-            replicated = named;
-            handReplicated();
-            if (leaving.length > 0)
-                await remove(leaving);
-        },
-        async catchUp(progress) {
-            const reading = [...behind].filter((conversation) => replicated.has(conversation)).sort();
-            if (reading.length > 0 && !deps.closed()) {
-                const failed = await readHistories(reading);
-                if (failed?.kind === 'transport-uncertainty')
-                    progress.reachable = false;
             }
-            if (behind.size > 0)
+            if (result.kind !== 'action' && result.retryable) {
                 progress.complete = false;
-        },
-        async resend(progress) {
-            for (const [conversation, held] of [...drafts]) {
-                for (const submission of held.submitted ?? []) {
-                    if (submission.turn !== null || sending.has(submission.operation))
-                        continue;
-                    if (deps.closed())
-                        return;
-                    if (deps.expired(submission.operation)) {
-                        await forgotten(conversation, submission);
-                        continue;
-                    }
-                    const result = await dispatched(conversation, submission);
-                    if (result.kind === 'revoked-authorization')
-                        return;
-                    if (result.kind === 'transport-uncertainty') {
-                        progress.reachable = false;
-                        return;
-                    }
-                    if (result.kind !== 'action' && result.retryable) {
-                        progress.complete = false;
-                        return;
-                    }
-                }
-            }
-        },
-        current() {
-            return behind.size === 0;
-        },
-        known() {
-            return listKnown;
-        },
-        reconnected() {
-            for (const conversation of replicated)
-                gap(conversation);
-        },
-        reopened() {
-            sending.clear();
-        },
-        watch(conversation, options, deliver) {
-            const limit = limitOf(options);
-            const key = JSON.stringify([conversation, limit ?? null]);
-            const view = views.get(key) ?? {
-                conversation,
-                limit,
-                watchers: new Set(),
-                window: null,
-            };
-            views.set(key, view);
-            const watcher = { notify: deliver, ready: false };
-            view.watchers.add(watcher);
-            void deps
-                .durably(async (local) => {
-                view.window ??= await local.messageWindow(conversation, limit);
-            })
-                .then(() => {
-                if (deps.closed() || !view.watchers.has(watcher))
-                    return;
-                watcher.ready = true;
-                watcher.notify(viewOf(conversation, view.window ?? []));
-            })
-                .catch(() => { });
-            return () => {
-                if (!view.watchers.delete(watcher))
-                    return;
-                if (view.watchers.size === 0)
-                    views.delete(key);
-            };
-        },
-        watchList(deliver) {
-            listWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && listWatchers.has(deliver))
-                    deliver(entries());
-            });
-            return () => {
-                listWatchers.delete(deliver);
-            };
-        },
-        watchAgents(deliver) {
-            agentWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && agentWatchers.has(deliver))
-                    deliver(agents());
-            });
-            return () => {
-                agentWatchers.delete(deliver);
-            };
-        },
-        changed(set) {
-            for (const conversation of set.conversations)
-                emit(conversation);
-            const declaration = deps.agents();
-            if (declaration !== undefined &&
-                set.documents.some((change) => change.locator === declaration.locator)) {
-                agentsRead = readAgents().catch(() => {
-                    agentsRead = null;
-                });
-            }
-        },
-        receive(event) {
-            if (deps.closed())
-                return false;
-            if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted') {
-                if (event.kind === 'list') {
-                    listing.clear();
-                    for (const entry of event.entries) {
-                        listing.set(entry.conversation, { ...entry });
-                        creations.delete(entry.conversation);
-                    }
-                    listKnown = true;
-                }
-                else if (event.kind === 'listed') {
-                    listing.set(event.entry.conversation, { ...event.entry });
-                    creations.delete(event.entry.conversation);
-                }
-                else {
-                    listing.delete(event.conversation);
-                }
-                emitList();
-                return (event.kind !== 'list' &&
-                    listKnown &&
-                    (listing.size !== replicated.size ||
-                        [...listing.keys()].some((conversation) => !replicated.has(conversation))));
+                return;
             }
-            heard(event);
-            return false;
-        },
-        searchable() {
-            return [...(listKnown ? listing.keys() : stored)].sort();
-        },
-        acquired(conversation) {
-            return reads.has(conversation) && !partials.has(conversation);
-        },
-        close() {
-            views.clear();
-            lives.clear();
-            listWatchers.clear();
-            agentWatchers.clear();
-        },
+        }
+    }
+}
+export function watchConversation(alive, conversation, options, deliver) {
+    const asked = askedOf(options);
+    const key = JSON.stringify([conversation, asked.limit, asked.after ?? null, asked.total]);
+    const { view, watcher } = alive.viewJoined(key, conversation, asked, deliver);
+    const { held } = view;
+    const reading = new AbortController();
+    void untilAnswered(() => alive.deps.durably(async (local) => {
+        if (held.now().window !== null)
+            return;
+        const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
+        held.set({ draft: (await local.chatDraft(conversation)) ?? null });
+        held.set({ ended: await endedIn(alive, conversation) });
+        held.set({ window: messages });
+        held.set({ marked: await local.jobMarkers(conversation) });
+        held.set({ more });
+        held.set({ total: asked.total ? await local.messageCount(conversation) : null });
+    }), reading.signal)
+        .then(() => {
+        if (alive.deps.closed() || !view.admit(watcher))
+            return;
+        const { window, draft, ended, marked } = held.now();
+        const shown = window ?? [];
+        watcher.notify(viewOf(alive, conversation, shown, sharedFrame(view, shown), draft, ended, marked));
+    })
+        .catch(() => { });
+    return () => {
+        reading.abort();
+        alive.viewLeft(key, view, watcher);
     };
 }
+export function watchConversationList(alive, deliver) {
+    alive.listeners.join(deliver);
+    conversationsLearned(alive);
+    return () => alive.listeners.leave(deliver);
+}
+export function watchConversationAgents(alive, deliver) {
+    alive.agentListeners.join(deliver);
+    conversationsLearned(alive);
+    readAgents(alive);
+    return () => alive.agentListeners.leave(deliver);
+}
+export function conversationsChanged(alive, set) {
+    for (const conversation of set.conversations)
+        emit(alive, conversation);
+}
+export function receiveConversationEvent(alive, event) {
+    if (alive.deps.closed())
+        return;
+    if (event.kind === 'list') {
+        if (event.whole)
+            alive.relistBegun();
+        if (alive.relisting())
+            alive.relistHeard(event.entries);
+        if (event.more && alive.relisting())
+            return;
+        const whole = alive.relistTaken();
+        listChanged(alive, {
+            replacing: whole !== null,
+            set: whole === null ? event.entries : [...whole.values()],
+            gone: null,
+            ...(event.more ? { paged: true } : { cursor: event.cursor }),
+        });
+        return;
+    }
+    if (event.kind === 'listed') {
+        alive.relistHeard([event.entry]);
+        listChanged(alive, { replacing: false, set: [event.entry], gone: null });
+        return;
+    }
+    if (event.kind === 'unlisted') {
+        alive.relistDropped(event.conversation);
+        listChanged(alive, { replacing: false, set: [], gone: event.conversation });
+        return;
+    }
+    heard(alive, event);
+}