@fungi.computer/parakeet 0.0.1 → 0.2.0

package/dist/conversation.js

@@ -7,13 +7,15 @@ import { createParakeetInteractions, } from "./commands/interactions.js";
 import { CancelledError, useQueryClient, } from "@tanstack/react-query";
 import { atom, createStore, } from "jotai/vanilla";
 import { atomWithInfiniteQuery, atomWithMutation, atomWithQuery, } from "jotai-tanstack-query";
-import { createContext, useCallback, useContext, useEffect, useMemo, useSyncExternalStore, } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore, } from "react";
 import { buildDurableTimeline, buildTimelineTail, } from "./core/build-timeline.js";
 import { mergeCompactionNotices, mergeCompactions, mergeMessages, } from "./core/session-projection.js";
 import { sessionHistoryQueryOptions, sessionQueryOptions, } from "./core/session-query.js";
 import { sameSessionViewState, sessionActivityStatus, sessionViewState, } from "./core/session-view-state.js";
 import { isCancelledOutcome } from "./commands/run.js";
 import { reportFailure } from "./lib/failure.js";
+import { createQueuedRecall, } from "./core/queued-recall.js";
+import { draftJournal, } from "./core/draft-storage.js";
 const noMessages = Object.freeze([]);
 const noCompactions = Object.freeze([]);
 const noCompactionNotices = Object.freeze([]);
@@ -33,6 +35,18 @@ function errorMessage(cause) {
         ? cause.message
         : "Prompt admission failed";
 }
+/** A lost withdrawal response must not block a later reconnect from retrying it. */
+function boundWithdrawal(operation) {
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error("Request recovery timed out"));
+        }, 10_000);
+    });
+    return Promise.race([operation, deadline]).finally(() => {
+        clearTimeout(timer);
+    });
+}
 function observationCause(cause) {
     const message = cause instanceof Error && cause.message.trim().length > 0
         ? cause.message.trim()
@@ -70,19 +84,40 @@ function newestDurableCommandId(messages) {
     }
     return newest?.commandId;
 }
