@agentshouse/mdruntime 0.1.0-cf04ede9fb796 → 0.1.0-cf0c43fc48aad

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 { 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,
     };
 }
 export const SESSION_STARTED = 'Session started';
 const NEW_CHAT = 'new:';
+const LISTING = 'listing';
+const AGENTS = 'agents';
+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) {
     const facts = alive.liveOf(conversation);
     return {
         conversation,
@@ -255,26 +227,39 @@ 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,
     };
 }
+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 { window, draft, ended, dismissed } = 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);
+        const frame = sharedFrame(view, window);
+        const value = viewOf(alive, conversation, window, frame, draft, ended, dismissed);
         for (const watcher of ready)
             watcher.notify(value);
     }
@@ -285,23 +270,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 });
@@ -399,7 +379,7 @@ function listChanged(alive, change) {
                 list.some(({ conversation }) => !replicated.has(conversation)))) {
             alive.deps.again();
         }
-    }, () => { });
+    }, uncaught);
 }
 function endedAnew(alive, list) {
     const entries = new Map(list.map((entry) => [entry.conversation, entry]));
@@ -415,7 +395,10 @@ function endedAnew(alive, list) {
 function shownList(alive, work) {
     const reading = heldList(alive);
     alive.inOrder(async () => {
-        const list = await reading.catch(() => null);
+        const list = await reading.catch((error) => {
+            uncaught(error);
+            return null;
+        });
         if (list === null || alive.deps.closed())
             return;
         work(list);
@@ -425,7 +408,7 @@ 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)
@@ -468,15 +451,24 @@ export function conversationsLearned(alive) {
     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);
+    const read = new Map((alive.held.now().listedAgents ?? []).map((one) => [one.agent, one]));
+    const named = new Map(read);
     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 }))
+        .map(([identity, agent]) => {
+        const held = read.get(identity);
+        return held === undefined
+            ? { identity, name: agent.name }
+            : {
+                identity,
+                name: agent.name,
+                cli: held.cli,
+                environment: structuredClone(held.environment),
+            };
+    })
         .sort((left, right) => left.name === right.name
         ? left.identity.localeCompare(right.identity)
         : left.name.localeCompare(right.name));
@@ -493,7 +485,7 @@ function readAgents(alive) {
         if (!alive.deps.online() || (!agentListeners.waiting() && !agentListeners.told())) {
             return 'done';
         }
-        const listed = await read();
+        const listed = await retrying(alive.deps.retries, 'conversations', AGENTS, read)();
         if (listed === null)
             return 'done';
         alive.held.set({ listedAgents: listed });
@@ -550,8 +542,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 +576,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);
@@ -634,7 +621,7 @@ function retiredDrafts(alive, list) {
             held.some(({ conversation }) => retiredChat(conversation, list))) {
             alive.deps.again();
         }
-    }, () => { });
+    }, uncaught);
 }
 function settleBehind(alive, list) {
     void alive.deps
@@ -660,21 +647,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 +771,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 +780,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 +798,8 @@ function heard(alive, event) {
         void keep(alive, conversation, arriving).catch((error) => {
             if (refusedForSpace(error))
                 alive.gapOpened(conversation);
+            else
+                uncaught(error);
         });
         return;
     }
@@ -817,19 +807,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 +858,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 +891,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 +902,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,8 +922,8 @@ 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) {
     return {
@@ -948,8 +944,7 @@ 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), (await local.chatDraft(conversation)) ?? null, await endedIn(alive, conversation), await dismissedIn(local, conversation)));
             });
         },
         async create(input) {
@@ -986,40 +981,88 @@ 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,
             });
         },
-        interrupt(conversation) {
-            return invoke(alive, 'conversations/interrupt', conversation);
+        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 });
         },
-        kill(conversation) {
-            return invoke(alive, 'conversations/kill', conversation);
+        option(conversation, option, value, operation) {
+            return invoke(alive, 'conversations/option/set', conversation, operation, { option, value });
         },
-        delete(conversation) {
-            return invoke(alive, 'conversations/delete', conversation);
+        retry(conversation, message, operation) {
+            return invoke(alive, 'conversations/retry', conversation, operation, {
+                message_id: message,
+            });
+        },
+        async pins() {
+            return (await (await alive.deps.local()).facts()).chatPins;
+        },
+        pin(figures) {
+            return alive.deps.durably((local) => local.fact('chatPins', [...figures]));
+        },
+        async openedTurns() {
+            return factOf(await alive.deps.local(), 'openedTurn');
+        },
+        openTurn(conversation, turn) {
+            return alive.deps.durably((local) => local.keepConversationFact({ conversation, name: 'openedTurn', value: turn }));
+        },
+        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
@@ -1039,9 +1082,9 @@ 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 }] = await Promise.all([
         local.conversations(),
-        local.chatDrafts(),
+        local.storedConversations(),
         local.facts(),
     ]);
     const list = conversationList ?? [];
@@ -1049,9 +1092,7 @@ export async function reconcileConversations(alive) {
     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)));
     for (const conversation of named) {
@@ -1088,6 +1129,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 +1151,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 +1171,24 @@ 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({ 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 { window, draft, ended, dismissed } = held.now();
         const shown = window ?? [];
-        watcher.notify(viewOf(alive, conversation, shown, sharedFrame(view, shown), draft, ended, marked));
+        const frame = sharedFrame(view, shown);
+        watcher.notify(viewOf(alive, conversation, shown, frame, draft, ended, dismissed));
     })
         .catch(() => { });
     return () => {

package/dist/declaration.d.ts

@@ -0,0 +1,10 @@
+import type { DiscoveredRoom, OperationScopes, PathRule, RoomDeclaration } from './adapter.js';
+export type WriteRefusal = {
+    readonly code: 'room-root' | 'provider-owned-path' | 'invalid-path' | `${keyof OperationScopes}-grant`;
+    readonly path: string;
+};
+export type WriteRule = (path: string, needs: readonly (keyof OperationScopes)[]) => WriteRefusal | null;
+export declare function declared({ locator: _locator, roomVersion: _roomVersion, ...declaration }: DiscoveredRoom): RoomDeclaration;
+export declare function sameDeclaration(left: RoomDeclaration, right: RoomDeclaration): boolean;
+export declare function writeRule({ operations, providerOwnedPaths, authoredPaths, }: Pick<RoomDeclaration, 'operations' | 'providerOwnedPaths' | 'authoredPaths'>, pathRule: PathRule, local: boolean): WriteRule;
+//# sourceMappingURL=declaration.d.ts.map