@agentshouse/mdruntime 0.1.0-cd507e16e5fc0 → 0.1.0-cd574a610e9c8

package/dist/conversation.js

@@ -1,14 +1,17 @@
 import { cursorOf, decodedCursor } from '@agentshouse/mdmodel';
+import { applied, isTurn, standingState, } from '@agentshouse/session-content';
 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 { runtimeError, uncaught } from './failure.js';
 import { refusedForSpace } from './durability.js';
 import { changeBatchIdentity, chatDraftRevision } from './identity.js';
-import { OFFLINE } from './outcome.js';
-import { jobsOf, runningLine } from './parts.js';
+import { OFFLINE, } from './outcome.js';
+import { runningLine } from './parts.js';
+import { record, text } from './read.js';
 import { openQuestion, questionAsked } from './questions.js';
 import { untilAnswered } from './recovery.js';
+import { retrying } from './retried.js';
 import { capped, FROM_START, messageOrder, precedes } from './windows.js';
 export function unheldView(conversation) {
     return {
@@ -21,15 +24,19 @@ export function unheldView(conversation) {
         commands: [],
         options: [],
         starting: null,
-        subagents: [],
+        state: null,
         link: null,
+        deliveryWaiting: [],
         deliveryUnknown: [],
         chatDraft: null,
-        jobs: [],
+        dismissedSuggestion: null,
+        pins: [],
     };
 }
 export const SESSION_STARTED = 'Session started';
 const NEW_CHAT = 'new:';
+const LISTING = 'listing';
+export const CATCHING_UP = 'catching-up';
 export const HISTORY_CONVERSATIONS = 64;
 export function newChat(agent) {
     return `${NEW_CHAT}${agent}`;
@@ -42,52 +49,15 @@ function creationOf(input) {
 }
 function startedTurn(turn, operation) {
     if (operation.op === 'begin')
-        return { turn, started: operation.at, parts: [], context: null };
-    if (operation.op === 'context') {
-        return {
-            turn,
-            started: null,
-            parts: [],
-            context: { used: operation.used, window: operation.window },
-        };
-    }
-    return operation.op === 'start' && operation.index === 0
-        ? { turn, started: null, parts: [structuredClone(operation.part)], context: null }
-        : null;
-}
-function changedFields(part, operation) {
-    if (operation.op === 'append') {
-        return { text: `${String(part.text ?? '')}${operation.text}` };
-    }
-    if (operation.op === 'status') {
-        return { status: operation.status, result: structuredClone(operation.result) };
-    }
-    if (operation.op === 'count')
-        return { count: operation.count };
-    return { entries: structuredClone(operation.entries) };
+        return { turn, started: operation.at, parts: [] };
+    const parts = applied([], operation);
+    return parts === null ? null : { turn, started: null, parts };
 }
 function appliedTurn(held, operation) {
     if (operation.op === 'begin')
         return { ...held, started: operation.at };
-    if (operation.op === 'context') {
-        return { ...held, context: { used: operation.used, window: operation.window } };
-    }
-    if (operation.op === 'start') {
-        if (operation.index !== 0 && operation.index !== held.parts.length)
-            return null;
-        return {
-            ...held,
-            parts: [...held.parts.slice(0, operation.index), structuredClone(operation.part)],
-        };
-    }
-    const part = held.parts[operation.index];
-    if (typeof part !== 'object' || part === null)
-        return null;
-    const changed = { ...part, ...changedFields(part, operation) };
-    return {
-        ...held,
-        parts: held.parts.map((kept, at) => (at === operation.index ? changed : kept)),
-    };
+    const parts = applied(held.parts, operation);
+    return parts === null ? null : { ...held, parts };
 }
 function windowOf(held, arriving, limit) {
     const byIdentity = new Map(held.map((message) => [message.identity, message]));
@@ -110,7 +80,7 @@ function frameOf(asked, messages, more, total) {
     };
 }
 function newestOf(arriving, from) {
-    return arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from);
+    return arriving.reduce((top, message) => (top === null || message.change > top ? message.change : top), from);
 }
 function acceptedMessage(value) {
     if (typeof value !== 'object' || value === null)
@@ -119,6 +89,7 @@ function acceptedMessage(value) {
     if (typeof record.identity !== 'string' ||
         typeof record.turn !== 'string' ||
         typeof record.position !== 'string' ||
+        typeof record.change !== 'string' ||
         typeof record.text !== 'string') {
         return null;
     }
@@ -126,6 +97,7 @@ function acceptedMessage(value) {
         identity: record.identity,
         turn: record.turn,
         position: record.position,
+        change: record.change,
         text: record.text,
         message: structuredClone(record.message),
     };
@@ -227,17 +199,17 @@ 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') };
+export function joinedDraft(first, second) {
+    return [first, second].filter((one) => one !== '').join('\n');
 }
 function returned(draft, submission, others) {
     return withSubmitted({
         conversation: draft.conversation,
-        ...prepended(draft, submission),
+        text: joinedDraft(submission.text, draft.text),
         revision: chatDraftRevision(),
     }, others);
 }
-function viewOf(alive, conversation, held, frame, draft, ended, marked) {
+function viewOf(alive, conversation, held, frame, { draft, ended, dismissed, pins }) {
     const facts = alive.liveOf(conversation);
     return {
         conversation,
@@ -255,26 +227,41 @@ function viewOf(alive, conversation, held, frame, draft, ended, marked) {
         commands: structuredClone(facts.commands),
         options: structuredClone(facts.options),
         starting: facts.starting,
-        subagents: structuredClone(facts.subagents),
+        state: sessionOf(facts, held, ended),
         link: facts.link === null ? null : { ...facts.link },
+        deliveryWaiting: [...facts.deliveryWaiting],
         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),
+        dismissedSuggestion: dismissed,
+        pins: [...pins],
     };
 }
+function sessionOf(facts, held, ended) {
+    if (facts.state !== null)
+        return structuredClone(facts.state);
+    const saved = [...held]
+        .reverse()
+        .map(({ message }) => record(message))
+        .find(({ content }) => isTurn(content));
+    const at = saved === undefined ? null : text(saved, 'accepted_at');
+    if (saved === undefined || !isTurn(saved.content) || at === null)
+        return null;
+    const down = facts.process?.running === false;
+    return structuredClone(standingState(saved.content.state, at, down ? at : ended));
+}
 function emit(alive, conversation) {
     if (alive.deps.closed())
         return;
     for (const view of alive.views()) {
-        const { window, draft, ended, marked } = view.held.now();
+        const held = view.held.now();
+        const { window } = held;
         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);
+        const frame = sharedFrame(view, window);
+        const value = viewOf(alive, conversation, window, frame, held);
         for (const watcher of ready)
             watcher.notify(value);
     }
@@ -285,23 +272,18 @@ function sharedFrame(view, window) {
 }
 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 });
+            held.set({ window: [], more: false, total: total === null ? null : 0 });
             continue;
         }
         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 });