-function newestDurablePrompt(messages, commandId) {
-    const message = messages.find((candidate) => candidate.commandId === commandId && candidate.value.role === "user");
-    if (message?.value.role !== "user")
-        return undefined;
-    const content = message.value.content;
-    const text = Array.isArray(content)
-        ? content
-            .flatMap((part) => (part.type === "text" ? [part.text] : []))
-            .join("\n")
-        : content;
-    return text.trim() === "" ? undefined : text;
+function sameImageCargo(left, right) {
+    const images = left ?? [];
+    const originals = right ?? [];
+    return (images.length === originals.length &&
+        images.every((image, index) => {
+            const original = originals[index];
+            return (image.data === original?.data && image.mimeType === original.mimeType);
+        }));
 }
-function createConversationAtoms(session, queryClient, authorOf) {
+function acquireDraftStorage(supplied) {
+    if (supplied !== undefined)
+        return { status: "available", storage: supplied };
+    try {
+        const browser = globalThis;
+        const storage = browser.localStorage;
+        return storage === undefined
+            ? { status: "unavailable" }
+            : { status: "available", storage };
+    }
+    catch {
+        // An opaque-origin sandbox denies even reading the browser's getter.
+        return { status: "unavailable" };
+    }
+}
+function createConversationAtoms(session, queryClient, authorOf, interactions, draftStorage, draftScope, contributions, shown) {
+    const journal = draftJournal(draftScope, draftStorage.status === "available" ? draftStorage.storage : undefined);
+    const saved = journal.read();
+    let mounted = false;
+    const timers = new Map();
+    const recoveryReasons = new Map(saved.pending.map(({ requestId }) => [
+        requestId,
+        "Closed before confirmation",
+    ]));
+    const recovering = new Set();
     const queryAtom = atomWithQuery(() => sessionQueryOptions(session), () => queryClient);
     const snapshotAtom = atom((get) => get(queryAtom).data?.snapshot);
     const pinnedHistoryAtom = atom(undefined);
@@ -169,9 +204,31 @@ function createConversationAtoms(session, queryClient, authorOf) {
             ? pages
             : mergeCompactionNotices(mergeCompactionNotices(pages, pinned), live);
     });
-    const newestCommandAtom = atom((get) => get(queryAtom).data?.latestPrompt?.[0] ??
+    const newestCommandAtom = atom((get) => get(queryAtom).data?.latestPrompt?.commandId ??
         newestDurableCommandId(get(messagesAtom)));
     const pendingAtom = atom((get) => get(snapshotAtom)?.pending ?? noPending);
+    // Presentation only: owner snapshots and admission reconciliation stay intact.
+    const hiddenQueuedAtom = atom(new Set());
+    const cancellingQueuedAtom = atom(undefined);
+    const visiblePendingAtom = atom((get) => {
+        const pending = get(pendingAtom);
+        const hidden = get(hiddenQueuedAtom);
+        const prompts = pending.prompts.filter(({ commandId }) => !hidden.has(commandId));
+        return prompts.length === pending.prompts.length
+            ? pending
+            : {
+                ...pending,
+                prompts,
+                total: pending.total - (pending.prompts.length - prompts.length),
+            };
+    });
+    const reconcileQueuedCancellationAtom = atom(null, (get, set) => {
+        const hidden = get(hiddenQueuedAtom);
+        const pending = new Set(get(pendingAtom).prompts.map(({ commandId }) => commandId));
+        const retained = new Set([...hidden].filter((id) => id === get(cancellingQueuedAtom) || pending.has(id)));
+        if (retained.size !== hidden.size)
+            set(hiddenQueuedAtom, retained);
+    });
     const extensionsAtom = atom((get) => get(snapshotAtom)?.extensions ?? noSlots);
     let liveToolActivity;
     const toolActivityAtom = atom((get) => {
@@ -197,11 +254,128 @@ function createConversationAtoms(session, queryClient, authorOf) {
         const requestIds = get(promptRequestIdsAtom);
         return (commandId) => requestIds.get(commandId);
     });
-    const durableAtom = atom((get) => buildDurableTimeline(get(messagesAtom), get(compactionsAtom), get(toolActivityAtom), authorOf, get(requestIdOfAtom), get(compactionNoticesAtom)));
-    const draftAtom = atom("");
+    const durableAtom = atom((get) => {
+        const messages = get(messagesAtom);
+        const compactions = get(compactionsAtom);
+        const notices = get(compactionNoticesAtom);
+        const sequences = [
+            ...messages.map((message) => message.sequence),
+            ...compactions.map((marker) => marker.sequence),
+            ...notices.map((notice) => notice.sequence),
+        ];
+        const oldest = Math.min(...sequences);
+        const newest = Math.max(...sequences);
+        const positions = get(contributions).flatMap(({ value }) => value.timeline.cells.flatMap(({ afterSequence }) => afterSequence === undefined ||
+            (get(hasMoreHistoryAtom) && afterSequence < oldest) ||
+            (get(hasNewerHistoryAtom) && afterSequence > newest)
+            ? []
+            : [afterSequence]));
+        return buildDurableTimeline(messages, compactions, get(toolActivityAtom), authorOf, get(requestIdOfAtom), notices, positions, shown);
+    });
+    const draftAtom = atom(saved.draft);
+    const draftImagesAtom = atom(saved.images);
+    const draftDeliveryAtom = atom(saved.delivery);
+    const recallReservationAtom = atom(saved.recall);
+    const recallStateAtom = atom({ kind: "idle" });
+    let recallOwner;
     const draftRevisionAtom = atom(0);
-    const rawAdmissionsAtom = atom([]);
+    const rawAdmissionsAtom = atom(saved.pending.map((pending) => ({
+        ...pending,
+        status: "admitting",
+    })));
+    const persistAtom = atom(null, (get, _set, state) => {
+        // Unavailable storage is session-only, not a pretend durable journal.
+        // A supplied adapter's write failures still refuse durable operations.
+        if (draftStorage.status === "unavailable")
+            return;
+        journal.write({
+            draft: state?.draft ?? get(draftAtom),
+            images: state?.draftPayload === undefined
+                ? get(draftImagesAtom)
+                : state.draftPayload.images,
+            delivery: state?.draftPayload === undefined
+                ? get(draftDeliveryAtom)
+                : state.draftPayload.delivery,
+            recall: state?.recall === null
+                ? undefined
+                : (state?.recall ?? get(recallReservationAtom)),
+            pending: (state?.admissions ?? get(rawAdmissionsAtom))
+                .filter(({ status }) => status === "admitting")
+                .map(({ requestId, content, submittedDraft, delivery, images, restoreDraft, }) => ({
+                requestId,
+                content,
+                submittedDraft,
+                delivery,
+                images,
+                restoreDraft,
+            })),
+        });
+    });
+    const recallAtom = atom(null, (get, set) => {
+        if (get(cancellingQueuedAtom) !== undefined)
+            return Promise.resolve("ignored");
+        recallOwner ??= createQueuedRecall({
+            session: {
+                latestPending: () => session.latestPending(),
+                cancel: (input) => session.command({ type: "cancel", ...input }),
+            },
+            recovery: get(recallReservationAtom),
+            emptyDraftRevision: () => get(draftAtom) === "" && (get(draftImagesAtom)?.length ?? 0) === 0
+                ? get(draftRevisionAtom)
+                : undefined,
+            reserve: (prompt) => {
+                set(persistAtom, { recall: prompt });
+                set(recallReservationAtom, prompt);
+            },
+            forget: () => {
+                set(persistAtom, { recall: null });
+                set(recallReservationAtom, undefined);
+            },
+            restore: (prompt, revision) => {
+                if (get(draftRevisionAtom) !== revision ||
+                    get(draftAtom) !== "" ||
+                    (get(draftImagesAtom)?.length ?? 0) !== 0)
+                    return false;
+                set(persistAtom, {
+                    draft: prompt.text,
+                    draftPayload: { images: prompt.images, delivery: prompt.delivery },
+                    recall: null,
+                });
+                set(recallReservationAtom, undefined);
+                set(draftImagesAtom, prompt.images);
+                set(draftDeliveryAtom, prompt.delivery);
+                set(draftAtom, prompt.text);
+                set(draftRevisionAtom, (current) => current + 1);
+                return true;
+            },
+            onState: (state) => {
+                set(recallStateAtom, state);
+                if (state.kind === "too_late" || state.kind === "uncertain")
+                    interactions.toast({ variant: "warning", message: state.message });
+            },
+        });
+        return recallOwner.recall();
+    });
     const latestSubmissionIdAtom = atom(undefined);
+    const checkpointDraftAtom = atom(null, (_get, set) => {
+        if (!mounted)
+            return {
+                status: "failed",
+                reason: "Conversation is no longer mounted",
+            };
+        if (draftStorage.status === "unavailable")
+            return {
+                status: "failed",
+                reason: "Durable draft storage is unavailable",
+            };
+        try {
+            set(persistAtom);
+            return { status: "saved" };
+        }
+        catch (cause) {
+            return { status: "failed", reason: errorMessage(cause) };
+        }
+    });
     const observedCommandIdsAtom = atom((get) => new Set([
         ...get(durableAtom).commandIds,
         ...get(pendingAtom).prompts.map(({ commandId }) => commandId),
@@ -217,41 +391,127 @@ function createConversationAtoms(session, queryClient, authorOf) {
     /** Retire a successful local admission only after owner identity is observed. */
     const reconcileAdmissionsAtom = atom(null, (get, set) => {
         const knownCommandIds = get(observedCommandIdsAtom);
+        const observedRequests = new Map([
+            // Recorded replies have no command: their accepted receipt names the
+            // durable entry, not model admission or cancellation.
+            ...get(messagesAtom).flatMap(({ id, requestId, commandId }) => requestId === undefined ? [] : [[requestId, commandId ?? id]]),
+            ...get(pendingAtom).prompts.map(({ requestId, commandId }) => [requestId, commandId]),
+        ]);
+        for (const candidate of get(rawAdmissionsAtom)) {
+            const commandId = observedRequests.get(candidate.requestId);
+            if (commandId !== undefined) {
+                set(promptRequestIdsAtom, (current) => new Map(current).set(commandId, candidate.requestId));
+            }
+        }
         set(rawAdmissionsAtom, (current) => {
-            const unresolved = current.filter(({ status, commandId }) => status !== "accepted" ||
-                commandId === undefined ||
-                !knownCommandIds.has(commandId));
+            const unresolved = current.filter(({ requestId, status, commandId }) => !observedRequests.has(requestId) &&
+                (status !== "accepted" ||
+                    commandId === undefined ||
+                    !knownCommandIds.has(commandId)));
+            if (unresolved.length !== current.length) {
+                try {
+                    set(persistAtom, { admissions: unresolved });
+                }
+                catch (cause) {
+                    reportFailure("save reconciled draft", cause);
+                }
+            }
             return unresolved.length === current.length ? current : unresolved;
         });
     });
     const admissionErrorAtom = atom(undefined);
     const setDraftAtom = atom(null, (get, set, value) => {
+        try {
+            set(persistAtom, { draft: value });
+        }
+        catch (cause) {
+            reportFailure("save current draft", cause);
+            interactions.toast({
+                variant: "error",
+                message: `Draft not saved: ${errorMessage(cause)}`,
+            });
+        }
         if (get(draftAtom) !== value)
             set(draftRevisionAtom, (revision) => revision + 1);
         set(draftAtom, value);
         set(admissionErrorAtom, undefined);
     });
-    /** The one owner of "clear the draft after submit" for prompts and commands. */
+    /** Consume only the exact draft a command submitted. */
     const clearSubmittedDraftAtom = atom(null, (get, set, submitted) => {
-        if (get(draftRevisionAtom) !== submitted.revision)
+        if (get(draftRevisionAtom) !== submitted.revision ||
+            get(draftAtom) !== submitted.draft)
             return;
-        set(draftAtom, (current) => (current === submitted.draft ? "" : current));
+        set(persistAtom, { draft: "" });
+        set(draftAtom, "");
     });
     const abortAtom = atomWithMutation(() => ({
         mutationFn: (commandId) => session.command({ type: "cancel", commandId }),
     }), () => queryClient);
+    // One unresolved queued gesture per mounted conversation, like Recall.
+    // Accepted masks last only while that identity remains in the bounded owner
+    // pending page; stale pre-ack snapshots cannot resurrect the removed row.
+    let queuedCancellation;
+    const cancelQueuedAtom = atom(null, (get, set, commandId) => {
+        if (!mounted || get(recallStateAtom).kind === "recalling")
+            return Promise.resolve();
+        if (queuedCancellation !== undefined)
+            return queuedCancellation;
+        if (get(hiddenQueuedAtom).has(commandId) ||
+            !get(pendingAtom).prompts.some((prompt) => prompt.commandId === commandId))
+            return Promise.resolve();
+        set(hiddenQueuedAtom, new Set(get(hiddenQueuedAtom)).add(commandId));
+        set(cancellingQueuedAtom, commandId);
+        const reveal = () => {
+            const next = new Set(get(hiddenQueuedAtom));
+            next.delete(commandId);
+            set(hiddenQueuedAtom, next);
+        };
+        const operation = Promise.resolve()
+            .then(() => session.command({ type: "cancel", commandId, onlyIfPending: true }))
+            .then((result) => {
+            if (!mounted)
+                return;
+            if (result.status === "too_late") {
+                reveal();
+                interactions.toast({
+                    variant: "warning",
+                    message: "Couldn't remove that message: it is no longer pending.",
+                });
+            }
+        }, () => {
+            if (!mounted)
+                return;
+            reveal();
+            interactions.toast({
+                variant: "warning",
+                message: "Cancellation unconfirmed. That message may still run. Try again or reconnect.",
+            });
+        })
+            .finally(() => {
+            queuedCancellation = undefined;
+            if (!mounted)
+                return;
+            set(cancellingQueuedAtom, undefined);
+            set(reconcileQueuedCancellationAtom);
+        });
+        queuedCancellation = operation;
+        return operation;
+    });
     const tailAtom = atom((get) => {
         if (get(hasNewerHistoryAtom))
             return [];
         const snapshot = get(snapshotAtom);
-        const pending = get(pendingAtom);
-        return buildTimelineTail(get(durableAtom), snapshot?.progress ?? null, pending.prompts, get(admissionsAtom), authorOf, get(requestIdOfAtom));
+        const pending = get(visiblePendingAtom);
+        return buildTimelineTail(get(durableAtom), snapshot?.progress ?? null, pending.prompts, get(admissionsAtom), authorOf);
     });
     const timelineAtom = atom((get) => {
         const durable = get(durableAtom);
         const base = {
             pendingHasMore: get(pendingAtom).hasMore,
-            queued: get(pendingAtom),
+            queued: get(visiblePendingAtom),
+            cancellingQueued: get(cancellingQueuedAtom) !== undefined ||
+                get(recallStateAtom).kind === "recalling",
+            positionAnchors: durable.positionAnchors,
             commandAnchors: durable.commandAnchors,
             hasMoreHistory: get(hasMoreHistoryAtom),
             hasNewerHistory: get(hasNewerHistoryAtom),
@@ -336,21 +596,43 @@ function createConversationAtoms(session, queryClient, authorOf) {
         ownerView = next;
         return next;
     });
-    const dispatchAdmissionAtom = atom(null, (get, set, admission) => {
-        void session
-            .command({
+    const dispatchAdmissionAtom = atom(null, (get, set, { admission, consumeDraft, }) => {
+        try {
+            set(persistAtom, consumeDraft
+                ? { draft: "", draftPayload: {} }
+                : { draft: get(draftAtom) });
+        }
+        catch (cause) {
+            reportFailure("save pending draft before send", cause);
+            set(rawAdmissionsAtom, (current) => current.filter(({ requestId }) => requestId !== admission.requestId));
+            interactions.toast({
+                variant: "error",
+                message: `Not sent: ${errorMessage(cause)}`,
+            });
+            return;
+        }
+        if (consumeDraft) {
+            set(draftImagesAtom, undefined);
+            set(draftDeliveryAtom, undefined);
+            set(setDraftAtom, "");
+        }
+        const prompt = {
             type: "prompt",
             text: admission.content,
             requestId: admission.requestId,
             delivery: admission.delivery,
-        })
+        };
+        void session
+            .command(admission.images === undefined
+            ? prompt
+            : { ...prompt, images: admission.images })
             .then((accepted) => {
+            if (!mounted ||
+                !get(rawAdmissionsAtom).some(({ requestId, status }) => requestId === admission.requestId && status === "admitting"))
+                return;
             if (accepted.status === "recorded") {
                 set(rawAdmissionsAtom, (current) => current.filter((candidate) => candidate.requestId !== admission.requestId));
-                set(clearSubmittedDraftAtom, {
-                    draft: admission.submittedDraft,
-                    revision: admission.submittedDraftRevision,
-                });
+                set(persistAtom);
                 return;
             }
             set(promptRequestIdsAtom, (current) => new Map(current).set(accepted.commandId, admission.requestId));
@@ -358,48 +640,139 @@ function createConversationAtoms(session, queryClient, authorOf) {
                 ? {
                     requestId: candidate.requestId,
                     content: candidate.content,
+                    images: candidate.images,
                     submittedDraft: candidate.submittedDraft,
-                    submittedDraftRevision: candidate.submittedDraftRevision,
+                    restoreDraft: candidate.restoreDraft,
                     delivery: candidate.delivery,
                     commandId: accepted.commandId,
                     status: "accepted",
                 }
                 : candidate));
-            const admissions = get(rawAdmissionsAtom);
-            const admissionIndex = admissions.findIndex((candidate) => candidate.requestId === admission.requestId);
-            const hasNewerMatchingAdmission = admissions
-                .slice(admissionIndex + 1)
-                .some((candidate) => candidate.status === "admitting" &&
-                candidate.submittedDraft === admission.submittedDraft);
             set(reconcileAdmissionsAtom);
-            if (!hasNewerMatchingAdmission)
-                set(clearSubmittedDraftAtom, {
-                    draft: admission.submittedDraft,
-                    revision: admission.submittedDraftRevision,
-                });
+            set(persistAtom);
         })
             .catch((cause) => {
-            set(rawAdmissionsAtom, (current) => current.map((candidate) => candidate.requestId === admission.requestId
-                ? {
-                    ...candidate,
-                    status: "failed",
-                    error: errorMessage(cause),
-                }
-                : candidate));
+            if (!mounted)
+                return;
+            recoveryReasons.set(admission.requestId, errorMessage(cause));
+            set(recoverAdmissionsAtom);
         });
     });
+    const recoverAdmissionsAtom = atom(null, (get, set) => {
+        if (!mounted)
+            return;
+        for (const admission of get(rawAdmissionsAtom)) {
+            const reason = recoveryReasons.get(admission.requestId);
+            if (admission.status !== "admitting" ||
+                reason === undefined ||
+                recovering.has(admission.requestId))
+                continue;
+            recovering.add(admission.requestId);
+            void boundWithdrawal(session.withdraw(admission.requestId))
+                .then((resolution) => {
+                if (!mounted ||
+                    !get(rawAdmissionsAtom).some(({ requestId, status }) => requestId === admission.requestId && status === "admitting"))
+                    return;
+                if (resolution.status === "accepted") {
+                    set(promptRequestIdsAtom, (current) => new Map(current).set(resolution.commandId, admission.requestId));
+                    set(rawAdmissionsAtom, (current) => current.map((candidate) => candidate.requestId === admission.requestId
+                        ? {
+                            ...candidate,
+                            status: "accepted",
+                            commandId: resolution.commandId,
+                        }
+                        : candidate));
+                    set(persistAtom);
+                    set(reconcileAdmissionsAtom);
+                    return;
+                }
+                const currentDraft = get(draftAtom);
+                const restored = !admission.restoreDraft
+                    ? currentDraft
+                    : currentDraft === ""
+                        ? admission.submittedDraft
+                        : `${currentDraft}\n\n${admission.submittedDraft}`;
+                const failed = get(rawAdmissionsAtom).map((candidate) => candidate.requestId === admission.requestId
+                    ? { ...candidate, status: "failed", error: reason }
+                    : candidate);
+                // Commit restoration and removal of the pending record in ONE replacement.
+                const restoredImages = admission.restoreDraft
+                    ? [...(get(draftImagesAtom) ?? []), ...(admission.images ?? [])]
+                    : get(draftImagesAtom);
+                set(persistAtom, {
+                    draft: restored,
+                    draftPayload: {
+                        images: restoredImages,
+                        delivery: get(draftDeliveryAtom),
+                    },
+                    admissions: failed,
+                });
+                set(draftImagesAtom, restoredImages);
+                set(rawAdmissionsAtom, failed);
+                set(setDraftAtom, restored);
+                interactions.toast({
+                    variant: "error",
+                    message: `Not sent: ${reason}`,
+                });
+            })
+                .catch((cause) => {
+                if (mounted)
+                    interactions.toast({
+                        variant: "error",
+                        message: `Send outcome unconfirmed; draft saved: ${errorMessage(cause)}`,
+                    });
+            })
+                .finally(() => {
+                recovering.delete(admission.requestId);
+            });
+        }
+    });
+    const maintainRecoveryAtom = atom(null, (get, set) => {
+        const observation = get(observationAtom).status;
+        const admissions = get(rawAdmissionsAtom);
+        for (const [id, timer] of timers) {
+            if (!admissions.some(({ requestId, status }) => requestId === id && status === "admitting")) {
+                clearTimeout(timer);
+                timers.delete(id);
+                recoveryReasons.delete(id);
+            }
+        }
+        for (const admission of admissions) {
+            if (admission.status !== "admitting")
+                continue;
+            if (observation === "unavailable")
+                recoveryReasons.set(admission.requestId, "Disconnected");
+            if (!timers.has(admission.requestId)) {
+                timers.set(admission.requestId, setTimeout(() => {
+                    recoveryReasons.set(admission.requestId, "Send confirmation timed out");
+                    set(recoverAdmissionsAtom);
+                }, 30_000));
+            }
+        }
+        if (observation === "live" || observation === "unavailable")
+            set(recoverAdmissionsAtom);
+    });
+    const mountRecoveryAtom = atom(null, (_get, set) => {
+        mounted = true;
+        set(recallStateAtom, { kind: "idle" });
+        set(maintainRecoveryAtom);
+        return () => {
+            mounted = false;
+            recallOwner?.dispose();
+            recallOwner = undefined;
+            for (const timer of timers.values())
+                clearTimeout(timer);
+            timers.clear();
+        };
+    });
     const sendAtom = atom(null, (get, set, delivery = "steer") => {
         const draft = get(draftAtom);
-        const content = draft.trim();
-        if (content === "")
+        const content = draft;
+        if (get(recallStateAtom).kind === "recalling")
             return;
-        const admissions = get(admissionsAtom);
-        const draftRevision = get(draftRevisionAtom);
-        const rawAdmissions = get(rawAdmissionsAtom);
-        if (rawAdmissions.some((admission) => admission.status === "admitting" &&
-            admission.submittedDraft === draft &&
-            admission.submittedDraftRevision === draftRevision))
+        if (content.trim() === "" && (get(draftImagesAtom)?.length ?? 0) === 0)
             return;
+        const admissions = get(admissionsAtom);
         const unresolved = admissions.filter(({ status }) => status !== "failed");
         if (unresolved.length >= MAX_UNRESOLVED_LOCAL_ADMISSIONS) {
             set(admissionErrorAtom, "queue_full");
@@ -407,23 +780,26 @@ function createConversationAtoms(session, queryClient, authorOf) {
         }
         const admission = {
             content,
-            delivery,
+            delivery: get(draftDeliveryAtom) ?? delivery,
+            images: get(draftImagesAtom),
             requestId: nanoid(),
             submittedDraft: draft,
-            submittedDraftRevision: draftRevision,
+            restoreDraft: true,
             status: "admitting",
         };
         set(rawAdmissionsAtom, [...admissions, admission]);
         set(latestSubmissionIdAtom, admission.requestId);
         set(admissionErrorAtom, undefined);
-        set(dispatchAdmissionAtom, admission);
+        set(dispatchAdmissionAtom, { admission, consumeDraft: true });
     });
     const submitCommandAtom = atom(null, async (get, set, run) => {
         const submitted = {
             draft: get(draftAtom),
             revision: get(draftRevisionAtom),
         };
-        const outcome = await run(submitted.draft);
+        const outcome = await run(submitted.draft, () => {
+            set(clearSubmittedDraftAtom, submitted);
+        });
         if (outcome?.status === "handled" && !isCancelledOutcome(outcome))
             set(clearSubmittedDraftAtom, submitted);
         return outcome;
@@ -433,12 +809,15 @@ function createConversationAtoms(session, queryClient, authorOf) {
         if (get(failureAtom) === "interrupted" || get(failureAtom) === "failed") {
             const snapshot = get(snapshotAtom);
             const commandId = get(newestCommandAtom);
-            if (snapshot === undefined || commandId === undefined)
-                return;
-            const content = newestDurablePrompt(snapshot.messages, commandId) ??
-                get(queryAtom).data?.latestPrompt?.[1];
-            if (content === undefined)
+            const prompt = get(queryAtom).data?.latestPrompt;
+            if (snapshot === undefined ||
+                prompt === undefined ||
+                prompt.commandId !== commandId)
                 return;
+            const content = prompt.text;
+            // Equal text alone does not make a newer image draft the failed prompt.
+            const consumeDraft = get(draftAtom) === content &&
+                sameImageCargo(get(draftImagesAtom), prompt.images);
             if (admissions.filter(({ status }) => status !== "failed").length >=
                 MAX_UNRESOLVED_LOCAL_ADMISSIONS) {
                 set(admissionErrorAtom, "queue_full");
@@ -446,16 +825,20 @@ function createConversationAtoms(session, queryClient, authorOf) {
             }
             const retry = {
                 content,
+                images: prompt.images,
                 delivery: "followUp",
                 requestId: nanoid(),
                 submittedDraft: content,
-                submittedDraftRevision: get(draftRevisionAtom),
+                restoreDraft: consumeDraft,
                 status: "admitting",
             };
             set(rawAdmissionsAtom, [...get(rawAdmissionsAtom), retry]);
             set(latestSubmissionIdAtom, retry.requestId);
             set(admissionErrorAtom, undefined);
-            set(dispatchAdmissionAtom, retry);
+            set(dispatchAdmissionAtom, {
+                admission: retry,
+                consumeDraft,
+            });
             return;
         }
         const admission = admissions
@@ -468,18 +851,24 @@ function createConversationAtoms(session, queryClient, authorOf) {
             set(admissionErrorAtom, "queue_full");
             return;
         }
+        const consumeDraft = get(draftAtom) === admission.submittedDraft &&
+            sameImageCargo(get(draftImagesAtom), admission.images);
         const retry = {
             content: admission.content,
             delivery: admission.delivery,
-            requestId: admission.requestId,
+            images: admission.images,
+            requestId: nanoid(),
             submittedDraft: admission.submittedDraft,
-            submittedDraftRevision: admission.submittedDraftRevision,
+            restoreDraft: consumeDraft,
             status: "admitting",
         };
         set(rawAdmissionsAtom, (current) => current.map((candidate) => candidate.requestId === admission.requestId ? retry : candidate));
         set(latestSubmissionIdAtom, retry.requestId);
         set(admissionErrorAtom, undefined);
-        set(dispatchAdmissionAtom, retry);
+        set(dispatchAdmissionAtom, {
+            admission: retry,
+            consumeDraft,
+        });
     });
     const dismissFailedAtom = atom(null, (get, set, requestId) => {
         const admissions = get(rawAdmissionsAtom);
@@ -556,9 +945,16 @@ function createConversationAtoms(session, queryClient, authorOf) {
                     inspect();
             });
             const timeout = setTimeout(() => {
-                finish({
-                    kind: "failed",
-                    cause: "Session history did not reopen within 10 seconds",
+                // Streamed "opening" updates also replace TanStack's revert state.
+                // Cancel first, then record this real timeout on the existing query
+                // without replacing its last coherent snapshot.
+                void query.cancel({ revert: true }).then(() => {
+                    const cause = "Session history did not reopen within 10 seconds";
+                    query.setState({ status: "error", error: new Error(cause) });
+                    finish({
+                        kind: "failed",
+                        cause,
+                    });
                 });
             }, 10_000);
             // A live stream does not settle its refetch promise until the watch closes.
@@ -576,12 +972,18 @@ function createConversationAtoms(session, queryClient, authorOf) {
         return reconnecting;
     });
     return {
+        cancelQueuedAtom,
+        reconcileQueuedCancellationAtom,
         abortAtom,
+        draftImagesAtom,
+        recallStateAtom,
+        recallAtom,
         commandIdAtom,
         contextAtom,
         admissionErrorAtom,
         admissionsAtom,
         cancelAtom,
+        checkpointDraftAtom,
         draftAtom,
         dismissFailedAtom,
         extensionsAtom,
@@ -591,6 +993,9 @@ function createConversationAtoms(session, queryClient, authorOf) {
         loadNewerHistoryAtom,
         observationAtom,
         observedCommandIdsAtom,
+        rawAdmissionsAtom,
+        maintainRecoveryAtom,
+        mountRecoveryAtom,
         pinVisibleHistoryAtom,
         queryAtom,
         reconcileAdmissionsAtom,
@@ -623,15 +1028,71 @@ function useStoreSetter(atom) {
     return useCallback((...args) => store.set(atom, ...args), [atom, store]);
 }
 /** Own one renderer-neutral conversation scope over the existing query cache. */
-export function ParakeetProvider({ children, session, clients = noClients, interactionStore, authorOf = noAuthor, }) {
+export function ParakeetProvider({ children, session, clients = noClients, interactionStore, authorOf = noAuthor, onToast, draftStorage, draftIdentity, }) {
     const queryClient = useQueryClient();
-    const scope = useMemo(() => ({
-        atoms: createConversationAtoms(session, queryClient, authorOf),
+    const acquiredDraftStorage = useMemo(() => acquireDraftStorage(draftStorage), [draftStorage]);
+    const draftScope = draftIdentity === undefined
+        ? session.address
+        : JSON.stringify([draftIdentity.agentId, draftIdentity.sessionId]);
+    const footerPromptOwners = useMemo(() => new Set(clients
+        .filter((entry) => entry.promptPresentation === "footer")
+        .map((entry) => entry.id)), [clients]);
+    const scope = useMemo(() => {
+        const interactions = interactionStore ?? createParakeetInteractions();
+        const contributions = atom(noContributions);
+        const shown = (item) => item.kind !== "user_message" ||
+            item.origin === undefined ||
+            !footerPromptOwners.has(item.origin.extensionId);
+        return {
+            atoms: createConversationAtoms(session, queryClient, authorOf, interactions, acquiredDraftStorage, draftScope, contributions, shown),
+            session,
+            store: createStore(),
+            contributions,
+            interactions,
+            shown,
+        };
+    }, [
+        queryClient,
         session,
-        store: createStore(),
-        contributions: atom(noContributions),
-        interactions: interactionStore ?? createParakeetInteractions(),
-    }), [queryClient, session, interactionStore, authorOf]);
+        interactionStore,
+        authorOf,
+        footerPromptOwners,
+        acquiredDraftStorage,
+        draftScope,
+    ]);
+    useEffect(() => {
+        const update = () => {
+            scope.store.set(scope.atoms.maintainRecoveryAtom);
+        };
+        const unobserve = scope.store.sub(scope.atoms.observationAtom, update);
+        const unobserveAdmissions = scope.store.sub(scope.atoms.rawAdmissionsAtom, update);
+        const dispose = scope.store.set(scope.atoms.mountRecoveryAtom);
+        return () => {
+            dispose();
+            unobserve();
+            unobserveAdmissions();
+        };
+    }, [scope]);
+    useEffect(() => {
+        if (onToast === undefined)
+            return undefined;
+        return scope.interactions.subscribeToasts(onToast);
+    }, [scope, onToast]);
+    useEffect(() => {
+        if (acquiredDraftStorage.status === "unavailable")
+            scope.interactions.report({
+                tone: "info",
+                message: "Drafts are session-only because browser storage is unavailable. They will be lost when this conversation closes.",
+            });
+    }, [scope, acquiredDraftStorage]);
+    useEffect(() => {
+        const reconcile = () => {
+            scope.store.set(scope.atoms.reconcileQueuedCancellationAtom);
+        };
+        const unsubscribe = scope.store.sub(scope.atoms.snapshotAtom, reconcile);
+        reconcile();
+        return unsubscribe;
+    }, [scope]);
     useEffect(() => {
         // The live page is bounded: after a later reset an observed command may no
         // longer be present. Retire its local row once, not just while it is visible.
@@ -674,21 +1135,52 @@ export function useTimeline() {
     const loadNewerHistory = useStoreSetter(atoms.loadNewerHistoryAtom);
     const jumpToLatest = useStoreSetter(atoms.jumpToLatestAtom);
     const pinVisibleHistory = useStoreSetter(atoms.pinVisibleHistoryAtom);
+    const cancelQueued = useStoreSetter(atoms.cancelQueuedAtom);
+    const { shown } = useConversationScope();
+    // View-only: stored prompts, queue counts and fork stay as loaded.
+    const settled = useMemo(() => base.settled.filter(shown), [base.settled, shown]);
+    const tail = useMemo(() => base.tail.filter(shown), [base.tail, shown]);
+    const view = useMemo(() => ({ ...base, settled, tail }), [base, settled, tail]);
+    const hidingOnly = view.settled.length + view.tail.length === 0 &&
+        base.settled.length + base.tail.length > 0;
+    const needsOlder = hidingOnly && base.hasMoreHistory && !base.loadingOlderHistory;
+    // One automatic request per loaded page: a failed fetch leaves the page
+    // unchanged, so it is not retried until the reader scrolls up.
+    const pageKey = `${base.settled[0]?.id ?? ""}:${String(base.settled.length)}`;
+    const requestedPage = useRef(undefined);
+    useEffect(() => {
+        if (!needsOlder || requestedPage.current === pageKey)
+            return;
+        requestedPage.current = pageKey;
+        loadOlderHistory();
+    }, [needsOlder, pageKey, loadOlderHistory]);
     return useMemo(() => ({
-        ...base,
+        ...view,
+        cancelQueued,
         jumpToLatest,
         loadNewerHistory,
         loadOlderHistory,
         pinVisibleHistory,
-    }), [base, jumpToLatest, loadNewerHistory, loadOlderHistory, pinVisibleHistory]);
+    }), [
+        view,
+        cancelQueued,
+        jumpToLatest,
+        loadNewerHistory,
+        loadOlderHistory,
+        pinVisibleHistory,
+    ]);
 }
 /** Read and mutate the current conversation draft and prompt. */
 export function useComposer() {
     const { atoms } = useConversationScope();
     const draft = useStoreAtom(atoms.draftAtom);
+    const images = useStoreAtom(atoms.draftImagesAtom);
+    const recallState = useStoreAtom(atoms.recallStateAtom);
+    const recall = useStoreSetter(atoms.recallAtom);
     const failure = useStoreAtom(atoms.failureAtom);
     const admissionError = useStoreAtom(atoms.admissionErrorAtom);
     const setDraft = useStoreSetter(atoms.setDraftAtom);
+    const checkpointDraft = useStoreSetter(atoms.checkpointDraftAtom);
     const send = useStoreSetter(atoms.sendAtom);
     const submitCommand = useStoreSetter(atoms.submitCommandAtom);
     const retry = useStoreSetter(atoms.retryAtom);
@@ -700,7 +1192,11 @@ export function useComposer() {
     return useMemo(() => ({
         admissionError,
         cancel,
+        checkpointDraft,
         draft,
+        images,
+        recall,
+        recallState,
         dismissFailed,
         failure,
         retry: retryLatest,
@@ -710,7 +1206,11 @@ export function useComposer() {
     }), [
         admissionError,
         cancel,
+        checkpointDraft,
         draft,
+        images,
+        recall,
+        recallState,
         dismissFailed,
         failure,
         retryLatest,