@fungi.computer/parakeet 0.1.0 → 0.2.1

package/dist/core/session-query.d.ts

@@ -1,4 +1,4 @@
-import type { SessionSnapshot } from "@fungi.computer/shiitake/client";
+import type { SessionSnapshot, PromptCommand } from "@fungi.computer/shiitake/client";
 import { type QueryClient } from "@tanstack/react-query";
 import type { ParakeetSession } from "../session.js";
 /** One shared TanStack observation keyed by Shiitake's logical Session address. */
@@ -7,36 +7,75 @@ export declare function sessionQueryOptions(session: ParakeetSession): import("@
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
-    /** One retryable user prompt survives live-page refreshes. */
-    latestPrompt: readonly [commandId: string, text: string] | undefined;
+    /** One retryable user prompt, including image cargo, survives page refreshes. */
+    latestPrompt: Readonly<{
+        /** Owner-issued identity of the original prompt command. */
+        commandId: string;
+        /** Original user text, including an empty image-only prompt body. */
+        text: string;
+        /** Original image content retained for a fresh retry admission. */
+        images: PromptCommand["images"];
+    }> | undefined;
 }>, Error, Readonly<{
     /** Whether the current watch has supplied a fresh owner baseline. */
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
-    /** One retryable user prompt survives live-page refreshes. */
-    latestPrompt: readonly [commandId: string, text: string] | undefined;
+    /** One retryable user prompt, including image cargo, survives page refreshes. */
+    latestPrompt: Readonly<{
+        /** Owner-issued identity of the original prompt command. */
+        commandId: string;
+        /** Original user text, including an empty image-only prompt body. */
+        text: string;
+        /** Original image content retained for a fresh retry admission. */
+        images: PromptCommand["images"];
+    }> | undefined;
 }>, readonly ["shiitake-session", string]>, "queryFn"> & {
     queryFn?: import("@tanstack/react-query").QueryFunction<Readonly<{
         /** Whether the current watch has supplied a fresh owner baseline. */
         observation: "connecting" | "live";
         /** Last coherent durable Session state, absent before the first snapshot. */
         snapshot: SessionSnapshot | undefined;
-        /** One retryable user prompt survives live-page refreshes. */
-        latestPrompt: readonly [commandId: string, text: string] | undefined;
+        /** One retryable user prompt, including image cargo, survives page refreshes. */
+        latestPrompt: Readonly<{
+            /** Owner-issued identity of the original prompt command. */
+            commandId: string;
+            /** Original user text, including an empty image-only prompt body. */
+            text: string;
+            /** Original image content retained for a fresh retry admission. */
+            images: PromptCommand["images"];
+        }> | undefined;
     }>, readonly ["shiitake-session", string], never>;
 } & import("@tanstack/react-query").QueryKeyWithDataTag<readonly ["shiitake-session", string], Readonly<{
     /** Whether the current watch has supplied a fresh owner baseline. */
     observation: "connecting" | "live";
     /** Last coherent durable Session state, absent before the first snapshot. */
     snapshot: SessionSnapshot | undefined;
-    /** One retryable user prompt survives live-page refreshes. */
-    latestPrompt: readonly [commandId: string, text: string] | undefined;
+    /** One retryable user prompt, including image cargo, survives page refreshes. */
+    latestPrompt: Readonly<{
+        /** Owner-issued identity of the original prompt command. */
+        commandId: string;
+        /** Original user text, including an empty image-only prompt body. */
+        text: string;
+        /** Original image content retained for a fresh retry admission. */
+        images: PromptCommand["images"];
+    }> | undefined;
 }>, Error>;
 /** Seed the shared observation with a bounded read before its watch mounts. */
 export declare function seedSessionQuery(queryClient: QueryClient, session: ParakeetSession, snapshot: SessionSnapshot): void;