@@ -325,66 +307,90 @@ function rowOf(alive, conversation) {
     };
 }
 async function entries(alive) {
-    const list = await heldList(alive);
-    if (list === null)
+    const listing = await heldListing(alive);
+    if (listing === null)
+        return null;
+    const list = listing.conversations;
+    const agents = new Map(listing.agents.map((agent) => [agent.id, agent]));
+    if (list.some((entry) => !agents.has(entry.agent)))
         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),
-    }));
+    return list.map((entry) => {
+        const agent = agents.get(entry.agent);
+        return {
+            conversation: entry.conversation,
+            agent: { identity: agent.id, name: agent.name, retired: agent.retired_at !== null },
+            name: entry.name,
+            created: entry.created,
+            finished: entry.finished,
+            outcome: entry.outcome,
+            waiting: entry.waiting,
+            subject: entry.subject,
+            ...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 heldListing(alive) {
+    const { conversationList, agentList } = await (await alive.deps.local()).facts();
+    if (conversationList !== null && agentList !== null)
+        return { conversations: conversationList, agents: agentList };
+    return !alive.known() && alive.deps.stream() !== undefined && alive.deps.online()
+        ? null
+        : { conversations: [], agents: [] };
 }
 async function endedIn(alive, conversation) {
-    const list = await heldList(alive);
-    return list?.find((entry) => entry.conversation === conversation)?.processEnded ?? null;
+    const listing = await heldListing(alive);
+    return (listing?.conversations.find((entry) => entry.conversation === conversation)?.processEnded ??
+        null);
+}
+function upserted(kept, set, key) {
+    const held = new Map(kept.map((one) => [key(one), one]));
+    for (const one of set)
+        held.set(key(one), { ...one });
+    return held;
 }
 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 });
+        const { conversationList, agentList, conversationCursor } = await local.facts();
+        const held = upserted(change.replacing ? [] : (conversationList ?? []), change.set, (entry) => entry.conversation);
+        for (const entry of change.set)
             alive.created(entry.conversation);
-        }
         if (change.gone !== null)
             held.delete(change.gone);
         const list = [...held.values()];
