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.
feat(web): prompt stash — cmd+S saves the composer to a per-provider queue (#4453)
Theo Browne200fa826b02c
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsxindex b427037bd..866ed0c9b 100644--- a/apps/web/src/components/chat/ChatComposer.tsx+++ b/apps/web/src/components/chat/ChatComposer.tsx@@ -51,13 +51,29 @@ import {type ComposerImageAttachment,type DraftId,type PersistedComposerImageAttachment,+ hydrateImagesFromPersisted,useComposerDraftStore,useComposerThreadDraft,useEffectiveComposerModelState,} from "../../composerDraftStore";+import {+ EMPTY_PROMPT_STASH_QUEUE,+ MAX_STASH_ENTRIES_PER_QUEUE,+ partitionStashAttachments,+ promptStashScopeKey,+ usePromptStashStore,+ type PromptStashEntry,+} from "../../promptStashStore";+import { ComposerStashBadge } from "./ComposerStashBadge";+import { ComposerStashMenu } from "./ComposerStashMenu";+import { compressImageForStash } from "../../lib/stashImageCompression";+import { isCommandPaletteOpen } from "../../commandPaletteBus";+import { getTerminalFocusOwner } from "../../lib/terminalFocus";+import { resolveShortcutCommand } from "../../keybindings";import {type TerminalContextDraft,type TerminalContextSelection,+ INLINE_TERMINAL_CONTEXT_PLACEHOLDER,insertInlineTerminalContextPlaceholder,removeInlineTerminalContextPlaceholder,} from "../../lib/terminalContext";@@ -723,6 +739,10 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const clearComposerDraftPersistedAttachments = useComposerDraftStore((store) => store.clearPersistedAttachments,);+ const clearComposerDraftPromptAndImages = useComposerDraftStore(+ (store) => store.clearComposerPromptAndImages,+ );+ const setComposerDraftModelSelection = useComposerDraftStore((store) => store.setModelSelection);const syncComposerDraftPersistedAttachments = useComposerDraftStore((store) => store.syncPersistedAttachments,);@@ -961,6 +981,11 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const [isComposerModelPickerOpen, setIsComposerModelPickerOpen] = useState(false);const [isComposerFocused, setIsComposerFocused] = useState(false);const [composerMenuAnchor, setComposerMenuAnchor] = useState<HTMLDivElement | null>(null);+ const [isStashMenuOpen, setIsStashMenuOpen] = useState(false);+ const [stashPulse, setStashPulse] = useState<{ key: number; active: boolean }>({+ key: 0,+ active: false,+ });const isMobileViewport = useMediaQuery("max-sm");const isComposerCollapsedMobile =isMobileViewport && !forceExpandedOnMobile && !isComposerFocused;@@ -980,6 +1005,14 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)const mobileComposerExpandReleaseFrameRef = useRef<number | null>(null);const mobileComposerExpandInFlightRef = useRef(false);const dragDepthRef = useRef(0);+ const stashPulseKeyRef = useRef(0);+ const stashPulseTimeoutRef = useRef<number | null>(null);+ /**+ * Snapshots currently being encoded, keyed by target+prompt+image ids.+ * Keyed rather than boolean so a genuinely different prompt (or a different+ * thread) can still be stashed while an earlier encode is running.+ */+ const stashInFlightRef = useRef<Set<string>>(new Set());// ------------------------------------------------------------------// Derived: composer send state@@ -1861,6 +1894,400 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)return false;};+ // ------------------------------------------------------------------+ // 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,+ ),+ );+ 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 () => {+ if (stashPulseTimeoutRef.current !== null) {+ window.clearTimeout(stashPulseTimeoutRef.current);+ }+ };+ }, []);++ /** Briefly highlight the badge so the save registers without a flourish. */+ const pulseStashBadge = useCallback(() => {+ stashPulseKeyRef.current += 1;+ setStashPulse({ key: stashPulseKeyRef.current, active: true });+ if (stashPulseTimeoutRef.current !== null) {+ window.clearTimeout(stashPulseTimeoutRef.current);+ }+ stashPulseTimeoutRef.current = window.setTimeout(() => {+ stashPulseTimeoutRef.current = null;+ setStashPulse((current) => ({ ...current, active: false }));+ }, 1200);+ }, []);++ 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,+ );+ if (!taken) return;+ if (!durable) {+ toastManager.add({+ type: "warning",+ title: "Restored prompt may reappear in the stash",+ description:+ "Browser storage rejected the update, so this entry could still be there after a reload.",+ data: { hideCopyButton: true },+ });+ }+ setIsStashMenuOpen(false);++ const currentPrompt = promptRef.current;+ // An image-only stash must not append blank lines to whatever is+ // already in the composer.+ const nextPrompt =+ entry.prompt.length === 0+ ? currentPrompt+ : currentPrompt.trim().length+ ? `${currentPrompt.replace(/\s+$/, "")}\n\n${entry.prompt}`+ : entry.prompt;+ const promptChanged = nextPrompt !== currentPrompt;+ if (promptChanged) {+ promptRef.current = nextPrompt;+ setComposerDraftPrompt(composerDraftTarget, nextPrompt);+ setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));+ setComposerTrigger(null);+ }++ let unrestoredImageNames: string[] = [];+ if (entry.attachments.length > 0) {+ const existingIds = new Set(composerImagesRef.current.map((image) => image.id));+ // The draft store also dedupes by mimeType+sizeBytes+name, so filter+ // on the same key here. Counting a duplicate against capacity would+ // burn a slot the store then refuses to fill, pushing a genuinely+ // unique image into the overflow list for nothing.+ const existingDedupKeys = new Set(+ composerImagesRef.current.map(+ (image) => `${image.mimeType} ${image.sizeBytes} ${image.name}`,+ ),+ );+ const capacity = Math.max(+ 0,+ PROVIDER_SEND_TURN_MAX_ATTACHMENTS - composerImagesRef.current.length,+ );+ const pending = entry.attachments.filter(+ (attachment) =>+ !existingIds.has(attachment.id) &&+ !existingDedupKeys.has(+ `${attachment.mimeType} ${attachment.sizeBytes} ${attachment.name}`,+ ),+ );+ // Anything past the attachment limit cannot be restored. The entry is+ // already out of the queue, so report the overflow by name instead of+ // discarding it silently.+ unrestoredImageNames = pending.slice(capacity).map((attachment) => attachment.name);+ const restoredImages = hydrateImagesFromPersisted(pending.slice(0, capacity));+ if (restoredImages.length > 0) {+ addComposerDraftImages(composerDraftTarget, restoredImages);+ }+ }++ 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,+ });+ }++ // 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+ // had no room to take back.+ const missingImageReasons: string[] = [];+ if (entry.droppedImageNames.length > 0) {+ missingImageReasons.push(+ `${entry.droppedImageNames.join(", ")} exceeded the stash size limit when this prompt was saved.`,+ );+ }+ if (entry.unreadableImageNames && entry.unreadableImageNames.length > 0) {+ missingImageReasons.push(+ `${entry.unreadableImageNames.join(", ")} could not be read when this prompt was saved.`,+ );+ }+ if (unrestoredImageNames.length > 0) {+ missingImageReasons.push(+ `${unrestoredImageNames.join(", ")} could not be restored: the composer is at its ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS}-image limit.`,+ );+ }+ if (missingImageReasons.length > 0) {+ toastManager.add({+ type: "warning",+ title: "Some images were not restored",+ description: missingImageReasons.join(" "),+ });+ }++ // Only yank the caret to the end when text was actually inserted;+ // restoring images alone should leave the user where they were typing.+ if (promptChanged) {+ window.requestAnimationFrame(() => {+ composerEditorRef.current?.focusAtEnd();+ });+ }+ },+ [+ addComposerDraftImages,+ composerDraftTarget,+ composerImagesRef,+ promptRef,+ providerInstanceEntries,+ setComposerDraftModelSelection,+ setComposerDraftPrompt,+ takeStashEntry,+ ],+ );++ const deleteStashEntry = useCallback(+ (entry: PromptStashEntry) => {+ const { durable } = takeStashEntry(promptStashScopeKey(entry.providerInstanceId), entry.id);+ if (!durable) {+ toastManager.add({+ type: "warning",+ title: "Stash entry may come back",+ description:+ "Browser storage rejected the delete, so this prompt could reappear after a reload.",+ data: { hideCopyButton: true },+ });+ }+ },+ [takeStashEntry],+ );++ const stashCurrentPrompt = useCallback(async () => {+ // Terminal-context placeholders reference live sessions the stash can't+ // round-trip, so they are stripped from the stashed prompt.+ const prompt = promptRef.current.split(INLINE_TERMINAL_CONTEXT_PLACEHOLDER).join("").trim();+ const images = [...composerImagesRef.current];+ if (prompt.length === 0 && images.length === 0) {+ setIsStashMenuOpen((open) => !open);+ return;+ }+ // A repeat ⌘S on the *same* still-unencoded snapshot would stash it+ // twice. Guard on the snapshot itself rather than a bare boolean: once+ // the composer has been cleared the user can type something genuinely+ // new (or switch threads) while encoding continues, and that deserves its+ // own entry.+ const snapshotKey = `${String(composerDraftTarget)} ${prompt} ${images+ .map((image) => image.id)+ .join(",")}`;+ if (stashInFlightRef.current.has(snapshotKey)) return;+ stashInFlightRef.current.add(snapshotKey);++ 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({+ 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) {+ toastManager.add({+ type: "error",+ title: "Could not stash this prompt",+ description:+ "Browser storage rejected the write, so the composer was left as-is. Free up site data and try again.",+ data: { hideCopyButton: true },+ });+ return;+ }++ // Only the prompt and images are cleared — terminal/element contexts,+ // preview annotations, and review comments are not stashable, so+ // destroying them here would be unrecoverable.+ promptRef.current = "";+ clearComposerDraftPromptAndImages(stashTarget);+ setComposerCursor(0);+ setComposerTrigger(null);+ pulseStashBadge();++ if (evicted) {+ 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.`,+ data: { hideCopyButton: true },+ });+ }++ // Images are re-encoded for the stash rather than stored verbatim: the+ // composer allows up to 10MB per image, but localStorage gives the whole+ // origin ~5MB. Only the stashed copy shrinks; the live attachment (and+ // anything sent without stashing) keeps the original file.+ const candidateAttachments: PersistedComposerImageAttachment[] = [];+ const oversizedImageNames: string[] = [];+ const unreadableImageNames: string[] = [];+ for (const image of images) {+ const result = await compressImageForStash(image.file);+ if (!result.ok) {+ // "too large" and "could not be read" are distinct outcomes; the+ // menu and restore toast report them separately.+ (result.reason === "too-large" ? oversizedImageNames : unreadableImageNames).push(+ image.name,+ );+ continue;+ }+ candidateAttachments.push({+ id: image.id,+ name: image.name,+ mimeType: result.image.mimeType,+ sizeBytes: result.image.sizeBytes,+ dataUrl: result.image.dataUrl,+ });+ }+ const { kept, droppedNames } = partitionStashAttachments(candidateAttachments);++ const { attached, durable: imagesDurable } = finalizeStashEntryImages(scopeKey, entryId, {+ attachments: kept,+ droppedImageNames: [...oversizedImageNames, ...droppedNames],+ unreadableImageNames,+ });+ if (attached) {+ // 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) {+ toastManager.add({+ type: "warning",+ title: "Stashed images were not saved",+ description:+ "The prompt was stashed, but browser storage rejected its images. They will be missing if you reload.",+ data: { hideCopyButton: true },+ });+ }+ } else if (kept.length > 0) {+ // The entry was restored or deleted before its images finished+ // encoding, so they have nowhere to land. Say so rather than letting+ // them evaporate.+ toastManager.add({+ type: "warning",+ title: "Stashed images did not attach",+ description: `That prompt was restored or deleted before ${kept.length} image${kept.length === 1 ? "" : "s"} finished saving. Re-attach ${kept.length === 1 ? "it" : "them"} if you still need ${kept.length === 1 ? "it" : "them"}.`,+ data: { hideCopyButton: true },+ });+ }+ } finally {+ // Must clear on every path: a throw that left this set would wedge this+ // snapshot's ⌘S until the composer remounts.+ stashInFlightRef.current.delete(snapshotKey);+ }+ }, [+ clearComposerDraftPromptAndImages,+ composerDraftTarget,+ composerImagesRef,+ finalizeStashEntryImages,+ noProviderAvailable,+ promptRef,+ pulseStashBadge,+ selectedModelSelection,+ stashEntryToQueue,+ stashProviderLabel,+ stashScopeInstanceId,+ ]);++ const toggleStashMenu = useCallback(() => {+ setIsStashMenuOpen((open) => !open);+ }, []);++ // Close the stash menu whenever the trigger-driven command menu opens so+ // the two popovers never stack in the same layer, and when the user+ // resumes typing (the menu is a transient picker, not a panel).+ useEffect(() => {+ if (composerMenuOpen) {+ setIsStashMenuOpen(false);+ }+ }, [composerMenuOpen]);+ useEffect(() => {+ setIsStashMenuOpen(false);+ }, [prompt]);++ useEffect(() => {+ const handler = (event: globalThis.KeyboardEvent) => {+ const command = resolveShortcutCommand(event, keybindings, {+ context: {+ terminalFocus: getTerminalFocusOwner() !== null,+ terminalOpen,+ modelPickerOpen: isComposerModelPickerOpen,+ },+ });+ if (command !== "composer.stash") return;+ // Always claim the shortcut so the browser save dialog never opens,+ // even when the composer is in a state that can't stash.+ event.preventDefault();+ event.stopPropagation();+ if (+ isCommandPaletteOpen() ||+ isComposerApprovalState ||+ pendingUserInputs.length > 0 ||+ projectSelectionRequired ||+ activePendingProgress !== null+ ) {+ return;+ }+ void stashCurrentPrompt();+ };+ window.addEventListener("keydown", handler, true);+ return () => window.removeEventListener("keydown", handler, true);+ }, [+ activePendingProgress,+ isComposerApprovalState,+ isComposerModelPickerOpen,+ keybindings,+ pendingUserInputs.length,+ projectSelectionRequired,+ stashCurrentPrompt,+ terminalOpen,+ ]);+// ------------------------------------------------------------------// Callbacks: images// ------------------------------------------------------------------@@ -2402,6 +2829,27 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)isComposerCollapsedMobile && "hidden",)}>+ <ComposerStashBadge+ count={stashQueue.length}+ pulseKey={stashPulse.key}+ pulsing={stashPulse.active}+ menuOpen={isStashMenuOpen}+ onToggleMenu={toggleStashMenu}+ />++ {isStashMenuOpen && !composerMenuOpen && !isComposerApprovalState && (+ <ComposerCommandMenuLayer anchor={composerMenuAnchor}>+ <ComposerStashMenu+ entries={stashQueue}+ providerLabel={stashProviderLabel}+ otherScopesCount={stashOtherScopesCount}+ onRestore={restoreStashEntry}+ onDelete={deleteStashEntry}+ onClose={() => setIsStashMenuOpen(false)}+ />+ </ComposerCommandMenuLayer>+ )}+{composerMenuOpen && !isComposerApprovalState && (<ComposerCommandMenuLayer anchor={composerMenuAnchor}><ComposerCommandMenudiff --git a/apps/web/src/components/chat/ComposerStashBadge.tsx b/apps/web/src/components/chat/ComposerStashBadge.tsxnew file mode 100644index 000000000..cb2d98339--- /dev/null+++ b/apps/web/src/components/chat/ComposerStashBadge.tsx@@ -0,0 +1,58 @@+import { BookmarkIcon } from "lucide-react";+import { memo } from "react";++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.+ *+ * On save the badge gives one quiet acknowledgement: it lifts to full+ * opacity and the count ticks over. `pulseKey` changes per stash, remounting+ * the count so the transition replays without a continuous animation.+ */+export const ComposerStashBadge = memo(function ComposerStashBadge(props: {+ count: number;+ pulseKey: number;+ pulsing: boolean;+ menuOpen: boolean;+ onToggleMenu: () => void;+}) {+ if (props.count === 0) return null;++ return (+ <button+ type="button"+ data-prompt-stash-badge="true"+ aria-label={`Stashed prompts: ${props.count}. Open stash.`}+ aria-expanded={props.menuOpen}+ className={cn(+ "absolute -top-3 right-4 z-10 inline-flex cursor-pointer items-center gap-1.5 rounded-full border bg-popover px-2.5 py-0.5 text-xs shadow-sm",+ "transition-[color,border-color,opacity] duration-200",+ props.menuOpen || props.pulsing+ ? "border-border text-foreground opacity-100"+ : "border-border/70 text-muted-foreground opacity-70 hover:opacity-100 hover:text-foreground",+ )}+ onPointerDown={(event) => {+ // Keep composer focus so Escape/typing flows stay intact.+ event.preventDefault();+ }}+ onClick={props.onToggleMenu}+ >+ <BookmarkIcon className="size-3" aria-hidden="true" />+ Stash+ <span+ key={props.pulseKey}+ className={cn(+ "rounded-full px-1.5 text-[10px] font-medium tabular-nums",+ props.pulsing+ ? "prompt-stash-count-enter bg-primary text-primary-foreground"+ : "bg-muted text-muted-foreground",+ )}+ >+ {props.count}+ </span>+ </button>+ );+});diff --git a/apps/web/src/components/chat/ComposerStashMenu.tsx b/apps/web/src/components/chat/ComposerStashMenu.tsxnew file mode 100644index 000000000..229500743--- /dev/null+++ b/apps/web/src/components/chat/ComposerStashMenu.tsx@@ -0,0 +1,186 @@+import { BookmarkIcon, XIcon } from "lucide-react";+import { memo, useEffect, useState } from "react";++import { formatRelativeTimeLabel } from "../../timestampFormat";+import { cn } from "~/lib/utils";+import { type PromptStashEntry } from "../../promptStashStore";+import { Command, CommandGroup, CommandGroupLabel, CommandItem, CommandList } from "../ui/command";+import { Button } from "../ui/button";++const SNIPPET_MAX_CHARS = 90;++/** Images that did not make it into the entry, whatever the reason. */+function missingImageCount(entry: PromptStashEntry): number {+ return entry.droppedImageNames.length + (entry.unreadableImageNames?.length ?? 0);+}++function stashEntrySnippet(entry: PromptStashEntry): string {+ const trimmed = entry.prompt.trim().replace(/\s+/g, " ");+ if (trimmed.length > 0) {+ return trimmed.length > SNIPPET_MAX_CHARS ? `${trimmed.slice(0, SNIPPET_MAX_CHARS)}…` : trimmed;+ }+ const imageCount = entry.attachments.length + entry.droppedImageNames.length;+ return imageCount > 0 ? `(${imageCount} image${imageCount === 1 ? "" : "s"})` : "(empty)";+}++/**+ * 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.+ */+export const ComposerStashMenu = memo(function ComposerStashMenu(props: {+ entries: ReadonlyArray<PromptStashEntry>;+ providerLabel: string;+ otherScopesCount: number;+ onRestore: (entry: PromptStashEntry) => void;+ onDelete: (entry: PromptStashEntry) => void;+ onClose: () => void;+}) {+ const { entries, onRestore, onDelete, onClose } = props;+ const [highlightedId, setHighlightedId] = useState<string | null>(entries[0]?.id ?? null);++ const highlightedEntry = entries.find((entry) => entry.id === highlightedId) ?? entries[0];++ useEffect(() => {+ if (entries.length === 0) return;+ if (!entries.some((entry) => entry.id === highlightedId)) {+ setHighlightedId(entries[0]?.id ?? null);+ }+ }, [entries, highlightedId]);++ useEffect(() => {+ const handler = (event: KeyboardEvent) => {+ if (event.key === "Escape") {+ event.preventDefault();+ event.stopPropagation();+ onClose();+ return;+ }+ if (event.key === "ArrowDown" || event.key === "ArrowUp") {+ if (entries.length === 0) return;+ event.preventDefault();+ event.stopPropagation();+ const currentIndex = entries.findIndex((entry) => entry.id === highlightedId);+ const offset = event.key === "ArrowDown" ? 1 : -1;+ const normalizedIndex = currentIndex >= 0 ? currentIndex : offset === 1 ? -1 : 0;+ const nextIndex = (normalizedIndex + offset + entries.length) % entries.length;+ setHighlightedId(entries[nextIndex]?.id ?? null);+ return;+ }+ if (event.key === "Enter") {+ // A focused control inside the row (the delete button) owns its own+ // activation; swallowing Enter here would restore instead of delete.+ if (event.target instanceof HTMLElement && event.target.closest("button[aria-label]")) {+ return;+ }+ if (!highlightedEntry) return;+ event.preventDefault();+ event.stopPropagation();+ onRestore(highlightedEntry);+ return;+ }+ if (event.key === "Backspace" && (event.metaKey || event.ctrlKey)) {+ if (!highlightedEntry) return;+ event.preventDefault();+ event.stopPropagation();+ onDelete(highlightedEntry);+ }+ };+ window.addEventListener("keydown", handler, true);+ return () => window.removeEventListener("keydown", handler, true);+ }, [entries, highlightedEntry, highlightedId, onClose, onDelete, onRestore]);++ return (+ <Command autoHighlight={false} mode="none">+ <div className="dropdown-glass relative w-full overflow-hidden rounded-[20px]">+ <CommandList className="max-h-72">+ <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}+ </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.+ </p>+ ) : (+ entries.map((entry) => (+ <CommandItem+ key={entry.id}+ value={entry.id}+ className={cn(+ "group/stash cursor-pointer select-none gap-2 hover:bg-transparent hover:text-inherit data-highlighted:bg-transparent data-highlighted:text-inherit",+ highlightedId === entry.id && "bg-accent! text-accent-foreground!",+ )}+ onMouseMove={() => {+ if (highlightedId !== entry.id) setHighlightedId(entry.id);+ }}+ onMouseDown={(event) => {+ event.preventDefault();+ }}+ onClick={() => {+ onRestore(entry);+ }}+ >+ {entry.attachments.length > 0 ? (+ <span className="flex shrink-0 items-center -space-x-1.5">+ {entry.attachments.slice(0, 3).map((attachment) => (+ <img+ key={attachment.id}+ src={attachment.dataUrl}+ alt=""+ aria-hidden="true"+ className="size-5 rounded border border-border/70 object-cover"+ />+ ))}+ </span>+ ) : (+ <BookmarkIcon className="size-4 shrink-0 text-muted-foreground/60" />+ )}+ <span className="min-w-0 flex-1 truncate text-sm">+ {stashEntrySnippet(entry)}+ </span>+ {entry.pendingImageCount ? (+ <span className="shrink-0 text-[10px] text-muted-foreground/60">+ saving {entry.pendingImageCount} image+ {entry.pendingImageCount === 1 ? "" : "s"}…+ </span>+ ) : missingImageCount(entry) > 0 ? (+ <span className="shrink-0 text-[10px] text-amber-600">+ {missingImageCount(entry)} image+ {missingImageCount(entry) === 1 ? "" : "s"} dropped+ </span>+ ) : null}+ <span className="shrink-0 text-muted-foreground/60 text-xs">+ {formatRelativeTimeLabel(entry.createdAt)}+ </span>+ <Button+ variant="ghost"+ size="icon-xs"+ className="shrink-0 opacity-0 transition-opacity group-hover/stash:opacity-100"+ aria-label="Delete stashed prompt"+ onClick={(event) => {+ event.stopPropagation();+ onDelete(entry);+ }}+ >+ <XIcon />+ </Button>+ </CommandItem>+ ))+ )}+ </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/composerDraftStore.ts b/apps/web/src/composerDraftStore.tsindex d4f38adca..16c99abad 100644--- a/apps/web/src/composerDraftStore.ts+++ b/apps/web/src/composerDraftStore.ts@@ -495,6 +495,13 @@ interface ComposerDraftStoreState {attachments: PersistedComposerImageAttachment[],) => void;clearComposerContent: (threadRef: ComposerThreadTarget) => void;+ /**+ * Clears only the prompt text and image attachments, preserving terminal /+ * element contexts, preview annotations, and review comments. Used by the+ * prompt stash, which can only round-trip text + images: clearing the+ * session-bound contexts would destroy state nothing can restore.+ */+ clearComposerPromptAndImages: (threadRef: ComposerThreadTarget) => void;}export interface EffectiveComposerModelState {@@ -2091,7 +2098,7 @@ function hydratePersistedComposerImageAttachment(}}-function hydrateImagesFromPersisted(+export function hydrateImagesFromPersisted(attachments: ReadonlyArray<PersistedComposerImageAttachment>,): ComposerImageAttachment[] {return attachments.flatMap((attachment) => {@@ -3347,6 +3354,35 @@ const composerDraftStore = create<ComposerDraftStoreState>()(return { draftsByThreadKey: nextDraftsByThreadKey };});},+ clearComposerPromptAndImages: (threadRef) => {+ const threadKey = resolveComposerDraftKey(get(), threadRef) ?? "";+ if (threadKey.length === 0) {+ return;+ }+ set((state) => {+ const current = state.draftsByThreadKey[threadKey];+ if (!current) {+ return state;+ }+ for (const image of current.images) {+ revokeObjectPreviewUrl(image.previewUrl);+ }+ const nextDraft: ComposerThreadDraftState = {+ ...current,+ prompt: ensureInlineTerminalContextPlaceholders("", current.terminalContexts.length),+ images: [],+ nonPersistedImageIds: [],+ persistedAttachments: [],+ };+ const nextDraftsByThreadKey = { ...state.draftsByThreadKey };+ if (shouldRemoveDraft(nextDraft)) {+ delete nextDraftsByThreadKey[threadKey];+ } else {+ nextDraftsByThreadKey[threadKey] = nextDraft;+ }+ return { draftsByThreadKey: nextDraftsByThreadKey };+ });+ },};},{diff --git a/apps/web/src/index.css b/apps/web/src/index.cssindex 29dd99b8e..19c058455 100644--- a/apps/web/src/index.css+++ b/apps/web/src/index.css@@ -1432,6 +1432,30 @@ label:has(> select#reasoning-effort) select {margin-top: 0.125rem;}+/* Prompt-stash save acknowledgement: the new count fades up from just below+ its resting position, once, then stops. One-shot and event-driven (React+ remounts the element by key on each stash) — no continuous animation. */+@keyframes prompt-stash-count-enter {+ from {+ opacity: 0;+ transform: translateY(2px);+ }+ to {+ opacity: 1;+ transform: translateY(0);+ }+}++.prompt-stash-count-enter {+ animation: prompt-stash-count-enter 180ms ease-out both;+}++@media (prefers-reduced-motion: reduce) {+ .prompt-stash-count-enter {+ animation: none;+ }+}+@keyframes provider-update-pill-countdown {from {transform: scaleX(1);diff --git a/apps/web/src/lib/stashImageCompression.test.ts b/apps/web/src/lib/stashImageCompression.test.tsnew file mode 100644index 000000000..aaffa284c--- /dev/null+++ b/apps/web/src/lib/stashImageCompression.test.ts@@ -0,0 +1,198 @@+import { afterEach, describe, expect, it, vi } from "vite-plus/test";++import { compressImageForStash, MAX_STASH_IMAGE_DATA_URL_CHARS } from "./stashImageCompression";++/**+ * jsdom has no real canvas/codec, so the re-encode path is exercised with+ * stubbed `createImageBitmap` + `OffscreenCanvas`. The encoder stub returns a+ * payload whose size scales with quality, mirroring how a real JPEG encoder+ * shrinks as quality drops — enough to verify the ladder logic and budget+ * enforcement without pulling in a native canvas.+ */++const originalCreateImageBitmap = globalThis.createImageBitmap;+const originalOffscreenCanvas = globalThis.OffscreenCanvas;++function makeFile(sizeBytes: number, type = "image/png"): File {+ return new File([new Uint8Array(sizeBytes).fill(7)], "shot.png", { type });+}++/**+ * Installs a fake bitmap + canvas whose encoded size follows `sizeForQuality`.+ * `supportsWebp: false` makes `convertToBlob` hand back a differently-typed+ * blob for WebP requests, which is how a real browser signals it cannot+ * encode that format.+ */+function stubCanvasPipeline(+ sizeForQuality: (quality: number) => number,+ options?: { supportsWebp?: boolean },+) {+ const supportsWebp = options?.supportsWebp ?? true;+ const close = vi.fn();+ const fillRect = vi.fn();+ vi.stubGlobal(+ "createImageBitmap",+ vi.fn(async () => ({ width: 4000, height: 3000, close })),+ );+ vi.stubGlobal(+ "OffscreenCanvas",+ class {+ constructor(+ public width: number,+ public height: number,+ ) {}+ getContext() {+ return {+ fillStyle: "",+ fillRect,+ drawImage: vi.fn(),+ };+ }+ async convertToBlob({ type, quality }: { type: string; quality: number }) {+ const resolvedType = type === "image/webp" && !supportsWebp ? "image/png" : type;+ return new Blob([new Uint8Array(sizeForQuality(quality))], { type: resolvedType });+ }+ },+ );+ return { close, fillRect };+}++afterEach(() => {+ vi.unstubAllGlobals();+ globalThis.createImageBitmap = originalCreateImageBitmap;+ globalThis.OffscreenCanvas = originalOffscreenCanvas;+});++describe("compressImageForStash", () => {+ it("stores a small image verbatim without re-encoding", async () => {+ const bitmapSpy = vi.fn();+ vi.stubGlobal("createImageBitmap", bitmapSpy);++ const result = await compressImageForStash(makeFile(1024));++ expect(result.ok).toBe(true);+ expect(result.ok && result.image.recompressed).toBe(false);+ expect(result.ok && result.image.mimeType).toBe("image/png");+ expect(result.ok && result.image.dataUrl.startsWith("data:image/png")).toBe(true);+ // Untouched payloads must not pay for a decode.+ expect(bitmapSpy).not.toHaveBeenCalled();+ });++ it("re-encodes an oversized image to WebP within the budget", async () => {+ // Comfortably under budget at the very first quality step.+ const { close, fillRect } = stubCanvasPipeline(() => 120_000);++ const result = await compressImageForStash(makeFile(4_000_000));++ expect(result.ok).toBe(true);+ expect(result.ok && result.image.recompressed).toBe(true);+ expect(result.ok && result.image.mimeType).toBe("image/webp");+ expect(result.ok && result.image.dataUrl.length <= MAX_STASH_IMAGE_DATA_URL_CHARS).toBe(true);+ // sizeBytes should describe the re-encoded payload, not the 4MB original.+ expect(result.ok && result.image.sizeBytes).toBeLessThan(4_000_000);+ // WebP keeps alpha, so no white matte should be painted.+ expect(fillRect).not.toHaveBeenCalled();+ expect(close).toHaveBeenCalled();+ });++ it("falls back to JPEG with a white matte when WebP encoding is unavailable", async () => {+ const { fillRect } = stubCanvasPipeline(() => 120_000, { supportsWebp: false });++ const result = await compressImageForStash(makeFile(4_000_000));++ expect(result.ok && result.image.recompressed).toBe(true);+ expect(result.ok && result.image.mimeType).toBe("image/jpeg");+ // JPEG has no alpha, so transparent regions must be matted white.+ expect(fillRect).toHaveBeenCalled();+ });++ it("steps quality down until the encoded image fits", async () => {+ // Only the lowest quality step (0.68) lands under the budget.+ const { close } = stubCanvasPipeline((quality) => (quality <= 0.68 ? 400_000 : 3_000_000));++ const result = await compressImageForStash(makeFile(9_000_000));++ expect(result.ok && result.image.recompressed).toBe(true);+ expect(result.ok && result.image.dataUrl.length <= MAX_STASH_IMAGE_DATA_URL_CHARS).toBe(true);+ expect(close).toHaveBeenCalled();+ });++ it("reports too-large when even the smallest encoding overflows the budget", async () => {+ const { close } = stubCanvasPipeline(() => 8_000_000);++ const result = await compressImageForStash(makeFile(9_000_000));++ expect(result).toEqual({ ok: false, reason: "too-large" });+ // The bitmap must still be released on the give-up path.+ expect(close).toHaveBeenCalled();+ });++ it("reports too-large for an oversized image when the browser cannot re-encode", async () => {+ vi.stubGlobal("createImageBitmap", undefined);+ vi.stubGlobal("OffscreenCanvas", undefined);++ expect(await compressImageForStash(makeFile(4_000_000))).toEqual({+ ok: false,+ reason: "too-large",+ });+ });++ it("reports unreadable when the image fails to decode", async () => {+ vi.stubGlobal(+ "createImageBitmap",+ vi.fn(async () => {+ throw new Error("corrupt image");+ }),+ );+ vi.stubGlobal(+ "OffscreenCanvas",+ class {+ getContext() {+ return null;+ }+ },+ );++ expect(await compressImageForStash(makeFile(4_000_000))).toEqual({+ ok: false,+ reason: "unreadable",+ });+ });++ it("shrinks below the source size when the image is already under MAX_DIMENSION", async () => {+ // A small-but-heavy source (e.g. a dense PNG): only a real downscale can+ // get it under budget, since quality alone is stubbed to never suffice.+ let smallestRequested = Number.POSITIVE_INFINITY;+ const close = vi.fn();+ vi.stubGlobal(+ "createImageBitmap",+ vi.fn(async () => ({ width: 800, height: 600, close })),+ );+ vi.stubGlobal(+ "OffscreenCanvas",+ class {+ constructor(+ public width: number,+ public height: number,+ ) {+ smallestRequested = Math.min(smallestRequested, width);+ }+ getContext() {+ return { fillStyle: "", fillRect: vi.fn(), drawImage: vi.fn() };+ }+ async convertToBlob({ type }: { type: string; quality: number }) {+ // Only a genuinely downscaled pass fits the budget.+ const size = smallestRequested < 800 ? 100_000 : 5_000_000;+ return new Blob([new Uint8Array(size)], { type });+ }+ },+ );++ const result = await compressImageForStash(makeFile(4_000_000));++ expect(result.ok).toBe(true);+ // Fallback passes must scale off the bitmap, not a fixed 2048 ceiling+ // that would never go below an 800px source.+ expect(smallestRequested).toBeLessThan(800);+ });+});diff --git a/apps/web/src/lib/stashImageCompression.ts b/apps/web/src/lib/stashImageCompression.tsnew file mode 100644index 000000000..7f133fb29--- /dev/null+++ b/apps/web/src/lib/stashImageCompression.ts@@ -0,0 +1,250 @@+/**+ * Re-encoding for stashed image attachments.+ *+ * The composer accepts images up to `PROVIDER_SEND_TURN_MAX_IMAGE_BYTES`+ * (10MB), but the stash persists them as base64 in localStorage, where the+ * whole origin shares a ~5MB quota. Rather than refuse large screenshots,+ * downscale + re-encode them to JPEG so a stashed prompt keeps its images.+ *+ * Only the *stashed copy* is compressed; the live composer attachment is+ * untouched, so sending without stashing still uploads the original file.+ */++/**+ * Longest edge kept when an image has to be re-encoded. Sized so a typical+ * retina screenshot (3024px wide) stays legible rather than being halved.+ */+const MAX_DIMENSION = 2048;+/** Base64 budget for a single stashed image (~975KB of binary). */+export const MAX_STASH_IMAGE_DATA_URL_CHARS = 1_300_000;+/**+ * Quality ladder tried in order until the encoded image fits the budget.+ * The floor stays high enough to avoid visible blocking on UI screenshots;+ * if even that overflows we drop resolution instead of quality.+ */+const QUALITY_STEPS = [0.92, 0.85, 0.78, 0.68] as const;+/** Extra downscale passes applied when even the lowest quality overflows. */+const FALLBACK_SCALE_STEPS = [0.75, 0.55] as const;++export interface CompressedStashImage {+ dataUrl: string;+ mimeType: string;+ sizeBytes: number;+ /** True when the payload was re-encoded rather than stored verbatim. */+ recompressed: boolean;+}++/**+ * Why an image could not be stashed. Callers report these differently:+ * "too large" is a budget outcome, "unreadable" is a decode failure.+ */+export type StashImageFailureReason = "too-large" | "unreadable";++export type CompressStashImageResult =+ | { ok: true; image: CompressedStashImage }+ | { ok: false; reason: StashImageFailureReason };++/** Chunked so a large image can't blow the argument limit of `fromCharCode`. */+const BASE64_CHUNK_SIZE = 0x8000;++function bytesToBase64(bytes: Uint8Array): string {+ let binary = "";+ for (let offset = 0; offset < bytes.length; offset += BASE64_CHUNK_SIZE) {+ binary += String.fromCharCode(...bytes.subarray(offset, offset + BASE64_CHUNK_SIZE));+ }+ return btoa(binary);+}++/**+ * Blob → base64 data URL. Uses `arrayBuffer()` rather than `FileReader` so+ * the module works anywhere `Blob` does (including non-DOM test runners).+ */+async function blobToDataUrl(blob: File | Blob, mimeTypeOverride?: string): Promise<string> {+ const buffer = await blob.arrayBuffer();+ const mimeType = mimeTypeOverride || blob.type || "application/octet-stream";+ return `data:${mimeType};base64,${bytesToBase64(new Uint8Array(buffer))}`;+}++/** Approximate decoded byte count for a base64 data URL. */+function dataUrlByteLength(dataUrl: string): number {+ const commaIndex = dataUrl.indexOf(",");+ const payload = commaIndex === -1 ? dataUrl : dataUrl.slice(commaIndex + 1);+ const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;+ return Math.max(0, Math.floor((payload.length * 3) / 4) - padding);+}++function canRecompress(): boolean {+ return (+ typeof createImageBitmap === "function" &&+ (typeof OffscreenCanvas === "function" || typeof document !== "undefined")+ );+}++interface Canvas2D {+ canvas: OffscreenCanvas | HTMLCanvasElement;+ context: OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D;+}++function createCanvas(width: number, height: number): Canvas2D | null {+ if (typeof OffscreenCanvas === "function") {+ const canvas = new OffscreenCanvas(width, height);+ const context = canvas.getContext("2d");+ if (!context) return null;+ return { canvas, context };+ }+ if (typeof document === "undefined") return null;+ const canvas = document.createElement("canvas");+ canvas.width = width;+ canvas.height = height;+ const context = canvas.getContext("2d");+ if (!context) return null;+ return { canvas, context };+}++/**+ * WebP is preferred: at matched visual quality it lands roughly 25-35%+ * smaller than JPEG, so the same budget buys more resolution and detail —+ * and it keeps alpha, so screenshots with transparency survive intact.+ * Browsers that can't encode it silently fall back to JPEG.+ */+async function encodeToDataUrl(+ canvas: OffscreenCanvas | HTMLCanvasElement,+ quality: number,+ mimeType: string,+): Promise<{ dataUrl: string; mimeType: string } | null> {+ if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {+ const dataUrl = canvas.toDataURL(mimeType, quality);+ // toDataURL silently returns a PNG when the requested type is unsupported.+ if (!dataUrl.startsWith(`data:${mimeType}`)) return null;+ return { dataUrl, mimeType };+ }+ const blob = await (canvas as OffscreenCanvas).convertToBlob({ type: mimeType, quality });+ if (blob.type && blob.type !== mimeType) return null;+ return { dataUrl: await blobToDataUrl(blob, mimeType), mimeType };+}++/**+ * Draws `bitmap` scaled to fit `maxDimension` and encodes it as JPEG,+ * stepping quality down until the data URL fits `budgetChars`. Returns the+ * smallest encoding produced, even if it still exceeds the budget, so the+ * caller can decide whether to keep or drop it.+ */+async function encodeWithinBudget(+ bitmap: ImageBitmap,+ maxDimension: number,+ budgetChars: number,+): Promise<{ dataUrl: string; mimeType: string } | null> {+ const scale = Math.min(1, maxDimension / Math.max(bitmap.width, bitmap.height));+ const width = Math.max(1, Math.round(bitmap.width * scale));+ const height = Math.max(1, Math.round(bitmap.height * scale));+ const target = createCanvas(width, height);+ if (!target) return null;++ // Probe WebP once; JPEG (no alpha) needs a white matte, so the fill has to+ // happen before drawing and depends on which codec we end up using.+ const probe = await encodeToDataUrl(target.canvas, QUALITY_STEPS[0], "image/webp");+ const mimeType = probe ? "image/webp" : "image/jpeg";++ if (mimeType === "image/jpeg") {+ target.context.fillStyle = "#ffffff";+ target.context.fillRect(0, 0, width, height);+ }+ target.context.drawImage(bitmap, 0, 0, width, height);++ let smallest: { dataUrl: string; mimeType: string } | null = null;+ for (const quality of QUALITY_STEPS) {+ const encoded = await encodeToDataUrl(target.canvas, quality, mimeType);+ if (!encoded) break;+ if (smallest === null || encoded.dataUrl.length < smallest.dataUrl.length) {+ smallest = encoded;+ }+ if (encoded.dataUrl.length <= budgetChars) {+ return encoded;+ }+ }+ return smallest;+}++/**+ * Produces the payload to persist for a stashed image.+ *+ * Small images are stored verbatim (preserving PNG transparency and exact+ * pixels). Anything over budget is downscaled and JPEG-encoded; if it still+ * doesn't fit after the fallback passes, returns `null` so the caller can+ * record it as dropped.+ */+export async function compressImageForStash(+ file: File,+ budgetChars: number = MAX_STASH_IMAGE_DATA_URL_CHARS,+): Promise<CompressStashImageResult> {+ let originalDataUrl: string;+ try {+ originalDataUrl = await blobToDataUrl(file);+ } catch {+ return { ok: false, reason: "unreadable" };+ }+ if (originalDataUrl.length <= budgetChars) {+ return {+ ok: true,+ image: {+ dataUrl: originalDataUrl,+ mimeType: file.type,+ sizeBytes: file.size,+ recompressed: false,+ },+ };+ }+ if (!canRecompress()) {+ return { ok: false, reason: "too-large" };+ }++ let bitmap: ImageBitmap;+ try {+ bitmap = await createImageBitmap(file);+ } catch {+ return { ok: false, reason: "unreadable" };+ }++ try {+ // Each pass shrinks relative to the *previous target*, capped by+ // MAX_DIMENSION. Scaling a fixed ceiling instead would be a no-op for+ // images already smaller than that ceiling — the fallback passes would+ // all resolve to the source size and never actually reduce resolution.+ const baseDimension = Math.min(MAX_DIMENSION, Math.max(bitmap.width, bitmap.height));+ // Tracks whether the *last* attempt threw, so a run of encoder failures+ // is reported as unreadable while a run of merely-too-big results is+ // reported as too-large.+ let encodeFailed = false;+ for (const dimensionScale of [1, ...FALLBACK_SCALE_STEPS]) {+ const targetDimension = Math.max(1, Math.round(baseDimension * dimensionScale));+ let encoded: { dataUrl: string; mimeType: string } | null;+ try {+ encoded = await encodeWithinBudget(bitmap, targetDimension, budgetChars);+ } catch {+ // Canvas allocation, drawing, or the codec itself can throw — often+ // precisely *because* the target is too big (OOM on a large bitmap).+ // Keep trying the smaller fallback scales rather than giving up: a+ // reduced pass may well succeed. The exception must never escape,+ // though, since the caller finalizes the entry after this returns and+ // a throw would strand it as permanently "still saving".+ encodeFailed = true;+ continue;+ }+ encodeFailed = false;+ if (encoded && encoded.dataUrl.length <= budgetChars) {+ return {+ ok: true,+ image: {+ dataUrl: encoded.dataUrl,+ mimeType: encoded.mimeType,+ sizeBytes: dataUrlByteLength(encoded.dataUrl),+ recompressed: true,+ },+ };+ }+ }+ return { ok: false, reason: encodeFailed ? "unreadable" : "too-large" };+ } finally {+ bitmap.close();+ }+}diff --git a/apps/web/src/promptStashStore.test.ts b/apps/web/src/promptStashStore.test.tsnew file mode 100644index 000000000..228e1e357--- /dev/null+++ b/apps/web/src/promptStashStore.test.ts@@ -0,0 +1,259 @@+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,+ 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 {+ return {+ id: input.id,+ createdAt: "2026-07-24T12:00:00.000Z",+ prompt: input.prompt ?? `prompt ${input.id}`,+ attachments:+ input.attachmentChars !== undefined+ ? [+ {+ id: `${input.id}-img`,+ name: "shot.png",+ mimeType: "image/png",+ sizeBytes: input.attachmentChars,+ dataUrl: "x".repeat(input.attachmentChars),+ },+ ]+ : [],+ providerInstanceId:+ input.providerInstanceId === undefined ? CLAUDE_AGENT_INSTANCE : input.providerInstanceId,+ modelSelection: null,+ droppedImageNames: [],+ };+}++function resetPromptStashStore() {+ usePromptStashStore.setState({ queuesByScopeKey: {} });+ 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 = {+ id: "a",+ name: "small.png",+ mimeType: "image/png",+ sizeBytes: 10,+ dataUrl: "x".repeat(10),+ };+ const huge = {+ id: "b",+ name: "huge.png",+ mimeType: "image/png",+ sizeBytes: MAX_STASH_ENTRY_ATTACHMENT_CHARS,+ dataUrl: "x".repeat(MAX_STASH_ENTRY_ATTACHMENT_CHARS),+ };+ const alsoSmall = {+ id: "c",+ name: "also-small.png",+ mimeType: "image/png",+ sizeBytes: 10,+ dataUrl: "x".repeat(10),+ };+ const { kept, droppedNames } = partitionStashAttachments([small, huge, alsoSmall]);+ expect(kept.map((attachment) => attachment.id)).toEqual(["a", "c"]);+ expect(droppedNames).toEqual(["huge.png"]);+ });++ it("admits a single attachment that exactly fits the budget", () => {+ const exact = {+ id: "a",+ name: "exact.png",+ mimeType: "image/png",+ sizeBytes: MAX_STASH_ENTRY_ATTACHMENT_CHARS,+ dataUrl: "x".repeat(MAX_STASH_ENTRY_ATTACHMENT_CHARS),+ };+ const { kept, droppedNames } = partitionStashAttachments([exact]);+ expect(kept).toHaveLength(1);+ expect(droppedNames).toEqual([]);+ });+});++describe("promptStashStore", () => {+ beforeEach(() => {+ resetPromptStashStore();+ });++ afterEach(() => {+ resetPromptStashStore();+ });++ it("prepends entries so the newest stash is first", () => {+ 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"]);+ });++ it("evicts the oldest entry past the per-queue cap and returns it", () => {+ const store = usePromptStashStore.getState();+ for (let index = 0; index < MAX_STASH_ENTRIES_PER_QUEUE; 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");+ });++ it("takeEntry removes and returns the entry; second take returns null", () => {+ 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"]);+ });++ // 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[]>,+ });+ const store = usePromptStashStore.getState();+ expect(() => store.takeEntry("__proto__", "missing")).not.toThrow();+ expect(store.takeEntry("__proto__", "missing").entry).toBeNull();+ });++ 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", {+ attachments: [+ {+ id: "img-1",+ name: "a.webp",+ mimeType: "image/webp",+ sizeBytes: 10,+ dataUrl: "data:image/webp;base64,AAAA",+ },+ ],+ droppedImageNames: ["big.png"],+ unreadableImageNames: [],+ });++ expect(attached).toBe(true);+ const entry = usePromptStashStore.getState().queuesByScopeKey[scopeKey]?.[0];+ expect(entry?.attachments).toHaveLength(1);+ expect(entry?.droppedImageNames).toEqual(["big.png"]);+ expect(entry?.pendingImageCount).toBe(0);+ });++ 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");++ const { attached } = store.finalizeEntryImages(scopeKey, "racing", {+ attachments: [],+ droppedImageNames: [],+ unreadableImageNames: [],+ });++ expect(attached).toBe(false);+ });++ it("settles a pending count left behind by a crashed or closed session", () => {+ const scopeKey = promptStashScopeKey(CLAUDE_AGENT_INSTANCE);+ writePromptStashStorageForTest(+ JSON.stringify({+ version: 1,+ state: {+ queuesByScopeKey: {+ [scopeKey]: [{ ...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];+ 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();+ });+});diff --git a/apps/web/src/promptStashStore.ts b/apps/web/src/promptStashStore.tsnew file mode 100644index 000000000..e4340935b--- /dev/null+++ b/apps/web/src/promptStashStore.ts@@ -0,0 +1,322 @@+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;++/**+ * 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__`.+ */+export const PROMPT_STASH_UNSCOPED_KEY = "__none__";+/** Namespace applied to provider-derived keys to keep them collision-proof. */+const PROVIDER_SCOPE_PREFIX = "provider:";++export const MAX_STASH_ENTRIES_PER_QUEUE = 20;+/**+ * Budget for an entry's serialized attachment payload. localStorage is a+ * ~5MB origin-wide quota shared with the composer draft store, so oversized+ * images are dropped (tracked in `droppedImageNames`) rather than persisted.+ *+ * Sized to hold two images at the per-image compression budget+ * (`MAX_STASH_IMAGE_DATA_URL_CHARS`) so a typical before/after screenshot+ * pair survives intact.+ */+export const MAX_STASH_ENTRY_ATTACHMENT_CHARS = 2_700_000;++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),+ /**+ * Names of images that could not be decoded or re-encoded at all — a+ * distinct failure from exceeding the size budget, so the menu can explain+ * which actually happened. Optional: entries written before this field+ * existed decode without it.+ */+ unreadableImageNames: Schema.optionalKey(Schema.Array(Schema.String)),+ /**+ * Images still being encoded when the entry was written. The entry is+ * persisted before its images so a crash mid-encode cannot lose the prompt;+ * this field lets the UI show "N images still saving" until+ * `finalizeEntryImages` lands, and flags entries orphaned by a reload.+ */+ pendingImageCount: Schema.optionalKey(Schema.Number),+});+export type PromptStashEntry = typeof StashEntrySchema.Type;++const PersistedPromptStashState = Schema.Struct({+ queuesByScopeKey: Schema.Record(Schema.String, Schema.Array(StashEntrySchema)),+});+type PersistedPromptStashState = typeof PersistedPromptStashState.Type;++const decodePersistedPromptStashState = Schema.decodeUnknownSync(PersistedPromptStashState);++/**+ * `pendingImageCount` only has meaning within the session that wrote it: the+ * encode loop that would clear it does not survive a reload. Any entry that+ * comes back from storage still pending was orphaned by a closed tab or a+ * crash mid-encode, so the count is settled here — otherwise the entry would+ * be stuck showing "saving…" and refuse to restore forever.+ *+ * The images are genuinely gone (they were never written), so they are+ * 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,+): ReadonlyArray<PromptStashEntry> {+ return Object.hasOwn(queues, scopeKey) ? (queues[scopeKey] ?? []) : [];+}++/**+ * Splits candidate attachments into a persistable set within the entry+ * budget plus the names of any that had to be dropped. Attachments are+ * admitted in order so the earliest-added images win.+ */+export function partitionStashAttachments(+ attachments: ReadonlyArray<PersistedComposerImageAttachment>,+): {+ kept: PersistedComposerImageAttachment[];+ droppedNames: string[];+} {+ const kept: PersistedComposerImageAttachment[] = [];+ const droppedNames: string[] = [];+ let usedChars = 0;+ for (const attachment of attachments) {+ if (usedChars + attachment.dataUrl.length > MAX_STASH_ENTRY_ATTACHMENT_CHARS) {+ droppedNames.push(attachment.name);+ continue;+ }+ usedChars += attachment.dataUrl.length;+ kept.push(attachment);+ }+ return { kept, droppedNames };+}++/**+ * Reading the `localStorage` property itself can throw `SecurityError` when+ * storage is blocked by policy or the page is a sandboxed iframe — so the+ * access has to be guarded, not just the get/set calls on it. Otherwise+ * importing this module would crash the app at load.+ *+ * `durable` is false for the in-memory fallback: writes there "succeed" but+ * vanish on reload, and callers clear the composer on the strength of a+ * successful stash, so they must be told the difference.+ */+function resolveBaseStorage(): { storage: StateStorage; durable: boolean } {+ try {+ if (typeof localStorage !== "undefined") {+ return { storage: localStorage, durable: true };+ }+ } catch {+ // Fall through to the in-memory store.+ }+ return { storage: createMemoryStorage(), durable: false };+}++const { storage: baseStashStorage, durable: storageIsDurable } = resolveBaseStorage();++/**+ * Persists the queues, 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.+ *+ * 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>>): {+ /** The write succeeded (possibly only into the in-memory fallback). */+ written: boolean;+ /** The write will survive a reload. */+ durable: boolean;+} {+ try {+ baseStashStorage.setItem(+ PROMPT_STASH_STORAGE_KEY,+ JSON.stringify({+ version: PROMPT_STASH_STORAGE_VERSION,+ state: { queuesByScopeKey: queues },+ }),+ );+ return { written: true, durable: storageIsDurable };+ } catch (error) {+ console.error("[PROMPT-STASH] Could not persist stash (storage quota?).", error);+ return { written: false, durable: false };+ }+}++/** Reads the persisted queues, settling stale pending counts. */+function readPersistedQueues(): Record<string, 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);+ } catch {+ return null;+ }+}++interface PromptStashStoreState {+ queuesByScopeKey: Record<string, 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.+ */+ stashEntry: (entry: PromptStashEntry) => {+ evicted: PromptStashEntry | null;+ /** False when the write did not reach durable storage; nothing was kept. */+ durable: boolean;+ };+ /**+ * Removes and returns an entry from a scope's 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 };+ /**+ * Attaches the encoded images to an entry written earlier by `stashEntry`,+ * clearing its pending count. Returns attached=false when the entry is gone+ * (restored or deleted while encoding was still running) so the caller can+ * tell the user their images did not make it.+ */+ finalizeEntryImages: (+ scopeKey: string,+ entryId: string,+ images: {+ attachments: ReadonlyArray<PersistedComposerImageAttachment>;+ droppedImageNames: ReadonlyArray<string>;+ unreadableImageNames: ReadonlyArray<string>;+ },+ ) => { attached: boolean; durable: boolean };+}++export const usePromptStashStore = create<PromptStashStoreState>()((set, get) => ({+ queuesByScopeKey: {},+ 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);+ // 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 };+ }+ set(() => ({ queuesByScopeKey: next }));+ return { evicted, durable };+ },+ takeEntry: (scopeKey, entryId) => {+ const queues = get().queuesByScopeKey;+ const queue = readQueue(queues, scopeKey);+ const entry = queue.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 }));+ 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];+ // Restored or deleted mid-encode: nothing to attach to.+ if (!existing) return { attached: false, durable: true };+ const nextQueue = [...queue];+ nextQueue[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 }));+ return { attached: true, durable };+ },+}));++// 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();+ if (persisted) {+ usePromptStashStore.setState({ queuesByScopeKey: 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.+ * Pass an empty string to clear.+ */+export function writePromptStashStorageForTest(raw: string): void {+ baseStashStorage.setItem(PROMPT_STASH_STORAGE_KEY, raw);+ usePromptStashStore.setState({ queuesByScopeKey: readPersistedQueues() ?? {} });+}diff --git a/packages/contracts/src/keybindings.ts b/packages/contracts/src/keybindings.tsindex c7cff9943..d966c1e7e 100644--- a/packages/contracts/src/keybindings.ts+++ b/packages/contracts/src/keybindings.ts@@ -63,6 +63,7 @@ const STATIC_KEYBINDING_COMMANDS = ["preview.zoomOut","preview.resetZoom","commandPalette.toggle",+ "composer.stash","chat.new","chat.newLocal","editor.openFavorite",diff --git a/packages/shared/src/keybindings.ts b/packages/shared/src/keybindings.tsindex b6bdd7b47..0688cf072 100644--- a/packages/shared/src/keybindings.ts+++ b/packages/shared/src/keybindings.ts@@ -35,6 +35,7 @@ export const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule> = [{ key: "mod+-", command: "preview.zoomOut", when: "previewFocus" },{ key: "mod+0", command: "preview.resetZoom", when: "previewFocus" },{ key: "mod+k", command: "commandPalette.toggle", when: "!terminalFocus" },+ { key: "mod+s", command: "composer.stash", when: "!terminalFocus" },{ key: "mod+n", command: "chat.new", when: "!terminalFocus" },{ key: "mod+shift+o", command: "chat.new", when: "!terminalFocus" },{ key: "mod+shift+n", command: "chat.newLocal", when: "!terminalFocus" },