-/** Borrow activity from the existing cache without starting another watch. */
-export declare function subscribeSessionActivity(queryClient: QueryClient, session: ParakeetSession, listener: (activity: "idle" | "working" | "unknown") => void): () => void;
+/** Observed Session activity; `header` is only an attention item's short heading. */
+export type SessionActivity = Readonly<{
+    /** The Session's observed activity. */
+    state: "idle" | "working" | "blocked" | "unknown";
+    /** Present when blocked by attention items: their short headings only. */
+    header?: string;
+}>;
+/**
+ * Borrow activity from the existing cache without starting another watch.
+ * An open attention item (such as an unanswered question) reports `blocked`
+ * ahead of working and idle; the header comes only from the question extension.
+ */
+export declare function subscribeSessionActivity(queryClient: QueryClient, session: ParakeetSession, listener: (activity: SessionActivity) => void, questionExtensionId: string | undefined): () => void;
 /** Shared, demand-loaded history; the live watch remains a separate small tail. */
 export declare function sessionHistoryQueryOptions(session: ParakeetSession, before?: string | null): import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseInfiniteQueryOptions<Readonly<{
     sessionId: string;
@@ -51,6 +90,7 @@ export declare function sessionHistoryQueryOptions(session: ParakeetSession, bef
     pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
     activity: import("@fungi.computer/shiitake/client").SessionActivity;
     progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+    toolOutput: readonly import("@fungi.computer/shiitake/client").SessionToolOutput[];
     extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
     attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
     context?: import("@fungi.computer/shiitake/client").SessionContext;
@@ -68,6 +108,7 @@ export declare function sessionHistoryQueryOptions(session: ParakeetSession, bef
         pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
         activity: import("@fungi.computer/shiitake/client").SessionActivity;
         progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+        toolOutput: readonly import("@fungi.computer/shiitake/client").SessionToolOutput[];
         extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
         attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
         context?: import("@fungi.computer/shiitake/client").SessionContext;
@@ -91,6 +132,7 @@ export declare function sessionHistoryQueryOptions(session: ParakeetSession, bef
         pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
         activity: import("@fungi.computer/shiitake/client").SessionActivity;
         progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+        toolOutput: readonly import("@fungi.computer/shiitake/client").SessionToolOutput[];
         extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
         attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
         context?: import("@fungi.computer/shiitake/client").SessionContext;
@@ -112,6 +154,7 @@ export declare function sessionHistoryQueryOptions(session: ParakeetSession, bef
     pending: import("@fungi.computer/shiitake/client").SessionPendingPrompts;
     activity: import("@fungi.computer/shiitake/client").SessionActivity;
     progress: import("@fungi.computer/shiitake/client").SessionProgress | null;
+    toolOutput: readonly import("@fungi.computer/shiitake/client").SessionToolOutput[];
     extensions: import("@fungi.computer/shiitake/client").SessionExtensionSlots;
     attention: readonly import("@fungi.computer/shiitake/client").SessionAttention[];
     context?: import("@fungi.computer/shiitake/client").SessionContext;

package/dist/core/session-query.js

@@ -13,9 +13,8 @@ const emptyProjection = Object.freeze({
 const LIVE_HISTORY_LIMIT = 200;
 const LIVE_HISTORY_REFRESH_AT = 400;
 function latestPrompt(messages, previous) {
-    for (let index = messages.length - 1; index >= 0; index--) {
-        const message = messages[index];
-        if (message?.value.role !== "user" || message.commandId === null)
+    for (const message of messages.slice().reverse()) {
+        if (message.value.role !== "user" || message.commandId === null)
             continue;
         const content = message.value.content;
         const text = Array.isArray(content)
@@ -23,7 +22,14 @@ function latestPrompt(messages, previous) {
                 .flatMap((part) => (part.type === "text" ? [part.text] : []))
                 .join("\n")
             : content;
-        return [message.commandId, text];
+        const images = Array.isArray(content)
+            ? content.filter((part) => part.type === "image")
+            : [];
+        return {
+            commandId: message.commandId,
+            text,
+            images: images.length === 0 ? undefined : images,
+        };
     }
     return previous;
 }
@@ -116,21 +122,41 @@ export function seedSessionQuery(queryClient, session, snapshot) {
         latestPrompt: latestPrompt(snapshot.messages),
     });
 }
-/** Borrow activity from the existing cache without starting another watch. */
-export function subscribeSessionActivity(queryClient, session, listener) {
+/** Longest header a Session activity may carry. */
+const maximumActivityHeader = 80;
+/**
+ * Borrow activity from the existing cache without starting another watch.
+ * An open attention item (such as an unanswered question) reports `blocked`
+ * ahead of working and idle; the header comes only from the question extension.
+ */
+export function subscribeSessionActivity(queryClient, session, listener, questionExtensionId) {
     const observer = new QueryObserver(queryClient, {
         ...sessionQueryOptions(session),
         enabled: false,
     });
     const report = (result) => {
         const snapshot = result.data?.snapshot;
-        listener(result.isError ||
+        if (result.isError ||
             result.data?.observation !== "live" ||
-            snapshot === undefined
-            ? "unknown"
-            : snapshot.activity.queue.state === "idle"
-                ? "idle"
-                : "working");
+            snapshot === undefined)
+            listener({ state: "unknown" });
+        else if (snapshot.attention.some((item) => item.kind === "question" ||
+            item.kind === "goal-blocked" ||
+            item.kind === "goal-stalled")) {
+            // Only the question owner's short headers may leave the Session.
+            const header = snapshot.attention
+                .filter((item) => questionExtensionId !== undefined &&
+                item.kind === "question" &&
+                item.extensionId === questionExtensionId)
+                .map((item) => item.summary)
+                .join(", ")
+                .slice(0, maximumActivityHeader);
+            listener(header === "" ? { state: "blocked" } : { state: "blocked", header });
+        }
+        else
+            listener({
+                state: snapshot.activity.queue.state === "idle" ? "idle" : "working",
+            });
     };
     const unsubscribe = observer.subscribe(report);
     report(observer.getCurrentResult());

package/dist/core/tool-groups.d.ts

@@ -6,7 +6,7 @@ export declare function toolGroup(tools: readonly [ToolItem, ...ToolItem[]]): To
  * Fold a stretch of tool work into one group. User rows and rendered assistant
  * content end the stretch; invisible assistant rows can span it.
  */
-export declare function groupToolCalls(items: readonly ProjectedItem[]): TimelineItem[];
+export declare function groupToolCalls(items: readonly ProjectedItem[], breakBefore?: ReadonlySet<string>): TimelineItem[];
 /** View-only open/closed state shared by the browser and terminal renderers. */
 export type ToolDisclosureState = Readonly<{
     /**

package/dist/core/tool-groups.js

@@ -76,7 +76,7 @@ export function toolGroup(tools) {
  * Fold a stretch of tool work into one group. User rows and rendered assistant
  * content end the stretch; invisible assistant rows can span it.
  */
-export function groupToolCalls(items) {
+export function groupToolCalls(items, breakBefore = new Set()) {
     const rows = [];
     let run = [];
     let nontextRows = [];
@@ -89,6 +89,8 @@ export function groupToolCalls(items) {
         nontextRows = [];
     };
     for (const item of items) {
+        if (breakBefore.has(item.id))
+            flush();
         if (item.kind === "tool") {
             run.push(item);
             continue;

package/dist/core/tool-view.js

@@ -41,8 +41,9 @@ const kindByName = new Map([
     ["bash", "command"],
     ["edit", "edit"],
     ["execute", "code"],
-    ["find", "search"],
+    ["glob", "search"],
     ["grep", "search"],
+    ["list", "search"],
     ["ls", "search"],
     ["read", "read"],
     ["write", "edit"],

package/dist/core/use-timeline-item-key.d.ts

@@ -0,0 +1,8 @@
+import type { TimelineItem } from "../store/types.js";
+/**
+ * The virtualizer's row-key callback. Text-only progress replaces tail items
+ * but not their keys, so the callback keeps its identity, and the virtualizer
+ * its measurements, until the settled history or the order or identity of the
+ * tail rows changes. Settled rows are keyed from the settled list alone.
+ */
+export declare function useTimelineItemKey(settled: readonly TimelineItem[], tail: readonly TimelineItem[]): (index: number) => string | number;

package/dist/core/use-timeline-item-key.js

@@ -0,0 +1,29 @@
+import { useCallback, useState } from "react";
+/** One submitted prompt keeps one row from submit to durable: no remount. */
+function rowKey(item) {
+    return item.kind === "user_message" && item.requestId !== undefined
+        ? item.requestId
+        : item.id;
+}
+function sameKeys(a, b) {
+    return a.length === b.length && a.every((key, index) => key === b[index]);
+}
+/**
+ * The virtualizer's row-key callback. Text-only progress replaces tail items
+ * but not their keys, so the callback keeps its identity, and the virtualizer
+ * its measurements, until the settled history or the order or identity of the
+ * tail rows changes. Settled rows are keyed from the settled list alone.
+ */
+export function useTimelineItemKey(settled, tail) {
+    const next = tail.map(rowKey);
+    const [previous, setPrevious] = useState(next);
+    const tailKeys = sameKeys(previous, next) ? previous : next;
+    if (tailKeys !== previous)
+        setPrevious(tailKeys);
+    return useCallback((index) => {
+        const item = settled[index];
+        if (item !== undefined)
+            return rowKey(item);
+        return tailKeys[index - settled.length] ?? index;
+    }, [settled, tailKeys]);
+}

package/dist/headless.d.ts

@@ -1,10 +1,12 @@
-export { formatModelIdentity } from "./core/model-identity.js";
+export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
+export type { QueuedRecallState, QueuedRecallOutcome, } from "./core/queued-recall.js";
+export type { ParakeetDraftIdentity, ParakeetDraftStorage, } from "./core/draft-storage.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { providerChoices } from "./provider-choices.js";
-export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useStatus, useTimeline, type ComposerController, type ParakeetModel, type ParakeetObservation, type ParakeetReconnectOutcome, type ParakeetStatus, type ParakeetSessionViewState, type ParakeetUsage, type StatusController, type TimelineController, } from "./conversation.js";
+export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useStatus, useTimeline, type ComposerController, type ParakeetDraftCheckpoint, type ParakeetModel, type ParakeetObservation, type ParakeetReconnectOutcome, type ParakeetStatus, type ParakeetSessionViewState, type ParakeetUsage, type StatusController, type TimelineController, } from "./conversation.js";
 export { sessionViewState, queuedSessionLabel, sessionActivityStatus, type SessionActivityStatus, type SessionViewFacts, type SessionViewState as ParakeetOwnerViewState, } from "./core/session-view-state.js";
 export { mergeTerminals } from "./core/session-projection.js";
-export { seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
+export { type SessionActivity, seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
 export { accountCommandDefinitions, contributeAccountCommands, loginRegistry, type AccountCommandOptions, type AccountOwner, type ProviderAccess, type ModelAccountContext, type LoginHost, type LoginMethod, type LoginMethodKind, type LoginPolicy, type LoginProvider, type LoginScope, } from "./account-commands.js";
 export { contributeModelCommands, sessionModelCommandDefinitions, type SessionModelChoice, type SessionModelCommandOptions, } from "./model-commands.js";
 export { contributeReloadCommand, reloadCommandDefinitions, reloadSources, type ReloadCommandOptions, type ReloadSource, } from "./reload-command.js";
@@ -12,7 +14,7 @@ export { contributeSessionCommands, type ParakeetSessionCommandOptions, } from "
 export { completeSlash, fuzzyMatch, keyBindings, keyLabel, parseSlashDraft, slashRegistry, type FuzzyMatch, type KeyBindingRow, type SlashCommand, type SlashCommandItem, type SlashCompletion, type SlashParse, type SlashWordItem, } from "./commands/slash.js";
 export { composerHints, fitHints, formatHints, type ComposerHintContext, type ComposerKeys, type KeyHint, } from "./commands/hints.js";
 export { isCancelledOutcome, runSlashDraft, type SlashRuntime, } from "./commands/run.js";
-export { createParakeetInteractions, type ParakeetInteractions, type ParakeetInteractionState, type ParakeetNotice, type ParakeetOpenInteraction, } from "./commands/interactions.js";
+export { createParakeetInteractions, type ParakeetInteractions, type ParakeetInteractionState, type ParakeetNotice, type ParakeetOpenInteraction, type ParakeetToast, } from "./commands/interactions.js";
 export { parakeetBuiltinCommands, type ParakeetBuiltinOptions, } from "./commands/builtins.js";
 export { advertisedCommands, type AdvertisedCatalogError, type AdvertisedCommands, } from "./commands/advertised.js";
 export { useSlashCommands, type ParakeetCommandRuntime, type SlashCommandController, type SlashCommandOptions, } from "./commands/use-slash-commands.js";

package/dist/headless.js

@@ -1,4 +1,4 @@
-export { formatModelIdentity } from "./core/model-identity.js";
+export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { providerChoices } from "./provider-choices.js";
 export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useStatus, useTimeline, } from "./conversation.js";

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
+export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
 export type { ParakeetVisitor } from "./parakeet.js";
 export { InteractionPanel, type InteractionPanelProps, } from "./components/InteractionPanel.js";
-export type { ParakeetAssistantMessageItem, ComposerController, ParakeetModel, ParakeetSession, ParakeetStatus, ParakeetTimelineItem, ParakeetToolArguments, ParakeetToolCallSection, ParakeetToolCallView, ParakeetToolDiffFile, ParakeetToolDiffHunk, ParakeetToolDiffLine, ParakeetToolDiffRow, ParakeetToolExcerptLine, ParakeetToolMatch, ParakeetToolOutputLine, ParakeetToolGroupItem, ParakeetToolItem, ParakeetToolKind, ToolDisclosureState, ParakeetUsage, ParakeetUserMessageItem, StatusController, TimelineController, MarkdownBlock, MarkdownInline, } from "./headless.js";
+export type { QueuedRecallState, QueuedRecallOutcome, ParakeetAssistantMessageItem, ComposerController, ParakeetDraftCheckpoint, ParakeetDraftIdentity, ParakeetDraftStorage, ParakeetModel, ParakeetSession, ParakeetStatus, ParakeetTimelineItem, ParakeetToolArguments, ParakeetToolCallSection, ParakeetToolCallView, ParakeetToolDiffFile, ParakeetToolDiffHunk, ParakeetToolDiffLine, ParakeetToolDiffRow, ParakeetToolExcerptLine, ParakeetToolMatch, ParakeetToolOutputLine, ParakeetToolGroupItem, ParakeetToolItem, ParakeetToolKind, ToolDisclosureState, ParakeetUsage, ParakeetUserMessageItem, StatusController, TimelineController, MarkdownBlock, MarkdownInline, } from "./headless.js";
 export type { ParakeetProps, ParakeetViewProps } from "./parakeet.js";
 export type { ParakeetAuthor, ParakeetAuthorOf } from "./core/author-labels.js";
 export type { ParakeetSessionCommand, ParakeetPromptResult, } from "./session.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
+export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
 export { InteractionPanel, } from "./components/InteractionPanel.js";
 export * from "./agent-head.js";

package/dist/model-commands.js

@@ -4,18 +4,27 @@ import { z } from "zod";
 import { loginRegistry, signInProvider, } from "./account-commands.js";
 import { providerChoices } from "./provider-choices.js";
 const defaultChoice = "default";
+// Session-local picker memory survives contribution refreshes, not the owner.
+const recentModels = new WeakMap();
+/** Private memory ceiling, independent of how many models a provider offers. */
+const maximumRememberedProviders = 256;
 function modelLabel(model) {
     return `${model.providerName} · ${model.name}`;
 }
-/** Current model first, then providers and models by name; no provider is favoured. */
-function orderModels(models, current) {
+/** Each provider's current or last-used model first, then catalog order. */
+function orderModels(models, current, recent) {
     return [...models].sort((left, right) => {
-        const leftCurrent = left.id === current?.modelId && left.providerId === current.providerId;
-        const rightCurrent = right.id === current?.modelId && right.providerId === current.providerId;
+        const leftPreference = current?.providerId === left.providerId
+            ? current
+            : recent.get(left.providerId);
+        const rightPreference = current?.providerId === right.providerId
+            ? current
+            : recent.get(right.providerId);
+        const leftCurrent = left.id === leftPreference?.modelId;
+        const rightCurrent = right.id === rightPreference?.modelId;
         if (leftCurrent !== rightCurrent)
             return leftCurrent ? -1 : 1;
-        return (left.providerName.localeCompare(right.providerName) ||
-            left.name.localeCompare(right.name));
+        return left.providerName.localeCompare(right.providerName);
     });
 }
 async function chooseReasoning(interaction, model, current) {
@@ -82,7 +91,7 @@ async function chooseProviderModels(interaction, models, account, refreshModels)
     let catalog = models;
     if (!access.some((candidate) => candidate.providerId === providerId)) {
         await signInProvider(owner, provider, interaction);
-        catalog = await refreshModels(interaction.signal);
+        catalog = await interaction.run(() => refreshModels(interaction.signal));
     }
     const selectedModels = catalog
         .filter((model) => model.providerId === providerId)
@@ -93,6 +102,20 @@ async function chooseProviderModels(interaction, models, account, refreshModels)
 }
 /** Describe and invoke the ordinary model-preference owner from any client. */
 export function sessionModelCommandDefinitions(session, options) {
+    const recent = recentModels.get(session.modelPreference.read) ??
+        new Map();
+    recentModels.set(session.modelPreference.read, recent);
+    const remember = (preference) => {
+        if (preference === null)
+            return;
+        recent.delete(preference.providerId);
+        recent.set(preference.providerId, preference);
+        if (recent.size > maximumRememberedProviders) {
+            const oldest = recent.keys().next().value;
+            if (oldest !== undefined)
+                recent.delete(oldest);
+        }
+    };
     const preferenceSchema = z
         .record(z.string(), z.json())
         .parse(modelPreferenceJsonSchema);
@@ -117,7 +140,7 @@ export function sessionModelCommandDefinitions(session, options) {
                 agent: {},
                 palette: {},
                 help: {},
-                slash: { aliases: ["model"] },
+                slash: { aliases: ["model"], consumesDraft: true },
             },
             action: {
                 inputSchema: {
@@ -132,42 +155,43 @@ export function sessionModelCommandDefinitions(session, options) {
                     if (input.origin === "agent" || interaction === undefined)
                         return session.modelPreference.read();
                     const current = await session.modelPreference.read();
-                    const ordered = await chooseProviderModels(interaction, orderModels(options.models, current), options.account, options.refreshModels);
-                    if (ordered === null) {
-                        await session.modelPreference.set(null);
-                        return session.modelPreference.read();
+                    remember(current);
+                    const providerModels = await chooseProviderModels(interaction, options.models, options.account, options.refreshModels);
+                    if (providerModels === null) {
+                        await interaction.run(() => session.modelPreference.set(null));
+                        return interaction.run(() => session.modelPreference.read());
                     }
+                    const ordered = orderModels(providerModels, current, recent);
                     const answer = await interaction.prompt({
                         type: "choice",
                         message: "Model",
-                        options: [
-                            { value: defaultChoice, label: "Use agent model" },
-                            ...ordered.map((model, index) => ({
-                                value: String(index),
-                                label: model.providerId === current?.providerId &&
-                                    model.id === current.modelId
-                                    ? `${modelLabel(model)} (current)`
-                                    : modelLabel(model),
-                            })),
-                        ],
+                        options: ordered.map((model, index) => ({
+                            value: String(index),
+                            label: model.providerId === current?.providerId &&
+                                model.id === current.modelId
+                                ? `${modelLabel(model)} (current)`
+                                : modelLabel(model),
+                        })),
                     });
-                    const model = answer === defaultChoice ? undefined : ordered[Number(answer)];
-                    let chosen = null;
-                    if (model !== undefined) {
-                        const reasoning = await chooseReasoning(interaction, model, current?.reasoning);
-                        chosen =
-                            reasoning === undefined
-                                ? { providerId: model.providerId, modelId: model.id }
-                                : {
-                                    providerId: model.providerId,
-                                    modelId: model.id,
-                                    reasoning,
-                                };
-                    }
-                    await session.modelPreference.set(chosen);
+                    const model = ordered[Number(answer)];
+                    if (model === undefined)
+                        throw new WhistleActionError("model_unavailable", "Choose a listed model.");
+                    const previous = current?.providerId === model.providerId
+                        ? current
+                        : recent.get(model.providerId);
+                    const reasoning = await chooseReasoning(interaction, model, previous?.reasoning);
+                    const chosen = reasoning === undefined
+                        ? { providerId: model.providerId, modelId: model.id }
+                        : {
+                            providerId: model.providerId,
+                            modelId: model.id,
+                            reasoning,
+                        };
+                    await interaction.run(() => session.modelPreference.set(chosen));
+                    remember(chosen);
                     // The mounted owner's effective-model label confirms the choice.
                     // A success notice would keep the choice dialog focused until Esc.
-                    return session.modelPreference.read();
+                    return interaction.run(() => session.modelPreference.read());
                 }
                 let preference;
                 try {
@@ -187,6 +211,7 @@ export function sessionModelCommandDefinitions(session, options) {
                         throw new WhistleActionError("reasoning_unavailable", "That thinking level is not supported by this model");
                 }
                 await session.modelPreference.set(preference);
+                remember(preference);
                 return session.modelPreference.read();
             },
         },
@@ -216,8 +241,8 @@ export function sessionModelCommandDefinitions(session, options) {
                 const chosen = reasoning === undefined
                     ? { providerId: model.providerId, modelId: model.id }
                     : { providerId: model.providerId, modelId: model.id, reasoning };
-                await session.modelPreference.set(chosen);
-                return session.modelPreference.read();
+                await interaction.run(() => session.modelPreference.set(chosen));
+                return interaction.run(() => session.modelPreference.read());
             },
         },
     ];

package/dist/parakeet.js

@@ -8,6 +8,7 @@ import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import { ParakeetProvider, useComposer, useClientContributions, useDismissFailedPrompt, useStatus, useTimeline, } from "./conversation.js";
 import { initialToolDisclosure, toggleDisclosure } from "./core/tool-groups.js";
 import { authorDisplayNames, } from "./core/author-labels.js";
+import { useTimelineItemKey } from "./core/use-timeline-item-key.js";
 import { ChatComposer, sessionReadout, } from "./components/ChatComposer.js";
 import { ClientRows } from "./components/ClientRows.js";
 import { useClientActions } from "./client-contributions.js";
@@ -31,7 +32,11 @@ export function ParakeetView({ disambiguateAuthors, visitor, composerActionVaria
     const clientActions = useClientActions(commands ?? ownCommands);
     const contributions = useClientContributions();
     const timelineController = useTimeline();
-    const placed = useMemo(() => placeClientTimeline(contributions, timelineController.commandAnchors), [contributions, timelineController.commandAnchors]);
+    const placed = useMemo(() => placeClientTimeline(contributions, timelineController.commandAnchors, timelineController.positionAnchors), [
+        contributions,
+        timelineController.commandAnchors,
+        timelineController.positionAnchors,
+    ]);
     return (_jsxs("div", { className: "parakeet flex h-full flex-col items-stretch", "data-parakeet": "standalone", "data-testid": "parakeet-view", onClickCapture: (event) => {
             const anchor = event.target instanceof Element
                 ? event.target.closest("a[href]")
@@ -85,19 +90,20 @@ function ConversationInteraction({ slash, }) {
     return (_jsx(Dialog, { open: open !== undefined, onOpenChange: (next) => {
             if (!next)
                 slash.store.close();
-        }, children: _jsx(DialogContent, { className: "w-[min(32rem,calc(100vw-2rem))] rounded-box bg-base-100 p-md shadow-lg", keepMounted: false, children: open === undefined ? null : (_jsx(InteractionPanel, { host: open.host, onClose: slash.store.close, onRetry: () => {
-                    slash.store.close();
-                    open.retry();
-                } }, open.key)) }) }));
+        }, children: _jsx(DialogContent, { className: "w-[min(32rem,calc(100vw-2rem))] rounded-box bg-base-100 p-md shadow-lg", keepMounted: false, children: open === undefined ? null : (_jsx(InteractionPanel, { host: open.host, onClose: slash.store.close }, open.key)) }) }));
 }
 function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focusAfterJump, empty, renderToolActions, renderAssistantAttachment, formatAssistantText, }) {
     const dismissFailed = useDismissFailedPrompt();
     const timelineController = useTimeline();
+    const cancelQueued = useCallback((commandId) => {
+        void timelineController.cancelQueued(commandId);
+    }, [timelineController.cancelQueued]);
     const authorNames = useMemo(() => authorDisplayNames(disambiguateAuthors
         ? [...timelineController.settled, ...timelineController.tail].flatMap((item) => ("author" in item && item.author ? [item.author] : []))
         : []), [disambiguateAuthors, timelineController.settled, timelineController.tail]);
     const contributions = useClientContributions();
-    const placed = placeClientTimeline(contributions, timelineController.commandAnchors);
+    const placed = placeClientTimeline(contributions, timelineController.commandAnchors, timelineController.positionAnchors);
+    const before = placed.before.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)));
     // View-only: kept above the virtualizer so off-screen groups remember it.
     const [toolDisclosure, setToolDisclosure] = useState(initialToolDisclosure);
     const toggleTool = useCallback((id, defaultOpen) => {
@@ -110,15 +116,7 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
     const itemAt = useCallback((index) => index < timelineController.settled.length
         ? timelineController.settled[index]
         : timelineController.tail[index - timelineController.settled.length], [timelineController.settled, timelineController.tail]);
-    const getItemKey = useCallback((index) => {
-        const item = itemAt(index);
-        if (item === undefined)
-            return index;
-        // One submitted prompt keeps one row from submit to durable: no remount.
-        return item.kind === "user_message" && item.requestId !== undefined
-            ? item.requestId
-            : item.id;
-    }, [itemAt]);
+    const getItemKey = useTimelineItemKey(timelineController.settled, timelineController.tail);
     const timeline = useVirtualizer({
         anchorTo: "end",
         count,
@@ -200,7 +198,7 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
                                 top: 0,
                                 transform: `translateY(${String(virtualItem.start)}px)`,
                                 width: "100%",
-                            }, children: [_jsx(TimelineItem, { item: "author" in item &&
+                            }, children: [virtualItem.index === 0 ? before : null, _jsx(TimelineItem, { item: "author" in item &&
                                         item.author &&
                                         authorNames.has(item.author.id)
                                         ? {
@@ -211,8 +209,8 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
                                                     item.author.name,
                                             },
                                         }
-                                        : item, onDismissFailed: dismissFailed, onToggleTool: toggleTool, renderToolActions: renderToolActions, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, toolDisclosure: toolDisclosure }), placed.after.get(item.id)?.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)))] }, virtualItem.key));
-                    }) })) : ((empty ?? (_jsx("div", { className: "flex h-full items-center justify-center text-center", children: _jsxs("div", { children: [_jsx("p", { className: "mb-1 text-xs text-base-content", children: "Ready" }), _jsx("p", { className: "text-[10px] text-dim", children: "What would you like to build?" })] }) })))) }), count > 0 ? (_jsx(ScrollToBottomBlob, { direction: "forward", unread: unread, focusAfterJump: focusAfterJump, onJump: jumpToBottom, scrollerRef: scrollerRef })) : null] }));
+                                        : item, onDismissFailed: dismissFailed, onCancelQueued: cancelQueued, cancellingQueued: timelineController.cancellingQueued, onToggleTool: toggleTool, renderToolActions: renderToolActions, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, toolDisclosure: toolDisclosure }), placed.after.get(item.id)?.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)))] }, virtualItem.key));
+                    }) })) : before.length > 0 ? (before) : hasMoreHistory ? null : ((empty ?? (_jsx("div", { className: "flex h-full items-center justify-center text-center", children: _jsxs("div", { children: [_jsx("p", { className: "mb-1 text-xs text-base-content", children: "Ready" }), _jsx("p", { className: "text-[10px] text-dim", children: "What would you like to build?" })] }) })))) }), count > 0 ? (_jsx(ScrollToBottomBlob, { direction: "forward", unread: unread, focusAfterJump: focusAfterJump, onJump: jumpToBottom, scrollerRef: scrollerRef })) : null] }));
 }
 /** The owner's queued state and independently contributed waiting controls. */
 function ConversationWaiting({ clientActions, }) {
@@ -243,6 +241,7 @@ function ConversationComposer({ visitor, textareaRef, composerActionVariant, sla
         void composer.cancel();
     }, [composer.cancel]);
     const composerProps = {
+        queuedRecall: visitor === undefined ? composer : undefined,
         statusChips: contributions
             .flatMap(({ value }) => value.chips)
             .sort((left, right) => left.order - right.order)

package/dist/session-commands.d.ts

@@ -1,4 +1,3 @@
-import type { CancelResult } from "@fungi.computer/shiitake/client";
 import type { ParakeetSessionCommand } from "./session.js";
 import type { WhistleRuntime } from "@fungi.computer/whistle";
 import { buildDurableTimeline } from "./core/build-timeline.js";
@@ -18,10 +17,6 @@ export type SessionCommandSession = Readonly<{
             }>[];
         }>;
     }> & SessionViewFacts>;
-    cancel?: ((input: Readonly<{
-        commandId: string;
-        onlyIfPending?: boolean;
-    }>) => Promise<CancelResult>) | undefined;
     /** Execute a type-discriminated Session command, including `fork`. */
     command: ParakeetSessionCommand;
 }>;
@@ -35,10 +30,6 @@ export type ParakeetSessionCommandOptions = Readonly<{
     sessionResume?: (() => void | Promise<void>) | undefined;
     /** Whether this host currently supports saved-Session selection. */
     sessionResumeAvailable: boolean;
-    /** Restore an owner-withdrawn queued prompt into the host composer. */
-    onEditQueued?: (text: string) => void;
-    /** Refuse withdrawal while the host has a draft that must be preserved. */
-    canEditQueued?: () => boolean;
     /** Navigate to the Session a fork just created. */
     onForked?: ((sessionId: string) => void | Promise<void>) | undefined;
     /** Whether this host currently supports navigating to a forked Session. */