+        const agents = [
+            ...upserted(change.replacing ? [] : (agentList ?? []), change.agents, (agent) => agent.id).values(),
+        ];
         if (JSON.stringify(list) !== JSON.stringify(conversationList)) {
             await local.fact('conversationList', list);
         }
+        if (JSON.stringify(agents) !== JSON.stringify(agentList)) {
+            await local.fact('agentList', agents);
+        }
         if (change.cursor !== undefined) {
             if (change.cursor !== conversationCursor) {
                 await local.fact('conversationCursor', change.cursor);
             }
             alive.deps.stream()?.hold(change.cursor);
         }
-        return list;
+        return { conversations: list, agents };
     })
-        .catch(async () => (await (await alive.deps.local()).facts()).conversationList ?? [])
-        .then((list) => {
+        .catch(async () => {
+        const { conversationList, agentList } = await (await alive.deps.local()).facts();
+        return { conversations: conversationList ?? [], agents: agentList ?? [] };
+    })
+        .then((listing) => {
         if (alive.deps.closed() || change.paged === true)
             return;
+        const list = listing.conversations;
         endedAnew(alive, list);
         if (change.cursor !== undefined) {
-            alive.held.set({ listKnown: true });
+            alive.held.set({ listKnown: true, openingListed: true });
             settleBehind(alive, list);
             openingEnded(alive);
             alive.deps.settled();
@@ -392,14 +398,15 @@ function listChanged(alive, change) {
         emitList(alive);
         if (!alive.known())
             return;
-        retiredDrafts(alive, list);
-        const { replicated } = alive.held.now();
-        if (change.cursor === undefined &&
-            (list.length !== replicated.size ||
-                list.some(({ conversation }) => !replicated.has(conversation)))) {
+        retiredDrafts(alive, listing);
+        const { replicated, openingRead } = alive.held.now();
+        if (change.cursor === undefined
+            ? list.length !== replicated.size ||
+                list.some(({ conversation }) => !replicated.has(conversation))
+            : openingRead) {
             alive.deps.again();
         }
-    }, () => { });
+    }, uncaught);
 }
 function endedAnew(alive, list) {
     const entries = new Map(list.map((entry) => [entry.conversation, entry]));
@@ -412,20 +419,23 @@ function endedAnew(alive, list) {
         emit(alive, view.conversation);
     }
 }
-function shownList(alive, work) {
-    const reading = heldList(alive);
+function shownListing(alive, work) {
+    const reading = heldListing(alive);
     alive.inOrder(async () => {
-        const list = await reading.catch(() => null);
-        if (list === null || alive.deps.closed())
+        const listing = await reading.catch((error) => {
+            uncaught(error);
+            return null;
+        });
+        if (listing === null || alive.deps.closed())
             return;
-        work(list);
+        work(listing);
     });
 }
 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);
+            const value = await untilAnswered(retrying(alive.deps.retries, 'conversations', LISTING, () => entries(alive)), alive.closing, () => true, alive.deps.recovery);
             if (alive.deps.closed())
                 return;
             if (value === null)
@@ -463,57 +473,48 @@ export function conversationsLearned(alive) {
         return;
     if (alive.listeners.waiting())
         tellList(alive);
-    if (!alive.agentListeners.waiting())
+    if (!alive.agentListeners.waiting() && !alive.listedListeners.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 });
-    }
-    return [...named]
-        .filter(([, agent]) => !agent.retired)
-        .map(([identity, agent]) => ({ identity, name: agent.name }))
+    shownListing(alive, (listing) => {
+        alive.agentListeners.welcome(agentsOf(listing));
+        alive.listedListeners.welcome(structuredClone(listing.agents));
+    });
+}
+function agentsOf(listing) {
+    return listing.agents
+        .filter((agent) => agent.retired_at === null)
+        .map((agent) => ({
+        identity: agent.id,
+        name: agent.name,
+        cli: agent.cli,
+        model: agent.model,
+        effort: agent.effort,
+        environment: {
+            identity: agent.environment,
+            name: agent.environment_name,
+            state: agent.environment_connected ? 'online' : 'offline',
+        },
+    }))
         .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';
-        }
-        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())
+    const { agentListeners, listedListeners } = alive;
+    if (alive.deps.closed() || (!agentListeners.told() && !listedListeners.told()))
         return;
