Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(web): stashed prompts now survive switching providers (#4787)
Theo Brownef2d2fb2f2444
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsxindex fa9a75dd3..5575916dd 100644--- a/apps/web/src/components/chat/ChatComposer.tsx+++ b/apps/web/src/components/chat/ChatComposer.tsx@@ -57,10 +57,8 @@ import {useEffectiveComposerModelState,} from "../../composerDraftStore";import {- EMPTY_PROMPT_STASH_QUEUE,- MAX_STASH_ENTRIES_PER_QUEUE,+ MAX_STASH_ENTRIES,partitionStashAttachments,- promptStashScopeKey,usePromptStashStore,type PromptStashEntry,} from "../../promptStashStore";@@ -733,7 +731,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const clearComposerDraftPromptAndImages = useComposerDraftStore((store) => store.clearComposerPromptAndImages,);- const setComposerDraftModelSelection = useComposerDraftStore((store) => store.setModelSelection);const syncComposerDraftPersistedAttachments = useComposerDraftStore((store) => store.syncPersistedAttachments,);@@ -1888,23 +1885,13 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)// ------------------------------------------------------------------// Prompt stash (⌘S)// ------------------------------------------------------------------- const stashScopeInstanceId = noProviderAvailable ? null : selectedInstanceId;- const stashScope = promptStashScopeKey(stashScopeInstanceId);- const stashQueue = usePromptStashStore(- (state) => state.queuesByScopeKey[stashScope] ?? EMPTY_PROMPT_STASH_QUEUE,- );- const stashOtherScopesCount = usePromptStashStore((state) =>- Object.entries(state.queuesByScopeKey).reduce(- (total, [key, queue]) => (key === stashScope ? total : total + queue.length),- 0,- ),- );+ // One global queue. Stashed prompts carry only text + images so they can be+ // restored into any thread or provider — stash, switch, restore is the+ // whole point.+ const stashQueue = usePromptStashStore((state) => state.entries);const stashEntryToQueue = usePromptStashStore((state) => state.stashEntry);const takeStashEntry = usePromptStashStore((state) => state.takeEntry);const finalizeStashEntryImages = usePromptStashStore((state) => state.finalizeEntryImages);- const stashProviderLabel = noProviderAvailable- ? "No provider"- : getProviderDisplayName(providerStatuses, selectedProvider);useEffect(() => {return () => {@@ -1930,10 +1917,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const restoreStashEntry = useCallback((entry: PromptStashEntry) => {// Remove first so a double activation (click + Enter) can't restore twice.- const { entry: taken, durable } = takeStashEntry(- promptStashScopeKey(entry.providerInstanceId),- entry.id,- );+ const { entry: taken, durable } = takeStashEntry(entry.id);if (!taken) return;if (!durable) {toastManager.add({@@ -1996,21 +1980,9 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)}}- const restorableSelection =- entry.modelSelection &&- providerInstanceEntries.some(- (candidate) =>- candidate.instanceId === entry.modelSelection?.instanceId &&- candidate.enabled &&- candidate.isAvailable,- )- ? entry.modelSelection- : null;- if (restorableSelection) {- setComposerDraftModelSelection(composerDraftTarget, restorableSelection, {- replaceOptions: true,- });- }+ // Deliberately no model/provider restore: the stash exists to carry a+ // prompt across threads and providers, so whatever the composer has+ // selected right now stays selected.// Each cause gets its own sentence so "too large" is never blamed for a// file that actually failed to decode, or for one the composer simply@@ -2052,8 +2024,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)composerDraftTarget,composerImagesRef,promptRef,- providerInstanceEntries,- setComposerDraftModelSelection,setComposerDraftPrompt,takeStashEntry,],@@ -2061,7 +2031,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const deleteStashEntry = useCallback((entry: PromptStashEntry) => {- const { durable } = takeStashEntry(promptStashScopeKey(entry.providerInstanceId), entry.id);+ const { durable } = takeStashEntry(entry.id);if (!durable) {toastManager.add({type: "warning",@@ -2097,30 +2067,27 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const stashTarget = composerDraftTarget;const entryId = randomUUID();- const scopeKey = promptStashScopeKey(stashScopeInstanceId);try {// Persist the text-only entry *first*, then clear. Ordering matters in// both directions: writing before clearing means a crash or closed tab// mid-encode still leaves the prompt recoverable, while clearing before// the async image work means edits typed during encoding are not wiped.// Images are appended to the stored entry as they finish encoding.- const { evicted, durable } = stashEntryToQueue({+ const { evicted, written, durable } = stashEntryToQueue({id: entryId,createdAt: new Date().toISOString(),prompt,attachments: [],- providerInstanceId: stashScopeInstanceId,- modelSelection: noProviderAvailable ? null : selectedModelSelection,droppedImageNames: [],unreadableImageNames: [],pendingImageCount: images.length,});- // Clearing the composer is only safe once the entry is durable. If the- // write was rejected (quota, blocked storage) the store has already- // rolled itself back, so leave the composer untouched rather than- // making it the second casualty of a reload.- if (!durable) {+ // Clearing the composer is only safe once the write actually landed.+ // If it was rejected (quota) the store has already rolled itself back,+ // so leave the composer untouched rather than making it the second+ // casualty of a reload.+ if (!written) {toastManager.add({type: "error",title: "Could not stash this prompt",@@ -2130,6 +2097,18 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)});return;}+ // Written but only into the in-memory fallback (localStorage blocked):+ // the entry is visible and restorable this session, so proceed with the+ // clear, but say it won't survive a reload.+ if (!durable) {+ toastManager.add({+ type: "warning",+ title: "Stashed prompt will not survive a reload",+ description:+ "Browser storage is unavailable, so this stash is kept in memory only for this session.",+ data: { hideCopyButton: true },+ });+ }// Only the prompt and images are cleared — terminal/element contexts,// preview annotations, and review comments are not stashable, so@@ -2144,7 +2123,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)toastManager.add({type: "warning",title: "Oldest stashed prompt discarded",- description: `The ${stashProviderLabel} stash holds ${MAX_STASH_ENTRIES_PER_QUEUE} prompts; the oldest was removed to make room.`,+ description: `The stash holds ${MAX_STASH_ENTRIES} prompts; the oldest was removed to make room.`,data: { hideCopyButton: true },});}@@ -2176,7 +2155,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)}const { kept, droppedNames } = partitionStashAttachments(candidateAttachments);- const { attached, durable: imagesDurable } = finalizeStashEntryImages(scopeKey, entryId, {+ const { attached, durable: imagesDurable } = finalizeStashEntryImages(entryId, {attachments: kept,droppedImageNames: [...oversizedImageNames, ...droppedNames],unreadableImageNames,@@ -2185,8 +2164,10 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)// The second phase can be rejected on its own: the text-only entry// fit, but adding image payloads pushed past the quota. Disk would// then still hold the phase-one entry with pendingImageCount set,- // which reads as an orphan after reload — so say so now.- if (!imagesDurable && images.length > 0) {+ // which reads as an orphan after reload — so say so now. Gated on the+ // entry write having been durable: on the in-memory fallback nothing+ // is ever durable, and the session-only warning already covered it.+ if (!imagesDurable && durable && images.length > 0) {toastManager.add({type: "warning",title: "Stashed images were not saved",@@ -2216,13 +2197,9 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)composerDraftTarget,composerImagesRef,finalizeStashEntryImages,- noProviderAvailable,promptRef,pulseStashBadge,- selectedModelSelection,stashEntryToQueue,- stashProviderLabel,- stashScopeInstanceId,]);const toggleStashMenu = useCallback(() => {@@ -2832,8 +2809,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)<ComposerCommandMenuLayer anchor={composerMenuAnchor}><ComposerStashMenuentries={stashQueue}- providerLabel={stashProviderLabel}- otherScopesCount={stashOtherScopesCount}onRestore={restoreStashEntry}onDelete={deleteStashEntry}onClose={() => setIsStashMenuOpen(false)}diff --git a/apps/web/src/components/chat/ComposerStashBadge.tsx b/apps/web/src/components/chat/ComposerStashBadge.tsxindex cb2d98339..79ed301a5 100644--- a/apps/web/src/components/chat/ComposerStashBadge.tsx+++ b/apps/web/src/components/chat/ComposerStashBadge.tsx@@ -5,8 +5,7 @@ import { cn } from "~/lib/utils";/*** Bookmark pill perched on the composer's top-right shoulder. Shows the- * current method's stash count and doubles as the click target for opening- * the stash menu.+ * stash count and doubles as the click target for opening the stash menu.** On save the badge gives one quiet acknowledgement: it lifts to full* opacity and the count ticks over. `pulseKey` changes per stash, remountingdiff --git a/apps/web/src/components/chat/ComposerStashMenu.tsx b/apps/web/src/components/chat/ComposerStashMenu.tsxindex 229500743..bfc2d88ba 100644--- a/apps/web/src/components/chat/ComposerStashMenu.tsx+++ b/apps/web/src/components/chat/ComposerStashMenu.tsx@@ -24,16 +24,13 @@ function stashEntrySnippet(entry: PromptStashEntry): string {}/**- * Popover listing the current connection method's stashed prompts.- * Keyboard-first: opened by ⌘S on an empty composer, navigated with- * arrows, restored with Enter, dismissed with Escape. The listener runs- * capture-phase on window so it wins over the Lexical editor's handlers- * while the menu is open.+ * Popover listing the stashed prompts. Keyboard-first: opened by ⌘S on an+ * empty composer, navigated with arrows, restored with Enter, dismissed+ * with Escape. The listener runs capture-phase on window so it wins over+ * the Lexical editor's handlers while the menu is open.*/export const ComposerStashMenu = memo(function ComposerStashMenu(props: {entries: ReadonlyArray<PromptStashEntry>;- providerLabel: string;- otherScopesCount: number;onRestore: (entry: PromptStashEntry) => void;onDelete: (entry: PromptStashEntry) => void;onClose: () => void;@@ -99,12 +96,11 @@ export const ComposerStashMenu = memo(function ComposerStashMenu(props: {<CommandGroup><CommandGroupLabel className="flex items-center gap-1.5 px-3 pt-2 pb-1 text-[10px] font-semibold uppercase tracking-[0.08em] text-muted-foreground/55"><BookmarkIcon className="size-3" aria-hidden="true" />- Stashed prompts — {props.providerLabel}+ Stashed prompts</CommandGroupLabel>{entries.length === 0 ? (<p className="px-3 pb-3 pt-1 text-muted-foreground/70 text-xs">- Nothing stashed for this method yet. Press ⌘S with a prompt in the composer to stash- it.+ Nothing stashed yet. Press ⌘S with a prompt in the composer to stash it.</p>) : (entries.map((entry) => (@@ -173,12 +169,6 @@ export const ComposerStashMenu = memo(function ComposerStashMenu(props: {)))}</CommandGroup>- {props.otherScopesCount > 0 ? (- <p className="border-t border-border/50 px-3 py-2 text-[11px] text-muted-foreground/60">- {props.otherScopesCount} more stashed under other connection methods — switch provider- to see them.- </p>- ) : null}</CommandList></div></Command>diff --git a/apps/web/src/promptStashStore.test.ts b/apps/web/src/promptStashStore.test.tsindex 228e1e357..20894713d 100644--- a/apps/web/src/promptStashStore.test.ts+++ b/apps/web/src/promptStashStore.test.ts@@ -1,26 +1,19 @@-import { ProviderInstanceId } from "@t3tools/contracts";import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";import { removeLocalStorageItem } from "./hooks/useLocalStorage";import {- MAX_STASH_ENTRIES_PER_QUEUE,+ MAX_STASH_ENTRIES,PROMPT_STASH_STORAGE_KEY,MAX_STASH_ENTRY_ATTACHMENT_CHARS,- PROMPT_STASH_UNSCOPED_KEY,partitionStashAttachments,- promptStashScopeKey,usePromptStashStore,writePromptStashStorageForTest,type PromptStashEntry,} from "./promptStashStore";-const CLAUDE_AGENT_INSTANCE = ProviderInstanceId.make("claudeAgent");-const CODEX_INSTANCE = ProviderInstanceId.make("codex");-function makeEntry(input: {id: string;- providerInstanceId?: ProviderInstanceId | null;prompt?: string;attachmentChars?: number;}): PromptStashEntry {@@ -40,35 +33,16 @@ function makeEntry(input: {},]: [],- providerInstanceId:- input.providerInstanceId === undefined ? CLAUDE_AGENT_INSTANCE : input.providerInstanceId,- modelSelection: null,droppedImageNames: [],};}function resetPromptStashStore() {- usePromptStashStore.setState({ queuesByScopeKey: {} });+ usePromptStashStore.setState({ entries: [] });writePromptStashStorageForTest("");removeLocalStorageItem(PROMPT_STASH_STORAGE_KEY);}-describe("promptStashScopeKey", () => {- it("maps a provider instance to its own bucket and null to the unscoped bucket", () => {- expect(promptStashScopeKey(CLAUDE_AGENT_INSTANCE)).toBe("provider:claudeAgent");- expect(promptStashScopeKey(null)).toBe(PROMPT_STASH_UNSCOPED_KEY);- expect(promptStashScopeKey(undefined)).toBe(PROMPT_STASH_UNSCOPED_KEY);- });-- // Provider slugs must match /^[a-zA-Z][a-zA-Z0-9_-]*$/, so no real instance- // id can equal the unscoped sentinel. The namespace prefix makes that- // structural rather than incidental.- it("namespaces provider keys so they can never equal the unscoped sentinel", () => {- expect(promptStashScopeKey(CLAUDE_AGENT_INSTANCE)).not.toBe(PROMPT_STASH_UNSCOPED_KEY);- expect(promptStashScopeKey(CODEX_INSTANCE).startsWith("provider:")).toBe(true);- });-});-describe("partitionStashAttachments", () => {it("keeps attachments within the budget and reports dropped names in order", () => {const small = {@@ -124,74 +98,50 @@ describe("promptStashStore", () => {const store = usePromptStashStore.getState();store.stashEntry(makeEntry({ id: "first" }));store.stashEntry(makeEntry({ id: "second" }));- const queue =- usePromptStashStore.getState().queuesByScopeKey[promptStashScopeKey(CLAUDE_AGENT_INSTANCE)] ??- [];- expect(queue.map((entry) => entry.id)).toEqual(["second", "first"]);- });-- it("scopes queues by provider instance, including the unscoped bucket", () => {- const store = usePromptStashStore.getState();- store.stashEntry(makeEntry({ id: "claude" }));- store.stashEntry(makeEntry({ id: "codex", providerInstanceId: CODEX_INSTANCE }));- store.stashEntry(makeEntry({ id: "none", providerInstanceId: null }));- const queues = usePromptStashStore.getState().queuesByScopeKey;- expect(queues[promptStashScopeKey(CLAUDE_AGENT_INSTANCE)]?.map((entry) => entry.id)).toEqual([- "claude",- ]);- expect(queues[promptStashScopeKey(CODEX_INSTANCE)]?.map((entry) => entry.id)).toEqual([- "codex",- ]);- expect(queues[PROMPT_STASH_UNSCOPED_KEY]?.map((entry) => entry.id)).toEqual(["none"]);+ const entries = usePromptStashStore.getState().entries;+ expect(entries.map((entry) => entry.id)).toEqual(["second", "first"]);});- it("evicts the oldest entry past the per-queue cap and returns it", () => {+ it("evicts the oldest entry past the cap and returns it", () => {const store = usePromptStashStore.getState();- for (let index = 0; index < MAX_STASH_ENTRIES_PER_QUEUE; index += 1) {+ for (let index = 0; index < MAX_STASH_ENTRIES; index += 1) {expect(store.stashEntry(makeEntry({ id: `entry-${index}` })).evicted).toBeNull();}const { evicted } = store.stashEntry(makeEntry({ id: "overflow" }));expect(evicted?.id).toBe("entry-0");- const queue =- usePromptStashStore.getState().queuesByScopeKey[promptStashScopeKey(CLAUDE_AGENT_INSTANCE)] ??- [];- expect(queue).toHaveLength(MAX_STASH_ENTRIES_PER_QUEUE);- expect(queue[0]?.id).toBe("overflow");+ const entries = usePromptStashStore.getState().entries;+ expect(entries).toHaveLength(MAX_STASH_ENTRIES);+ expect(entries[0]?.id).toBe("overflow");});- it("takeEntry removes and returns the entry; second take returns null", () => {+ // This test environment has no `localStorage`, so the store runs on its+ // in-memory fallback — the exact "kept for this session, gone on reload"+ // case the composer must distinguish from an outright write failure.+ it("distinguishes a memory-only write (written, not durable) from a failed one", () => {const store = usePromptStashStore.getState();- store.stashEntry(makeEntry({ id: "keep" }));- store.stashEntry(makeEntry({ id: "take" }));- expect(store.takeEntry(promptStashScopeKey(CLAUDE_AGENT_INSTANCE), "take").entry?.id).toBe(- "take",- );- expect(store.takeEntry(promptStashScopeKey(CLAUDE_AGENT_INSTANCE), "take").entry).toBeNull();- const queue =- usePromptStashStore.getState().queuesByScopeKey[promptStashScopeKey(CLAUDE_AGENT_INSTANCE)] ??- [];- expect(queue.map((entry) => entry.id)).toEqual(["keep"]);+ const result = store.stashEntry(makeEntry({ id: "memory-only" }));+ expect(result.written).toBe(true);+ expect(result.durable).toBe(false);+ expect(usePromptStashStore.getState().entries.map((entry) => entry.id)).toEqual([+ "memory-only",+ ]);});- // Queue keys are persisted as plain strings, so a hand-edited or corrupted- // localStorage payload can carry a literal `__proto__` key that survives- // JSON.parse as an own property. An unguarded lookup would resolve to- // Object.prototype and throw "not iterable" on spread.- it("tolerates a __proto__ scope key rehydrated from storage", () => {- usePromptStashStore.setState({- queuesByScopeKey: JSON.parse('{"__proto__":[]}') as Record<string, PromptStashEntry[]>,- });+ it("takeEntry removes and returns the entry; second take returns null", () => {const store = usePromptStashStore.getState();- expect(() => store.takeEntry("__proto__", "missing")).not.toThrow();- expect(store.takeEntry("__proto__", "missing").entry).toBeNull();+ store.stashEntry(makeEntry({ id: "keep" }));+ store.stashEntry(makeEntry({ id: "take" }));+ expect(store.takeEntry("take").entry?.id).toBe("take");+ expect(store.takeEntry("take").entry).toBeNull();+ const entries = usePromptStashStore.getState().entries;+ expect(entries.map((entry) => entry.id)).toEqual(["keep"]);});it("finalizeEntryImages attaches images and clears the pending count", () => {const store = usePromptStashStore.getState();- const scopeKey = promptStashScopeKey(CLAUDE_AGENT_INSTANCE);store.stashEntry({ ...makeEntry({ id: "pending" }), pendingImageCount: 2 });- const { attached } = store.finalizeEntryImages(scopeKey, "pending", {+ const { attached } = store.finalizeEntryImages("pending", {attachments: [{id: "img-1",@@ -206,7 +156,7 @@ describe("promptStashStore", () => {});expect(attached).toBe(true);- const entry = usePromptStashStore.getState().queuesByScopeKey[scopeKey]?.[0];+ const entry = usePromptStashStore.getState().entries[0];expect(entry?.attachments).toHaveLength(1);expect(entry?.droppedImageNames).toEqual(["big.png"]);expect(entry?.pendingImageCount).toBe(0);@@ -214,12 +164,11 @@ describe("promptStashStore", () => {it("finalizeEntryImages reports false when the entry was already taken", () => {const store = usePromptStashStore.getState();- const scopeKey = promptStashScopeKey(CLAUDE_AGENT_INSTANCE);store.stashEntry({ ...makeEntry({ id: "racing" }), pendingImageCount: 1 });// Restored (or deleted) while its images were still encoding.- store.takeEntry(scopeKey, "racing");+ store.takeEntry("racing");- const { attached } = store.finalizeEntryImages(scopeKey, "racing", {+ const { attached } = store.finalizeEntryImages("racing", {attachments: [],droppedImageNames: [],unreadableImageNames: [],@@ -229,31 +178,31 @@ describe("promptStashStore", () => {});it("settles a pending count left behind by a crashed or closed session", () => {- const scopeKey = promptStashScopeKey(CLAUDE_AGENT_INSTANCE);writePromptStashStorageForTest(JSON.stringify({- version: 1,+ version: 2,state: {- queuesByScopeKey: {- [scopeKey]: [{ ...makeEntry({ id: "orphan" }), pendingImageCount: 2 }],- },+ entries: [{ ...makeEntry({ id: "orphan" }), pendingImageCount: 2 }],},}),);// Hydration must settle the stale count, or the entry would stay stuck// showing "saving…" with images that no longer exist anywhere.- const entry = usePromptStashStore.getState().queuesByScopeKey[scopeKey]?.[0];+ const entry = usePromptStashStore.getState().entries[0];expect(entry?.pendingImageCount).toBe(0);expect(entry?.unreadableImageNames).toHaveLength(2);});- it("drops the scope key entirely when its queue empties", () => {- const store = usePromptStashStore.getState();- store.stashEntry(makeEntry({ id: "only" }));- store.takeEntry(promptStashScopeKey(CLAUDE_AGENT_INSTANCE), "only");- expect(- usePromptStashStore.getState().queuesByScopeKey[promptStashScopeKey(CLAUDE_AGENT_INSTANCE)],- ).toBeUndefined();+ it("ignores an unreadable v1 payload seeded under the current key", () => {+ // The v1 shape (per-provider queues) does not decode as v2; hydration+ // must fall back to an empty stash rather than throw.+ writePromptStashStorageForTest(+ JSON.stringify({+ version: 1,+ state: { queuesByScopeKey: { "provider:claudeAgent": [] } },+ }),+ );+ expect(usePromptStashStore.getState().entries).toEqual([]);});});diff --git a/apps/web/src/promptStashStore.ts b/apps/web/src/promptStashStore.tsindex e4340935b..d7c541e7a 100644--- a/apps/web/src/promptStashStore.ts+++ b/apps/web/src/promptStashStore.ts@@ -1,24 +1,20 @@-import { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";import * as Schema from "effect/Schema";import { create } from "zustand";import { PersistedComposerImageAttachment } from "./composerDraftStore";import { createMemoryStorage, type StateStorage } from "./lib/storage";-export const PROMPT_STASH_STORAGE_KEY = "t3code:prompt-stash:v1";-const PROMPT_STASH_STORAGE_VERSION = 1;-+export const PROMPT_STASH_STORAGE_KEY = "t3code:prompt-stash:v2";/**- * Queue bucket for prompts stashed while no provider instance is selected.- *- * Provider-scoped keys are prefixed (see `promptStashScopeKey`), so this- * sentinel can never collide with a provider literally named `__none__`.+ * v1 bucketed entries into per-provider-instance queues and stored a model+ * selection with each prompt. The stash is provider-agnostic now, so the old+ * payload is deleted at startup rather than migrated — left behind it would+ * silently hold megabytes of the origin's ~5MB localStorage quota forever.*/-export const PROMPT_STASH_UNSCOPED_KEY = "__none__";-/** Namespace applied to provider-derived keys to keep them collision-proof. */-const PROVIDER_SCOPE_PREFIX = "provider:";+const LEGACY_PROMPT_STASH_STORAGE_KEY = "t3code:prompt-stash:v1";+const PROMPT_STASH_STORAGE_VERSION = 2;-export const MAX_STASH_ENTRIES_PER_QUEUE = 20;+export const MAX_STASH_ENTRIES = 20;/*** Budget for an entry's serialized attachment payload. localStorage is a* ~5MB origin-wide quota shared with the composer draft store, so oversized@@ -30,13 +26,17 @@ export const MAX_STASH_ENTRIES_PER_QUEUE = 20;*/export const MAX_STASH_ENTRY_ATTACHMENT_CHARS = 2_700_000;+/**+ * A stashed prompt carries only what every provider can accept: text and+ * image attachments. Deliberately no provider instance or model selection —+ * the point of stashing is to move a prompt into a different thread or+ * provider, so restoring must never drag the old model choice along.+ */const StashEntrySchema = Schema.Struct({id: Schema.String,createdAt: Schema.String,prompt: Schema.String,attachments: Schema.Array(PersistedComposerImageAttachment),- providerInstanceId: Schema.NullOr(ProviderInstanceId),- modelSelection: Schema.NullOr(ModelSelection),/** Names of images that exceeded the attachment budget and were not saved. */droppedImageNames: Schema.Array(Schema.String),/**@@ -57,7 +57,7 @@ const StashEntrySchema = Schema.Struct({export type PromptStashEntry = typeof StashEntrySchema.Type;const PersistedPromptStashState = Schema.Struct({- queuesByScopeKey: Schema.Record(Schema.String, Schema.Array(StashEntrySchema)),+ entries: Schema.Array(StashEntrySchema),});type PersistedPromptStashState = typeof PersistedPromptStashState.Type;@@ -74,44 +74,23 @@ const decodePersistedPromptStashState = Schema.decodeUnknownSync(PersistedPrompt* recorded as unreadable to keep the prompt itself restorable.*/function clearOrphanedPendingImages(- queues: Record<string, ReadonlyArray<PromptStashEntry>>,-): Record<string, ReadonlyArray<PromptStashEntry>> {- const next: Record<string, ReadonlyArray<PromptStashEntry>> = {};- for (const [scopeKey, queue] of Object.entries(queues)) {- next[scopeKey] = queue.map((entry) => {- if (!entry.pendingImageCount) return entry;- const lostCount = entry.pendingImageCount;- return {- ...entry,- pendingImageCount: 0,- unreadableImageNames: [- ...(entry.unreadableImageNames ?? []),- ...Array.from(- { length: lostCount },- (_, index) => `image ${index + 1} (not saved before reload)`,- ),- ],- };- });- }- return next;-}--/** Maps the composer's active provider instance to a stash queue bucket. */-export function promptStashScopeKey(instanceId: ProviderInstanceId | null | undefined): string {- return instanceId ? `${PROVIDER_SCOPE_PREFIX}${instanceId}` : PROMPT_STASH_UNSCOPED_KEY;-}--/**- * Reads a queue without inheriting from `Object.prototype`. Scope keys derive- * from user-authored provider slugs, so a key like `__proto__` must not- * resolve to the prototype chain.- */-function readQueue(- queues: Record<string, ReadonlyArray<PromptStashEntry>>,- scopeKey: string,+ entries: ReadonlyArray<PromptStashEntry>,): ReadonlyArray<PromptStashEntry> {- return Object.hasOwn(queues, scopeKey) ? (queues[scopeKey] ?? []) : [];+ return entries.map((entry) => {+ if (!entry.pendingImageCount) return entry;+ const lostCount = entry.pendingImageCount;+ return {+ ...entry,+ pendingImageCount: 0,+ unreadableImageNames: [+ ...(entry.unreadableImageNames ?? []),+ ...Array.from(+ { length: lostCount },+ (_, index) => `image ${index + 1} (not saved before reload)`,+ ),+ ],+ };+ });}/**@@ -163,7 +142,7 @@ function resolveBaseStorage(): { storage: StateStorage; durable: boolean } {const { storage: baseStashStorage, durable: storageIsDurable } = resolveBaseStorage();/**- * Persists the queues, immediately rather than debounced. Stashing is a+ * Persists the queue, immediately rather than debounced. Stashing is a* deliberate, infrequent keystroke — not a per-character autosave — so there* is nothing to coalesce, and the caller clears the composer on the strength* of this write landing, which a debounce timer cannot honestly report.@@ -171,7 +150,7 @@ const { storage: baseStashStorage, durable: storageIsDurable } = resolveBaseStor* Returns whether the write will survive a reload: false on a quota rejection* or when only the in-memory fallback is available.*/-function persistQueues(queues: Record<string, ReadonlyArray<PromptStashEntry>>): {+function persistEntries(entries: ReadonlyArray<PromptStashEntry>): {/** The write succeeded (possibly only into the in-memory fallback). */written: boolean;/** The write will survive a reload. */@@ -182,7 +161,7 @@ function persistQueues(queues: Record<string, ReadonlyArray<PromptStashEntry>>):PROMPT_STASH_STORAGE_KEY,JSON.stringify({version: PROMPT_STASH_STORAGE_VERSION,- state: { queuesByScopeKey: queues },+ state: { entries },}),);return { written: true, durable: storageIsDurable };@@ -192,40 +171,42 @@ function persistQueues(queues: Record<string, ReadonlyArray<PromptStashEntry>>):}}-/** Reads the persisted queues, settling stale pending counts. */-function readPersistedQueues(): Record<string, ReadonlyArray<PromptStashEntry>> | null {+/** Reads the persisted queue, settling stale pending counts. */+function readPersistedEntries(): ReadonlyArray<PromptStashEntry> | null {try {const raw = baseStashStorage.getItem(PROMPT_STASH_STORAGE_KEY);if (typeof raw !== "string" || raw.length === 0) return null;const parsed: unknown = JSON.parse(raw);const state = (parsed as { state?: unknown } | null)?.state;if (!state) return null;- return clearOrphanedPendingImages(decodePersistedPromptStashState(state).queuesByScopeKey);+ return clearOrphanedPendingImages(decodePersistedPromptStashState(state).entries);} catch {return null;}}interface PromptStashStoreState {- queuesByScopeKey: Record<string, ReadonlyArray<PromptStashEntry>>;+ entries: ReadonlyArray<PromptStashEntry>;/**- * Prepends an entry to its scope's queue, evicting the oldest entry past- * the per-queue cap. Returns the evicted entry (for messaging) if any.+ * Prepends an entry to the queue, evicting the oldest entry past the cap.+ * Returns the evicted entry (for messaging) if any.*/stashEntry: (entry: PromptStashEntry) => {evicted: PromptStashEntry | null;- /** False when the write did not reach durable storage; nothing was kept. */+ /** False when the write failed outright (e.g. quota); nothing was kept. */+ written: boolean;+ /**+ * False when the write will not survive a reload: either it failed, or it+ * landed only in the in-memory fallback because localStorage is blocked.+ */durable: boolean;};/**- * Removes and returns an entry from a scope's queue (restore + delete).+ * Removes and returns an entry from the queue (restore + delete).* `durable` is false when the removal could not be persisted, meaning a* reload would resurrect the entry.*/- takeEntry: (- scopeKey: string,- entryId: string,- ) => { entry: PromptStashEntry | null; durable: boolean };+ takeEntry: (entryId: string) => { entry: PromptStashEntry | null; durable: boolean };/*** Attaches the encoded images to an entry written earlier by `stashEntry`,* clearing its pending count. Returns attached=false when the entry is gone@@ -233,7 +214,6 @@ interface PromptStashStoreState {* tell the user their images did not make it.*/finalizeEntryImages: (- scopeKey: string,entryId: string,images: {attachments: ReadonlyArray<PersistedComposerImageAttachment>;@@ -244,58 +224,45 @@ interface PromptStashStoreState {}export const usePromptStashStore = create<PromptStashStoreState>()((set, get) => ({- queuesByScopeKey: {},+ entries: [],stashEntry: (entry) => {- const scopeKey = promptStashScopeKey(entry.providerInstanceId);- const queues = get().queuesByScopeKey;- const nextQueue = [entry, ...readQueue(queues, scopeKey)];- const evicted =- nextQueue.length > MAX_STASH_ENTRIES_PER_QUEUE ? (nextQueue.pop() ?? null) : null;- const next = { ...queues, [scopeKey]: nextQueue };- const { written, durable } = persistQueues(next);+ const nextEntries = [entry, ...get().entries];+ const evicted = nextEntries.length > MAX_STASH_ENTRIES ? (nextEntries.pop() ?? null) : null;+ const { written, durable } = persistEntries(nextEntries);// A rejected write must not leave the entry visible either: the caller// keeps the composer intact on failure, so a stashed copy would// duplicate the prompt. Eviction likewise only sticks on success.if (!written) {- return { evicted: null, durable: false };+ return { evicted: null, written: false, durable: false };}- set(() => ({ queuesByScopeKey: next }));- return { evicted, durable };+ set(() => ({ entries: nextEntries }));+ return { evicted, written: true, durable };},- takeEntry: (scopeKey, entryId) => {- const queues = get().queuesByScopeKey;- const queue = readQueue(queues, scopeKey);- const entry = queue.find((candidate) => candidate.id === entryId) ?? null;+ takeEntry: (entryId) => {+ const entries = get().entries;+ const entry = entries.find((candidate) => candidate.id === entryId) ?? null;if (!entry) return { entry: null, durable: true };- const nextQueue = queue.filter((candidate) => candidate.id !== entryId);- const next = { ...queues };- if (nextQueue.length === 0) {- delete next[scopeKey];- } else {- next[scopeKey] = nextQueue;- }- const { durable } = persistQueues(next);- set(() => ({ queuesByScopeKey: next }));+ const nextEntries = entries.filter((candidate) => candidate.id !== entryId);+ const { durable } = persistEntries(nextEntries);+ set(() => ({ entries: nextEntries }));return { entry, durable };},- finalizeEntryImages: (scopeKey, entryId, images) => {- const queues = get().queuesByScopeKey;- const queue = readQueue(queues, scopeKey);- const index = queue.findIndex((candidate) => candidate.id === entryId);- const existing = index === -1 ? undefined : queue[index];+ finalizeEntryImages: (entryId, images) => {+ const entries = get().entries;+ const index = entries.findIndex((candidate) => candidate.id === entryId);+ const existing = index === -1 ? undefined : entries[index];// Restored or deleted mid-encode: nothing to attach to.if (!existing) return { attached: false, durable: true };- const nextQueue = [...queue];- nextQueue[index] = {+ const nextEntries = [...entries];+ nextEntries[index] = {...existing,attachments: images.attachments,droppedImageNames: images.droppedImageNames,unreadableImageNames: images.unreadableImageNames,pendingImageCount: 0,};- const next = { ...queues, [scopeKey]: nextQueue };- const { durable } = persistQueues(next);- set(() => ({ queuesByScopeKey: next }));+ const { durable } = persistEntries(nextEntries);+ set(() => ({ entries: nextEntries }));return { attached: true, durable };},}));@@ -303,14 +270,18 @@ export const usePromptStashStore = create<PromptStashStoreState>()((set, get) =>// Hydrate once at startup. Like the app's other persisted stores, tabs are// last-write-wins: no cross-tab merging or storage-event syncing.{- const persisted = readPersistedQueues();+ try {+ baseStashStorage.removeItem(LEGACY_PROMPT_STASH_STORAGE_KEY);+ } catch {+ // Purging the v1 payload is best-effort; a storage policy that rejects+ // the delete must not take down module init.+ }+ const persisted = readPersistedEntries();if (persisted) {- usePromptStashStore.setState({ queuesByScopeKey: persisted });+ usePromptStashStore.setState({ entries: persisted });}}-export const EMPTY_PROMPT_STASH_QUEUE: ReadonlyArray<PromptStashEntry> = [];-/*** Test seam: seeds the persisted payload through the same storage the store* reads and rehydrates, without needing a real `localStorage` global.@@ -318,5 +289,5 @@ export const EMPTY_PROMPT_STASH_QUEUE: ReadonlyArray<PromptStashEntry> = [];*/export function writePromptStashStorageForTest(raw: string): void {baseStashStorage.setItem(PROMPT_STASH_STORAGE_KEY, raw);- usePromptStashStore.setState({ queuesByScopeKey: readPersistedQueues() ?? {} });+ usePromptStashStore.setState({ entries: readPersistedEntries() ?? [] });}