-    shownList(alive, (list) => {
-        const value = agents(alive, list);
+    shownListing(alive, (listing) => {
+        const value = agentsOf(listing);
         const shown = JSON.stringify(value);
-        if (shown === alive.held.now().agentsShown)
-            return;
-        alive.held.set({ agentsShown: shown });
-        alive.agentListeners.tell(value);
+        if (shown !== alive.held.now().agentsShown) {
+            alive.held.set({ agentsShown: shown });
+            agentListeners.tell(value);
+        }
+        const listed = JSON.stringify(listing.agents);
+        if (listed !== alive.held.now().listedShown) {
+            alive.held.set({ listedShown: listed });
+            listedListeners.tell(structuredClone(listing.agents));
+        }
     });
 }
 function setLive(alive, conversation, next) {
@@ -527,11 +528,11 @@ function setLive(alive, conversation, next) {
         after.asked !== before.asked)
         tellSoon(alive);
 }
-function retiredChat(conversation, list) {
+function retiredChat(conversation, listing) {
     if (!conversation.startsWith(NEW_CHAT))
         return false;
     const agent = conversation.slice(NEW_CHAT.length);
-    return list.some((entry) => entry.agent === agent && entry.agentRetired);
+    return listing.agents.some((one) => one.id === agent && one.retired_at !== null);
 }
 function live(alive, conversation, change) {
     alive.factsHeard(conversation, FACTS.filter((one) => one in change));
@@ -550,8 +551,9 @@ function openingEnded(alive) {
             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,
+            state: facts.has('state') ? QUIET.state : held.state,
             link: facts.has('link') ? QUIET.link : held.link,
+            deliveryWaiting: facts.has('deliveryWaiting') ? QUIET.deliveryWaiting : held.deliveryWaiting,
             deliveryUnknown: facts.has('deliveryUnknown') ? QUIET.deliveryUnknown : held.deliveryUnknown,
         });
         emit(alive, conversation);
@@ -583,19 +585,13 @@ function handReplicated(alive) {
 }
 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 kept = new Set(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);
+            heldInViews(alive, conversation, { draft: null, dismissed: null });
             alive.forget(conversation);
             setLive(alive, conversation, null);
             await slide(alive, local, conversation, null);
@@ -624,7 +620,7 @@ 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))
+    if (!list.agents.some((agent) => agent.retired_at !== null))
         return;
     void alive.deps
         .local()
@@ -634,7 +630,7 @@ function retiredDrafts(alive, list) {
             held.some(({ conversation }) => retiredChat(conversation, list))) {
             alive.deps.again();
         }
-    }, () => { });
+    }, uncaught);
 }
 function settleBehind(alive, list) {
     void alive.deps
@@ -660,21 +656,19 @@ function settleBehind(alive, list) {
         alive.deps.settled();
         if (owed)
             alive.deps.again();
-    }, () => { });
+    }, uncaught);
 }
 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);
+        const advances = read !== undefined && !alive.behind(conversation) && (read === null || message.change > read);
         await sealed(alive, local, conversation, new Set([message.turn]));
         await local.keepMessages({
             conversation,
             messages: [message],
-            ...(advances ? { read: { at: message.position, partial: false } } : {}),
+            ...(advances ? { read: { at: message.change, partial: false } } : {}),
         });
         sealTurns(alive, conversation, new Set([message.turn]));
         await slide(alive, local, conversation, [message]);
@@ -786,8 +780,8 @@ function heard(alive, event) {
         live(alive, conversation, { starting: event.step });
         return;
     }
-    if (event.kind === 'subagents') {
-        live(alive, conversation, { subagents: structuredClone(event.subagents) });
+    if (event.kind === 'state') {
+        live(alive, conversation, { state: structuredClone(event.state) });
         return;
     }
     if (event.kind === 'link') {
@@ -795,13 +789,16 @@ function heard(alive, event) {
         return;
     }
     if (event.kind === 'deliveries') {
-        live(alive, conversation, { deliveryUnknown: [...event.unknown] });
+        live(alive, conversation, {
+            deliveryWaiting: [...event.waiting],
+            deliveryUnknown: [...event.unknown],
+        });
         return;
     }
     const arriving = acceptedMessage(event.message);
     if (arriving === null)
         return;
-    alive.heardAt(conversation, arriving.position);
+    alive.heardAt(conversation, arriving.change);
     if (alive.held.now().replicated.has(conversation)) {
         if (alive.deps.full()) {
             alive.gapOpened(conversation);
@@ -810,6 +807,8 @@ function heard(alive, event) {
         void keep(alive, conversation, arriving).catch((error) => {
             if (refusedForSpace(error))
                 alive.gapOpened(conversation);
+            else
+                uncaught(error);
         });
         return;
     }
@@ -817,19 +816,27 @@ function heard(alive, event) {
         emit(alive, conversation);
 }
 async function kept(alive, local, conversation, following) {
-    const shown = following === null || empty(following) ? null : following;
-    if (shown === null)
+    const draft = following === null || empty(following) ? null : following;
+    if (draft === null)
         await local.dropChatDraft(conversation);
     else
-        await local.keepChatDrafts([shown]);
-    shownDraft(alive, conversation, shown);
+        await local.keepChatDrafts([draft]);
+    heldInViews(alive, conversation, { draft });
 }
-function shownDraft(alive, conversation, draft) {
+function heldInViews(alive, conversation, held) {
     for (const view of alive.views()) {
         if (view.conversation === conversation)
-            view.held.set({ draft });
+            view.held.set(held);
     }
 }
+async function factOf(local, name) {
+    return Object.fromEntries((await local.conversationFacts())
+        .filter((fact) => fact.name === name)
+        .map(({ conversation, value }) => [conversation, value]));
+}
+async function dismissedIn(local, conversation) {
+    return (await factOf(local, 'dismissedSuggestion'))[conversation] ?? null;
+}
 async function draftAt(local, conversation) {
     return (await local.chatDraft(conversation)) ?? undefined;
 }
@@ -860,9 +867,9 @@ function moved(alive, agent, operation, to) {
             : [{ ...unsent, conversation: to }];
         const left = { ...(taken.length === 0 ? unsent : blank), moves: [...earlier, operation] };
         await local.keepChatDrafts([left, ...taken]);
-        shownDraft(alive, from, left);
+        heldInViews(alive, from, { draft: left });
         for (const one of taken)
-            shownDraft(alive, to, one);
+            heldInViews(alive, to, { draft: one });
         alive.deps.publish(conversationChangeSet([from, to]));
     });
 }
@@ -893,13 +900,10 @@ async function submitted(alive, conversation, operation, draft) {
     });
     return submission;
 }
-async function dispatched(alive, conversation, submission) {
+async function dispatched(alive, conversation, submission, resent = false) {
     const dispatch = alive.sendingBegan(submission.operation);
     try {
-        const result = await invoke(alive, 'conversations/send', conversation, {
-            operation_id: submission.operation,
-            text: submission.text,
-        });
+        const result = await invoke(alive, 'conversations/send', conversation, submission.operation, { text: submission.text }, { step: 'sending', instance: `message ${submission.operation}` });
         dispatch.set({ answered: result.kind !== 'transport-uncertainty' });
         if (result.kind === 'revoked-authorization')
             return result;
@@ -907,6 +911,7 @@ async function dispatched(alive, conversation, submission) {
             alive.deps.unanswered();
             return result;
         }
+        alive.deps.heard(submission.operation, resent);
         const turn = answered(result, 'message_id');
         await withDraft(alive, conversation, async (current, local) => {
             const held = current?.submitted?.find((one) => one.operation === submission.operation);
@@ -926,11 +931,12 @@ async function dispatched(alive, conversation, submission) {
         alive.sendingEnded(submission.operation, dispatch);
     }
 }
-function invoke(alive, name, conversation, extra = { operation_id: changeBatchIdentity() }) {
-    return alive.deps.call(name, { conversation_id: conversation, ...extra });
+function invoke(alive, name, conversation, operation, extra = {}, attempt) {
+    return alive.deps.call(name, { conversation_id: conversation, operation_id: operation, ...extra }, attempt);
 }
-export function conversationSurface(alive) {
+export function conversationSurface(alive, files) {
     return {
+        ...files,
         list() {
             return new Promise((settle) => {
                 const answer = (listed) => {
@@ -948,8 +954,12 @@ export function conversationSurface(alive) {
             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));
+                return structuredClone(viewOf(alive, conversation, messages, frameOf(asked, messages, more, total), {
+                    draft: (await local.chatDraft(conversation)) ?? null,
+                    ended: await endedIn(alive, conversation),
+                    dismissed: await dismissedIn(local, conversation),
+                    pins: (await local.facts()).chatPins,
+                }));
             });
         },
         async create(input) {
@@ -957,7 +967,7 @@ export function conversationSurface(alive) {
             const conversation = answered(result, 'conversation_id');
             if (conversation === null)
                 return result;
-            const listed = (await heldList(alive)) ?? [];
+            const listed = (await heldListing(alive))?.conversations ?? [];
             if (!listed.some((entry) => entry.conversation === conversation)) {
                 alive.creating(conversation);
             }
@@ -986,40 +996,90 @@ export function conversationSurface(alive) {
             }
             return OFFLINE;
         },
-        answer(conversation, answer) {
-            return invoke(alive, 'conversations/interaction/answer', conversation, {
-                operation_id: changeBatchIdentity(),
-                ...answer,
+        answer(conversation, answer, operation) {
+            return invoke(alive, 'conversations/interaction/answer', conversation, operation, answer);
+        },
+        interrupt(conversation, operation) {
+            return invoke(alive, 'conversations/interrupt', conversation, operation);
+        },
+        kill(conversation, operation) {
+            return invoke(alive, 'conversations/kill', conversation, operation);
+        },
+        delete(conversation, operation) {
+            return invoke(alive, 'conversations/delete', conversation, operation);
+        },
+        takeOut(conversation, message, operation) {
+            return invoke(alive, 'conversations/take-out', conversation, operation, {
+                message_id: message,
+            });
+        },
+        decide({ request, room, message }, decision, operation) {
+            return alive.deps.call('agent-functions/decide', {
+                room_ref: room,
+                request,
+                ...(message === undefined ? {} : { message }),
+                decision,
+                operation_id: operation,
+            });
+        },
+        rename(conversation, name, operation) {
+            return invoke(alive, 'conversations/rename', conversation, operation, { name });
+        },
+        option(conversation, option, value, operation) {
+            return invoke(alive, 'conversations/option/set', conversation, operation, { option, value });
+        },
+        retry(conversation, message, operation) {
+            return invoke(alive, 'conversations/retry', conversation, operation, {
+                message_id: message,
             });
         },
-        interrupt(conversation) {
-            return invoke(alive, 'conversations/interrupt', conversation);
+        async pin(figures) {
+            const pins = [...figures];
+            await alive.deps.durably((local) => local.fact('chatPins', pins));
+            const views = [...alive.views()];
+            for (const view of views)
+                view.held.set({ pins });
+            for (const conversation of new Set(views.map((view) => view.conversation))) {
+                emit(alive, conversation);
+            }
         },
-        kill(conversation) {
-            return invoke(alive, 'conversations/kill', conversation);
+        async openTurn(conversation, turn) {
+            await alive.deps.durably((local) => local.keepConversationFact({ conversation, name: 'openedTurn', value: turn }));
+            tellList(alive);
         },
-        delete(conversation) {
-            return invoke(alive, 'conversations/delete', conversation);
+        dismissSuggestion(conversation, suggestion) {
+            return alive.deps.durably(async (local) => {
+                if ((await dismissedIn(local, conversation)) === suggestion)
+                    return;
+                await local.keepConversationFact({
+                    conversation,
+                    name: 'dismissedSuggestion',
+                    value: suggestion,
+                });
+                heldInViews(alive, conversation, { dismissed: suggestion });
+                alive.deps.publish(conversationChangeSet([conversation]));
+            });
         },
     };
 }
+function rewritten(alive, conversation, text, revision = chatDraftRevision()) {
+    return withDraft(alive, conversation, (current) => ({
+        conversation,
+        text: text(current?.text ?? ''),
+        revision,
+        ...(current === undefined ? {} : pending(current)),
+    }));
+}
 export function chatDraftSurface(alive) {
     return {
-        write(conversation, draft, revision = chatDraftRevision()) {
-            return withDraft(alive, conversation, (current) => ({
-                conversation,
-                text: draft.text,
-                revision,
-                ...(current === undefined ? {} : pending(current)),
-            }));
+        write(conversation, draft, revision) {
+            return rewritten(alive, conversation, () => draft.text, revision);
         },
         prepend(conversation, draft) {
-            return withDraft(alive, conversation, (current) => ({
-                conversation,
-                ...(current === undefined ? { text: draft.text } : prepended(current, draft)),
-                revision: chatDraftRevision(),
-                ...(current === undefined ? {} : pending(current)),
-            }));
+            return rewritten(alive, conversation, (held) => joinedDraft(draft.text, held));
+        },
+        append(conversation, draft) {
+            return rewritten(alive, conversation, (held) => joinedDraft(held, draft.text));
         },
         discard(conversation) {
             return withDraft(alive, conversation, (current) => current === undefined
@@ -1029,31 +1089,34 @@ export function chatDraftSurface(alive) {
     };
 }
 export async function conversationsOpened(alive, local) {
-    const { conversationList, conversationCursor } = await local.facts();
-    if (conversationList === null || alive.known())
+    const { conversationList, agentList, conversationCursor } = await local.facts();
+    if (conversationList === null || agentList === null || alive.known())
         return;
     alive.deps.stream()?.hold(conversationCursor);
     conversationsLearned(alive);
 }
+export function reconcileOpening(alive) {
+    alive.held.set({ openingRead: true });
+    return reconcileConversations(alive);
+}
 export async function reconcileConversations(alive) {
     if (!alive.known())
         return;
     const local = await alive.deps.local();
-    const [held, kept, { conversationList }] = await Promise.all([
+    const [held, stored, { conversationList, agentList }] = await Promise.all([
         local.conversations(),
-        local.chatDrafts(),
+        local.storedConversations(),
         local.facts(),
     ]);
     const list = conversationList ?? [];
+    const listing = { conversations: list, agents: agentList ?? [] };
     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) &&
+    const leaving = [...new Set([...replicated, ...stored])].filter((conversation) => !named.has(conversation) &&
         !alive.isCreating(conversation) &&
-        (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation, list)));
+        (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation, listing)));
     for (const conversation of named) {
         if (!replicated.has(conversation) &&
             missed(alive, conversation, reads.get(conversation), entries.get(conversation))) {
@@ -1088,6 +1151,17 @@ export async function catchUpConversations(alive, progress) {
     if (!alive.current())
         progress.complete = false;
 }
+export async function holdsSubmission(alive, operation) {
+    if (alive.sending(operation))
+        return true;
+    const local = await alive.deps.local();
+    for (const { conversation } of await local.chatDrafts()) {
+        const held = (await local.chatDraft(conversation))?.submitted;
+        if (held?.some((one) => one.operation === operation && one.turn === null) === true)
+            return true;
+    }
+    return false;
+}
 export async function resendConversations(alive, progress) {
     const local = await alive.deps.local();
     const tried = new Set();
@@ -1099,7 +1173,7 @@ export async function resendConversations(alive, progress) {
             if (alive.deps.closed())
                 return;
             tried.add(submission.operation);
-            const result = await dispatched(alive, conversation, submission);
+            const result = await dispatched(alive, conversation, submission, true);
             if (result.kind === 'revoked-authorization')
                 return;
             if (result.kind === 'transport-uncertainty') {
@@ -1119,23 +1193,25 @@ export function watchConversation(alive, conversation, options, deliver) {
     const { view, watcher } = alive.viewJoined(key, conversation, asked, deliver);
     const { held } = view;
     const reading = new AbortController();
-    void untilAnswered(() => alive.deps.durably(async (local) => {
+    void untilAnswered(retrying(alive.deps.retries, 'reading', `window ${key}`, () => 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({ dismissed: await dismissedIn(local, conversation) });
+        held.set({ pins: (await local.facts()).chatPins });
         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)
+    })), 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));
+        const now = held.now();
+        const shown = now.window ?? [];
+        const frame = sharedFrame(view, shown);
+        watcher.notify(viewOf(alive, conversation, shown, frame, now));
     })
         .catch(() => { });
     return () => {
@@ -1151,9 +1227,13 @@ export function watchConversationList(alive, deliver) {
 export function watchConversationAgents(alive, deliver) {
     alive.agentListeners.join(deliver);
     conversationsLearned(alive);
-    readAgents(alive);
     return () => alive.agentListeners.leave(deliver);
 }
+export function watchListedAgents(alive, deliver) {
+    alive.listedListeners.join(deliver);
+    conversationsLearned(alive);
+    return () => alive.listedListeners.leave(deliver);
+}
 export function conversationsChanged(alive, set) {
     for (const conversation of set.conversations)
         emit(alive, conversation);
@@ -1165,26 +1245,32 @@ export function receiveConversationEvent(alive, event) {
         if (event.whole)
             alive.relistBegun();
         if (alive.relisting())
-            alive.relistHeard(event.entries);
+            alive.relistHeard(event.entries, event.agents);
         if (event.more && alive.relisting())
             return;
         const whole = alive.relistTaken();
         listChanged(alive, {
             replacing: whole !== null,
-            set: whole === null ? event.entries : [...whole.values()],
+            set: whole === null ? event.entries : [...whole.conversations.values()],
+            agents: whole === null ? event.agents : [...whole.agents.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 });
+        alive.relistHeard([event.entry], []);
+        listChanged(alive, { replacing: false, set: [event.entry], agents: [], gone: null });
+        return;
+    }
+    if (event.kind === 'agent') {
+        alive.relistHeard([], [event.agent]);
+        listChanged(alive, { replacing: false, set: [], agents: [event.agent], gone: null });
         return;
     }
     if (event.kind === 'unlisted') {
         alive.relistDropped(event.conversation);
-        listChanged(alive, { replacing: false, set: [], gone: event.conversation });
+        listChanged(alive, { replacing: false, set: [], agents: [], gone: event.conversation });
         return;
     }
     heard(alive, event);