diff --git a/docs/buzz-help.md b/docs/buzz-help.md
index 36af3d698e..b6c3027e26 100644
--- a/docs/buzz-help.md
+++ b/docs/buzz-help.md
@@ -118,9 +118,22 @@ that agent in Buzz; they do not notify the external app through this connection.
 
 - **Solo** organizes your chats with agents. Choose **New chat**, select or tag
   an agent, and send a message. Solo conversations continue at the chat's top
-  level rather than requiring a new thread for each reply. Solo chats can also
-  be shared with other people; do not describe every Solo chat as visible only
-  to its creator.
+  level rather than requiring a new thread for each reply. Where available, use
+  **Model and effort** in the composer before sending; Solo keeps those choices
+  for that chat until you reset them in the same control, even if its available
+  models change. Wait for saved choices to load before sending; an unreadable
+  store never silently falls back to defaults. If choices cannot be read, use
+  **Retry saved choices** before sending. If their agent catalog cannot be loaded, retry
+  or reset them in the model control. If New chat cannot clear
+  its choices after sending, reset them before starting another chat. Wait for
+  pending model changes to save before sending. If saving fails, the current
+  composer keeps your unsaved selection; other windows may not see it.
+  If a refused start offers **Retry restoring message**, it keeps the original
+  message, attachments, and choices while this window stays open. Retry never
+  replaces a newer New chat draft or a later Reset. Reloading or dismissing that
+  notice ends this recovery option.
+  Solo chats can also be shared with other people; do not describe every Solo
+  chat as visible only to its creator.
 - **Team** contains community channels and their threads. Use the **@** picker
   to address a channel member. Typing a name alone does not guarantee a
   notification. Selecting someone outside the channel does not grant access;
diff --git a/src/bundled/channels/ChannelsPage.solo.test.tsx b/src/bundled/channels/ChannelsPage.solo.test.tsx
index e0ae4b3697..5a129f1774 100644
--- a/src/bundled/channels/ChannelsPage.solo.test.tsx
+++ b/src/bundled/channels/ChannelsPage.solo.test.tsx
@@ -12,6 +12,7 @@ import {
 import userEvent from "@testing-library/user-event";
 import { afterEach, expect, it, vi } from "vitest";
 import { createRelaySession } from "../../features/relay/session";
+import { ChatNotStarted } from "../../features/relay/channel-writes";
 import { keypair, signed } from "../../features/relay/testing";
 import type { RelayData } from "../../features/relay/service";
 import type { ChannelSummary } from "../../features/relay/contracts";
@@ -37,6 +38,11 @@ import { SoloWorkspaces } from "./SoloWorkspaces";
 import type { RelaySession } from "../../features/relay/session";
 import type { ReadTarget } from "../../features/relay/read-state-model";
 
+vi.mock(
+  "../../features/messages/solo-model-picks-storage",
+  () => import("../../features/messages/solo-model-picks-storage-testing"),
+);
+
 composerDOMFixture();
 const owners: ReturnType<typeof createRelaySession>[] = [];
 afterEach(() => {
@@ -542,6 +548,138 @@ it("renders a Solo draft route as the new chat composer", async () => {
   expect(f.archive.current).toBeUndefined();
 });
 
+it("keeps the newer destination when a departed New chat acquires model ownership", async () => {
+  const first = fixture({
+    target: (scope) => soloDraftTarget(scope, { agent }),
+  });
+  const descriptor = Object.getOwnPropertyDescriptor(navigator, "locks");
+  let release!: () => void;
+  const held = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let requested!: () => void;
+  const waiting = new Promise<void>((resolve) => {
+    requested = resolve;
+  });
+  let completed!: () => void;
+  const settled = new Promise<void>((resolve) => {
+    completed = resolve;
+  });
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: {
+      request: async (_name: string, run: () => unknown) => {
+        requested();
+        await held;
+        try {
+          return run();
+        } finally {
+          completed();
+        }
+      },
+    },
+  });
+  const view = first.mount();
+  const user = userEvent.setup();
+  try {
+    await user.type(
+      await screen.findByRole("textbox", { name: "Message your agents" }),
+      "Start before navigating",
+    );
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await waiting;
+    expect(first.send).toHaveBeenCalledOnce();
+    first.abort.abort();
+    view.unmount();
+    const newer = fixture({ type: "stream" });
+    newer.mount();
+    await screen.findByRole("textbox", { name: "Message #Planning" });
+    await act(async () => {
+      release();
+      await settled;
+    });
+    expect(first.open).not.toHaveBeenCalled();
+    expect(newer.open).not.toHaveBeenCalled();
+    expect(
+      screen.getByRole("textbox", { name: "Message #Planning" }),
+    ).toBeVisible();
+  } finally {
+    release();
+    if (descriptor) Object.defineProperty(navigator, "locks", descriptor);
+    else Reflect.deleteProperty(navigator, "locks");
+  }
+});
+
+it("keeps refused-start restoration visibly retryable when window ownership fails again", async () => {
+  const f = fixture({ target: (scope) => soloDraftTarget(scope, { agent }) });
+  let refuse!: () => void;
+  const ready = new Promise<void>((_resolve, reject) => {
+    refuse = () => reject(new ChatNotStarted("Channel creation rejected"));
+  });
+  f.session.channelWrites.start.mockImplementationOnce((chat) => ({
+    create: f.session.channelWrites.create(chat),
+    ready,
+  }));
+  const descriptor = Object.getOwnPropertyDescriptor(navigator, "locks");
+  const available = {
+    request: async (_name: string, run: () => unknown) => run(),
+  };
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: available,
+  });
+  f.mountWithToasts();
+  const user = userEvent.setup();
+  try {
+    await user.type(
+      await screen.findByRole("textbox", { name: "Message your agents" }),
+      "Keep this message",
+    );
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await waitFor(() => expect(f.open).toHaveBeenCalledOnce());
+    Object.defineProperty(navigator, "locks", {
+      configurable: true,
+      value: {
+        request: async () => {
+          throw new Error("Lock refused");
+        },
+      },
+    });
+    await act(async () => {
+      refuse();
+      await ready.catch(() => {});
+    });
+    const retry = () =>
+      screen.findByRole("button", { name: "Retry restoring message" });
+    const firstRetry = await retry();
+    fireEvent.click(firstRetry);
+    // The toast consumes its action before invoking it; a second failure must
+    // offer a new action retaining the same refused prompt.
+    await waitFor(() => expect(firstRetry).not.toBeInTheDocument());
+    const offeredAgain = await retry();
+    Object.defineProperty(navigator, "locks", {
+      configurable: true,
+      value: available,
+    });
+    fireEvent.click(offeredAgain);
+    await waitFor(() =>
+      expect(
+        screen.getByRole("textbox", { name: "Message your agents" }),
+      ).toHaveTextContent("Keep this message"),
+    );
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("button", { name: "Retry restoring message" }),
+      ).toBeNull(),
+    );
+    expect(f.send).toHaveBeenCalledOnce();
+    expect(f.session.channelWrites.start).toHaveBeenCalledOnce();
+  } finally {
+    if (descriptor) Object.defineProperty(navigator, "locks", descriptor);
+    else Reflect.deleteProperty(navigator, "locks");
+  }
+});
+
 it("starts a Solo draft route in its project, with that project's saved draft", async () => {
   const f = fixture({
     target: (scope) => soloDraftTarget(scope, { project: "work" }),
diff --git a/src/bundled/channels/ChannelsPage.tsx b/src/bundled/channels/ChannelsPage.tsx
index ab748c7fa6..ceab8f31c3 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -2080,8 +2080,18 @@ function ChannelWorkspace({
                     signal: navigation?.signal,
                   }));
               }}
-              onFailed={(channelId, message) => {
-                notify(message, "error");
+              onFailed={(channelId, message, retry) => {
+                notify(
+                  message,
+                  "error",
+                  retry
+                    ? {
+                        label: "Retry restoring message",
+                        onClick: () => void retry(),
+                        timeout: Infinity,
+                      }
+                    : undefined,
+                );
                 // A failure behind Settings must not navigate away from it.
                 if (
                   showing.current === channelId &&
diff --git a/src/features/agents/react.test.tsx b/src/features/agents/react.test.tsx
index dd362b1cf6..1a8d30138f 100644
--- a/src/features/agents/react.test.tsx
+++ b/src/features/agents/react.test.tsx
@@ -64,7 +64,7 @@ it("loads models and their effort levels asynchronously before an agent runs", a
   ]);
 });
 
-it("offers nothing for a single model without effort levels", async () => {
+it("loads a single model without effort levels for saved-choice validation", async () => {
   const agents = ["fixed", "tunable"].map(
     (pubkey) => ({ pubkey, type: pubkey, name: pubkey }) as Agent,
   );
@@ -92,7 +92,10 @@ it("offers nothing for a single model without effort levels", async () => {
   });
   // Both lookups settle together, so the tunable one is the barrier.
   await waitFor(() =>
-    expect(result.current.map((choice) => choice.pubkey)).toEqual(["tunable"]),
+    expect(result.current.map((choice) => choice.current)).toEqual([
+      "only",
+      "Tunable",
+    ]),
   );
 });
 
diff --git a/src/features/agents/react.ts b/src/features/agents/react.ts
index d51d2e78e7..a4f40cd122 100644
--- a/src/features/agents/react.ts
+++ b/src/features/agents/react.ts
@@ -117,13 +117,15 @@ export type MentionModelChoice = Models &
     pubkey: string;
     name: string;
     loading?: boolean;
+    failed?: boolean;
     /** Its type offers immediate controls for sessions of this scope. */
     session?: "thread" | "channel";
   }>;
-/** The mentioned agents, of the viewer's own, whose type offers a choice of
- * model or effort, or session actions. */
+/** Model catalogs and session actions for the viewer's mentioned agents.
+ * A single model still validates saved picks even when no control is needed. */
 export function useMentionModels(
   pubkeys: readonly string[],
+  retry = 0,
 ): readonly MentionModelChoice[] {
   const remote = useContext(MentionModelsContext);
   const agents = useContext(AgentsContext);
@@ -144,6 +146,7 @@ export function useMentionModels(
     snapshot: typeof snapshot;
     types: typeof types;
     key: string;
+    retry: number;
     choices: readonly MentionModelChoice[];
   }>();
   useEffect(() => {
@@ -163,22 +166,23 @@ export function useMentionModels(
                 if (!agent || !type) return [];
                 const session = type.sessionControls?.scope(agent);
                 let found: Models = { current: "", models: [] };
+                let failed = false;
                 try {
                   if (type.models) found = await type.models(agent);
                 } catch (error) {
+                  failed = true;
                   console.warn(
                     `Agent type ${type.key} could not list its models`,
                     error,
                   );
                 }
-                return found.models.length > 1 ||
-                  found.models.some((m) => m.efforts.length) ||
-                  session
+                return failed || found.models.length || session
                   ? [
                       {
                         pubkey,
                         name: agent.name,
                         ...found,
+                        ...(failed ? { failed } : {}),
                         ...(session ? { session } : {}),
                       },
                     ]
@@ -186,17 +190,19 @@ export function useMentionModels(
               }),
           ).then((choices) => choices.flat())
     ).then((choices) => {
-      if (current) setResolved({ remote, snapshot, types, key, choices });
+      if (current)
+        setResolved({ remote, snapshot, types, key, retry, choices });
     });
     return () => {
       current = false;
     };
-  }, [snapshot, types, key, remote]);
+  }, [snapshot, types, key, remote, retry]);
   // Never offer a previous agent/config's choices while the new lookup settles.
   return resolved?.remote === remote &&
     resolved?.snapshot === snapshot &&
     resolved?.types === types &&
-    resolved?.key === key
+    resolved?.key === key &&
+    resolved?.retry === retry
     ? resolved.choices
     : key.split(":").flatMap((pubkey) => {
         const agent = snapshot?.agents.find((item) => item.pubkey === pubkey);
diff --git a/src/features/communities/device-state.test.ts b/src/features/communities/device-state.test.ts
index d151fa05f7..c3e3231c51 100644
--- a/src/features/communities/device-state.test.ts
+++ b/src/features/communities/device-state.test.ts
@@ -34,6 +34,13 @@ vi.mock("../relay/outbox-storage", () => ({
   purgeOutboxStorage: (scope: string) => record("outbox", scope),
 }));
 
+vi.mock("../messages/solo-model-picks-storage", () => ({
+  purgeSoloModelPicks: (scope: string) =>
+    typeof indexedDB === "undefined"
+      ? Promise.resolve()
+      : record("model choices", scope),
+}));
+
 vi.mock("../artifact-storage/store", () => ({
   purgeArtifactStorage: (viewer: string, origin: string) =>
     typeof indexedDB === "undefined"
@@ -142,6 +149,7 @@ it("purges the relay's heads, read state and outbox for the exact partition, in
     ["read state", `${origin}:${viewer}`],
     ["outbox", `${origin}:${viewer}`],
     ["artifacts", viewer, origin],
+    ["model choices", `${origin}:${viewer}`],
   ]);
 });
 
@@ -159,14 +167,17 @@ it("reports each failed relay store by name, closes heads and still clears the o
   const heads = new Error("heads blocked");
   const reads = new Error("read state blocked");
   const artifacts = new Error("artifacts blocked");
+  const choices = new Error("choices blocked");
   relay.fail
     .set("heads.clear", heads)
     .set("read state", reads)
-    .set("artifacts", artifacts);
+    .set("artifacts", artifacts)
+    .set("model choices", choices);
   expect(await purgeCommunityDeviceState(origin, viewer)).toEqual([
     { store: "channel heads", error: heads },
     { store: "read state", error: reads },
     { store: "artifacts", error: artifacts },
+    { store: "model and effort choices", error: choices },
   ]);
   expect(relay.calls.map(([name]) => name)).toEqual([
     "heads",
@@ -175,11 +186,16 @@ it("reports each failed relay store by name, closes heads and still clears the o
     "read state",
     "outbox",
     "artifacts",
+    "model choices",
   ]);
   expect(warn.mock.calls).toEqual([
     [`Couldn't clear channel heads for ${origin} on this device`, heads],
     [`Couldn't clear read state for ${origin} on this device`, reads],
     [`Couldn't clear artifacts for ${origin} on this device`, artifacts],
+    [
+      `Couldn't clear model and effort choices for ${origin} on this device`,
+      choices,
+    ],
   ]);
 });
 
diff --git a/src/features/messages/ComposerModels.tsx b/src/features/messages/ComposerModels.tsx
index 63e2c41cef..477477227e 100644
--- a/src/features/messages/ComposerModels.tsx
+++ b/src/features/messages/ComposerModels.tsx
@@ -22,6 +22,7 @@ import {
   AgentsContext,
   useSessionState,
   useMentionModels,
+  useAgentsSnapshot,
 } from "../agents/react";
 import type { MentionModelChoice } from "../agents/react";
 import type { SessionPlace, SessionControlAction } from "../agents/service";
@@ -62,8 +63,11 @@ export function ComposerModels({
   media,
   value,
   disabled,
+  resettable = false,
+  explicitOnly = false,
   onChange,
   onResolved,
+  onRetryInventory,
   startsThread,
   place,
 }: {
@@ -72,28 +76,36 @@ export function ComposerModels({
   media: Parameters<typeof avatarMedia>[1];
   value: DraftPicks;
   disabled: boolean;
-  onChange(value: DraftPicks): void;
-  onResolved(value: MentionPicks): void;
+  /** Solo chat picks are defaults for the chat until explicitly reset. */
+  resettable?: boolean;
+  /** A new Solo chat keeps provider defaults unchanged unless picked. */
+  explicitOnly?: boolean;
+  onChange(value: DraftPicks, resetPubkeys?: readonly string[]): void;
+  /** null waits for choices; undefined invalidates the picker's snapshot. */
+  onResolved(value: MentionPicks | null | undefined, error?: string): void;
+  onRetryInventory?(): void;
   /** The message starts a thread of its own, as a channel's top-level one
    * does, so a thread-scoped agent has no session to act on. */
   startsThread: boolean;
   place: SessionPlace;
 }) {
   const [open, setOpen] = useState(false);
-  const mentioned = useMentionModels(pubkeys);
+  const [retry, setRetry] = useState(0);
+  const mentioned = useMentionModels(pubkeys, retry);
   const choices = useMemo<readonly MentionModelChoice[]>(
     () =>
-      startsThread
-        ? mentioned.flatMap((choice) => {
-            if (choice.session !== "thread") return [choice];
-            const { session: _, ...rest } = choice;
-            return rest.loading ||
-              rest.models.length > 1 ||
-              rest.models.some((model) => model.efforts.length)
-              ? [rest]
-              : [];
-          })
-        : mentioned,
+      mentioned.flatMap((choice) => {
+        const { session, ...catalog } = choice;
+        const visible: MentionModelChoice =
+          startsThread && session === "thread" ? catalog : choice;
+        return visible.loading ||
+          visible.failed ||
+          visible.models.length > 1 ||
+          visible.models.some((model) => model.efforts.length) ||
+          visible.session
+          ? [visible]
+          : [];
+      }),
     [mentioned, startsThread],
   );
   const profileKey = pubkeys.join(":");
@@ -114,6 +126,32 @@ export function ComposerModels({
     selection.snapshot,
   );
   const agents = useContext(AgentsContext);
+  const agentSnapshot = useAgentsSnapshot(agents);
+  const unavailableType =
+    resettable &&
+    pubkeys.some((pubkey) => {
+      const agent = agentSnapshot?.agents.find(
+        (item) => item.pubkey === pubkey,
+      );
+      return (
+        (value[pubkey]?.model || value[pubkey]?.effort) &&
+        agent &&
+        !agents?.types().some((type) => type.key === agent.type)
+      );
+    });
+  const unresolvedInventory =
+    unavailableType ||
+    (resettable &&
+      (agentSnapshot?.status === "loading" ||
+        agentSnapshot?.status === "error") &&
+      pubkeys.some(
+        (pubkey) =>
+          (value[pubkey]?.model || value[pubkey]?.effort) &&
+          !agentSnapshot.agents.some((agent) => agent.pubkey === pubkey),
+      ));
+  const inventoryFailed =
+    unavailableType ||
+    (unresolvedInventory && agentSnapshot?.status === "error");
   // A pick keeps the type it was made under: a retype drops it, even while
   // the new type's choices load or once they fail to, as none showed it.
   // biome-ignore lint/correctness/useExhaustiveDependencies: `mentioned` follows the agents' snapshot, so a retype reruns this.
@@ -131,37 +169,87 @@ export function ComposerModels({
   // Publish the displayed defaults separately from the user's draft picks.
   // A settings refresh or model-only pick must still follow the new default.
   useLayoutEffect(() => {
-    const resolved: Record<string, RunPick> = Object.fromEntries(
-      Object.entries(value).map(([pubkey, { model, effort }]) => [
-        pubkey,
-        { ...(model ? { model } : {}), ...(effort ? { effort } : {}) },
-      ]),
-    );
-    for (const choice of choices) {
-      if (choice.loading || !choice.sendDefaults) continue;
+    const waitingForSavedChoices =
+      resettable &&
+      (unresolvedInventory ||
+        mentioned.some(
+          (choice) =>
+            (choice.loading || choice.failed) &&
+            (value[choice.pubkey]?.model || value[choice.pubkey]?.effort),
+        ));
+    if (waitingForSavedChoices) {
+      onResolved(
+        null,
+        inventoryFailed || mentioned.some((choice) => choice.failed)
+          ? "Saved model and effort choices could not be loaded. Open model and effort controls to retry or reset them."
+          : undefined,
+      );
+      return () => onResolved(undefined);
+    }
+    const resolved: Record<string, RunPick> = resettable
+      ? {}
+      : Object.fromEntries(
+          Object.entries(value).map(([pubkey, { model, effort }]) => [
+            pubkey,
+            { ...(model ? { model } : {}), ...(effort ? { effort } : {}) },
+          ]),
+        );
+    for (const choice of resettable ? mentioned : choices) {
+      if (choice.loading || choice.failed) continue;
       const saved = value[choice.pubkey] ?? {};
+      const selected = choice.models.find((item) => item.id === saved.model);
       const runs = runModel(choice, saved.model);
-      if (!runs.id) continue;
-      const effort = runs.efforts.some((item) => item.id === saved.effort)
-        ? saved.effort
-        : runs.efforts.some((item) => item.id === runs.effort)
+      if (!runs?.id) continue;
+      const explicitEffort = runs.efforts.find(
+        (item) =>
+          item.id === saved.effort &&
+          (!resettable || !saved.model || selected !== undefined),
+      )?.id;
+      const effort =
+        explicitEffort ??
+        (runs.efforts.some((item) => item.id === runs.effort)
           ? runs.effort
-          : undefined;
-      resolved[choice.pubkey] = {
-        model: runs.id,
-        ...(effort ? { effort } : {}),
-      };
+          : undefined);
+      if (choice.sendDefaults && !explicitOnly) {
+        resolved[choice.pubkey] = {
+          model: runs.id,
+          ...(effort ? { effort } : {}),
+        };
+      } else if (resettable && (selected || explicitEffort)) {
+        resolved[choice.pubkey] = {
+          ...(selected ? { model: selected.id } : {}),
+          ...(explicitEffort ? { effort: explicitEffort } : {}),
+        };
+      }
     }
     onResolved(resolved);
-    return () => onResolved({});
-  }, [choices, value, onResolved]);
-  if (!choices.length) return null;
+    return () => onResolved(undefined);
+  }, [
+    choices,
+    mentioned,
+    value,
+    onResolved,
+    resettable,
+    explicitOnly,
+    unresolvedInventory,
+    inventoryFailed,
+  ]);
+  const canReset =
+    resettable &&
+    pubkeys.some((pubkey) => value[pubkey]?.model || value[pubkey]?.effort);
+  if (!choices.length && !inventoryFailed && !canReset) return null;
   const picked = choices.flatMap((choice) => {
+    if (choice.loading) return [];
     const { model, effort } = value[choice.pubkey] ?? {};
     const runs = runModel(choice, model);
+    const selected = choice.models.some((item) => item.id === model);
+    const savedEffortApplies = !resettable || !model || selected;
+    const supportedEffort = savedEffortApplies
+      ? runs.efforts.find((item) => item.id === effort)
+      : undefined;
     const text = [
-      model !== undefined && runs.label,
-      runs.efforts.find((item) => item.id === effort)?.label,
+      selected && runs.label,
+      effort !== undefined && supportedEffort?.label,
     ]
       .filter(Boolean)
       .join(" · ");
@@ -177,8 +265,11 @@ export function ComposerModels({
     );
   };
   const label = choices.some((choice) => choice.session)
-    ? "Model, effort, and session controls"
-    : "Model and effort for the next run";
+    ? `Model, effort, and session controls${resettable ? " for this chat" : ""}`
+    : resettable
+      ? "Model and effort for this chat"
+      : "Model and effort for the next run";
+  const target = resettable ? "this chat" : "next run";
   return (
     <Popover.Root open={open && !disabled} onOpenChange={setOpen}>
       <Popover.Trigger
@@ -192,7 +283,9 @@ export function ComposerModels({
             data-selected={picked.length ? "" : undefined}
             aria-label={label}
             title={
-              picked.length ? `${label}. Next run: ${picked.join(", ")}` : label
+              picked.length
+                ? `${label}. ${target}: ${picked.join(", ")}`
+                : label
             }
             icon={<GaugeIcon size={18} aria-hidden="true" />}
           />
@@ -213,6 +306,52 @@ export function ComposerModels({
             aria-label={label}
             initialFocus={thumb}
           >
+            {inventoryFailed && (
+              <div className={`${styles.agent} floating-surface`}>
+                <PanelHeader
+                  variant="card"
+                  title={<PanelHeaderLabel title="Model and effort" />}
+                />
+                <div className={styles.controls}>
+                  <div className={styles.status}>
+                    <span className={styles.statusCopy} role="alert">
+                      Agents could not be loaded.
+                    </span>
+                    {onRetryInventory && (
+                      <Button
+                        size="sm"
+                        onClick={() => {
+                          onRetryInventory();
+                          setOpen(false);
+                        }}
+                      >
+                        Retry agents
+                      </Button>
+                    )}
+                  </div>
+                </div>
+              </div>
+            )}
+            {canReset && (
+              <Button
+                variant="subtle"
+                size="sm"
+                onClick={() => {
+                  const addressed = new Set(pubkeys);
+                  onChange(
+                    Object.fromEntries(
+                      Object.entries(value).filter(
+                        ([pubkey]) => !addressed.has(pubkey),
+                      ),
+                    ),
+                    [...addressed],
+                  );
+                  setOpen(false);
+                }}
+              >
+                Reset model and effort
+              </Button>
+            )}
             {choices.map((choice, index) => (
               <AgentChoice
                 key={choice.pubkey}
@@ -224,6 +363,8 @@ export function ComposerModels({
                 place={place}
                 value={value[choice.pubkey] ?? {}}
                 disabled={disabled}
+                chatScoped={resettable}
+                retry={() => setRetry((attempt) => attempt + 1)}
                 pick={(next) => pick(choice.pubkey, next)}
                 {...(index === 0 ? { thumb } : {})}
               />
@@ -247,6 +388,8 @@ function AgentChoice({
   place,
   value,
   disabled,
+  chatScoped,
+  retry,
   pick,
   thumb,
 }: {
@@ -255,6 +398,8 @@ function AgentChoice({
   place: SessionPlace;
   value: RunPick;
   disabled: boolean;
+  chatScoped: boolean;
+  retry(): void;
   pick(next: RunPick): void;
   thumb?: Ref<HTMLInputElement>;
 }) {
@@ -287,16 +432,23 @@ function AgentChoice({
       </div>
     );
   const runs = runModel(choice, value.model);
+  const selectedModel = choice.models.some((item) => item.id === value.model)
+    ? value.model
+    : undefined;
+  const selectedEffort =
+    !chatScoped || !value.model || selectedModel !== undefined
+      ? runs.efforts.find((item) => item.id === value.effort)?.id
+      : undefined;
   const several = choice.models.length > 1;
-  // Picking the agent's own model is no pick; an effort the new model lacks
-  // falls back to its default.
+  // Chat choices stay explicit even when they match the provider default.
+  // An effort the new model lacks falls back to its default.
   const chooseModel = (id: string) => {
     const next = choice.models.find((item) => item.id === id);
     const effort = next?.efforts.some((item) => item.id === value.effort)
       ? value.effort
       : undefined;
     pick({
-      ...(id !== choice.current ? { model: id } : {}),
+      ...(chatScoped || id !== choice.current ? { model: id } : {}),
       ...(effort ? { effort } : {}),
     });
   };
@@ -306,7 +458,11 @@ function AgentChoice({
         <MenuRoot>
           <MenuTrigger
             disabled={disabled}
-            aria-label={`Model for ${choice.name}'s next run`}
+            aria-label={
+              chatScoped
+                ? `Model for ${choice.name} in this chat`
+                : `Model for ${choice.name}'s next run`
+            }
             render={
               <Button variant="subtle" size="sm">
                 <span className={styles.about}>{runs.label}</span>
@@ -353,18 +509,28 @@ function AgentChoice({
         }
       />
       <div className={styles.controls}>
-        {runs.efforts.length > 0 ? (
+        {choice.failed ? (
+          <div className={styles.status}>
+            <span className={styles.statusCopy} role="alert">
+              Model and effort could not be loaded.
+            </span>
+            <Button size="sm" disabled={disabled} onClick={retry}>
+              Retry
+            </Button>
+          </div>
+        ) : runs.efforts.length > 0 ? (
           <EffortSlider
             name={choice.name}
+            chatScoped={chatScoped}
             avatarSrc={avatarSrc}
             model={model}
             efforts={runs.efforts}
             resting={runs.effort}
-            value={value.effort}
+            value={selectedEffort}
             disabled={disabled}
             pick={(effort) =>
               pick({
-                ...(value.model ? { model: value.model } : {}),
+                ...(selectedModel ? { model: selectedModel } : {}),
                 ...(effort ? { effort } : {}),
               })
             }
diff --git a/src/features/messages/MessageComposer.test.tsx b/src/features/messages/MessageComposer.test.tsx
index 9429703bf7..f586ece831 100644
--- a/src/features/messages/MessageComposer.test.tsx
+++ b/src/features/messages/MessageComposer.test.tsx
@@ -66,7 +66,7 @@ import { ClaudeProcess } from "../../bundled/claude-code/claude";
 import { fakeSpawn } from "../../bundled/claude-code/claude-testing";
 import { ConversationPresentation } from "../conversation/ConversationPresentation";
 import { AgentsContext } from "../agents/react";
-import type { Agents } from "../agents/service";
+import type { Agents, Models } from "../agents/service";
 import { MessageComposer, type MessageComposerProps } from "./MessageComposer";
 import { MessageMarkdown } from "./MessageMarkdown";
 import { InlineChip } from "../../shared/design-system/ui/InlineChip";
@@ -93,6 +93,7 @@ import type { ComposerInputElement } from "./composer-dom";
 import { profileTarget } from "../profiles/target";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { setRememberAgentsPreference } from "./mention-preferences";
+import * as modelStorage from "./solo-model-picks-storage";
 import { setDefaultAgent } from "../solo/default-agent";
 import { ResourcePicker } from "../../bundled/repos/ResourcePicker";
 import { entityHref } from "../repos/routes";
@@ -112,6 +113,11 @@ vi.mock("../../shared/design-system/ui/InlineChip", async (importOriginal) => {
   return { ...actual, InlineChip: vi.fn(actual.InlineChip) };
 });
 
+vi.mock(
+  "./solo-model-picks-storage",
+  () => import("./solo-model-picks-storage-testing"),
+);
+
 composerDOMFixture();
 
 const owners: ReturnType<typeof createRelaySession>[] = [];
@@ -185,6 +191,16 @@ const localAgent = {
   owner: "d".repeat(64),
 };
 
+async function choicesLoaded() {
+  await waitFor(() =>
+    expect(
+      screen
+        .getByRole("form")
+        .querySelector('.buzz-loading-region[aria-busy="true"]'),
+    ).toBeNull(),
+  );
+}
+
 function mount(
   options: Partial<MessageComposerProps> = {},
   control?: LocalAgents,
@@ -2265,7 +2281,7 @@ it.each(["never", "before the failure", "after the failure"])(
     expect(button).toHaveAttribute("data-selected");
     await userEvent.hover(button);
     expect(await screen.findByRole("tooltip")).toHaveTextContent(
-      "Next run: High",
+      "next run: High",
     );
     await userEvent.unhover(button);
     expect(h.publish).not.toHaveBeenCalled();
@@ -3378,17 +3394,14 @@ it("keeps a pick through a failed discovery of the agent's same type", async ()
   await honey.pickHigh();
   honey.listing.fails = true;
   honey.refresh();
-  // Discovery's failure omits Honey, and the picker with it.
-  await waitFor(() =>
-    expect(
-      screen.queryByRole("button", { name: /Model.*effort/ }),
-    ).not.toBeInTheDocument(),
+  await honey.h.user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
   );
+  await screen.findByText("Model and effort could not be loaded.");
   honey.listing.fails = false;
-  honey.refresh();
-  expect(
-    await screen.findByRole("button", { name: /Model.*effort/ }),
-  ).toBeVisible();
+  await honey.h.user.click(screen.getByRole("button", { name: "Retry" }));
+  await screen.findByLabelText("Effort for Honey's next run");
+  await honey.h.user.keyboard("{Escape}");
   expect(await honey.sentPick()).toEqual({ effort: "high" });
 });
 
@@ -3614,17 +3627,16 @@ const sessionAgents = (
     label: string;
     efforts: readonly { id: string; label: string }[];
   }[] = [{ id: "fast", label: "Fast", efforts: [] }],
+  pubkeys: readonly string[] = [first.pubkey],
 ) => {
   const snapshot = {
     status: "ready",
-    agents: [
-      {
-        key: first.pubkey,
-        pubkey: first.pubkey,
-        name: "Honey",
-        type: "test/agent",
-      },
-    ],
+    agents: pubkeys.map((pubkey) => ({
+      key: pubkey,
+      pubkey,
+      name: "Honey",
+      type: "test/agent",
+    })),
   };
   let state: "idle" | "active" | "compacting" | "unavailable" = "idle";
   const listeners = new Set<() => void>();
@@ -4513,6 +4525,7 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
       {
         id: "fast",
         label: "Fast",
+        effort: "low",
         efforts: [
           { id: "low", label: "Low" },
           { id: "high", label: "High" },
@@ -4533,6 +4546,7 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
     find: (pubkey: string) =>
       snapshot.agents.find((agent) => agent.pubkey === pubkey),
     joinable: () => [],
+    portable: async () => ({ agents: [] }),
     sessionState: () => "unavailable" as const,
     subscribe: () => () => {},
     snapshot: () => snapshot,
@@ -4562,8 +4576,12 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
     await h.user.click(screen.getByRole("button", { name }));
   };
   const send = async () => {
+    const sent = h.messages.send.mock.calls.length;
     await h.user.keyboard("{Escape}");
     await h.user.click(screen.getByRole("button", { name: "Send message" }));
+    await waitFor(() =>
+      expect(h.messages.send).toHaveBeenCalledTimes(sent + 1),
+    );
   };
   expect(picker()).toBeNull();
   await h.user.click(screen.getByRole("button", { name: "Second Honey" }));
@@ -4572,8 +4590,8 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
   await write("First Honey", "think hard");
   const slider = await open();
   expect(model()).toHaveTextContent("Fast");
-  expect(slider).toHaveAttribute("aria-valuetext", "Default");
-  expect(slider.closest("[data-unknown]")).not.toBeNull();
+  expect(slider).toHaveAttribute("aria-valuetext", "Low");
+  expect(slider.closest("[data-unknown]")).toBeNull();
   slider.focus();
   await h.user.keyboard("{ArrowRight}");
   expect(slider).toHaveAttribute("aria-valuetext", "High");
@@ -4589,7 +4607,7 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
   );
   await write("First Honey", "think deeper");
   const again = await open();
-  expect(again).toHaveAttribute("aria-valuetext", "Default");
+  expect(again).toHaveAttribute("aria-valuetext", "Low");
   // A new model keeps an effort it also offers.
   again.focus();
   await h.user.keyboard("{ArrowRight}");
@@ -4597,38 +4615,1394 @@ it("asks a mentioned agent of the viewer's for a model and effort on the next ru
   await h.user.click(
     await screen.findByRole("menuitemradio", { name: "Deep" }),
   );
-  expect(model()).toHaveTextContent("Deep");
-  const deep = await screen.findByLabelText("Effort for Honey's next run");
-  expect(deep).toHaveAttribute("aria-valuetext", "High");
-  await send();
-  expect(h.messages.send).toHaveBeenLastCalledWith(
+  expect(model()).toHaveTextContent("Deep");
+  const deep = await screen.findByLabelText("Effort for Honey's next run");
+  expect(deep).toHaveAttribute("aria-valuetext", "High");
+  await send();
+  expect(h.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("think deeper"),
+    [first.pubkey],
+    [],
+    undefined,
+    [],
+    { [first.pubkey]: { model: "deep", effort: "high" } },
+  );
+  await write("First Honey", "as usual");
+  await open();
+  await h.user.click(model());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  // Back to the agent's own model is no pick at all.
+  await h.user.click(model());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Fast" }),
+  );
+  expect(model()).toHaveTextContent("Fast");
+  const usual = await screen.findByLabelText("Effort for Honey's next run");
+  usual.focus();
+  await h.user.keyboard("{ArrowRight}{Home}");
+  expect(usual).toHaveAttribute("aria-valuetext", "Low");
+  await send();
+  expect(h.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("as usual"),
+    [first.pubkey],
+    [],
+  );
+});
+
+function soloModelPreferenceHarness(
+  agents: Agents = sessionAgents("channel", [
+    {
+      id: "fast",
+      label: "Fast",
+      efforts: [
+        { id: "low", label: "Low" },
+        { id: "high", label: "High" },
+      ],
+    },
+    {
+      id: "deep",
+      label: "Deep",
+      efforts: [
+        { id: "low", label: "Low" },
+        { id: "high", label: "High" },
+      ],
+    },
+  ]),
+) {
+  const options = {
+    soloConversation: true,
+    ownSoloConversation: true,
+    chatPresentation: true,
+    requireMention: true,
+  };
+  const mountChat = (
+    channelId = "channel",
+    extra: Partial<MessageComposerProps> = {},
+  ) => {
+    const channel = {
+      id: channelId,
+      channelType: "solo" as const,
+      members: [first.pubkey, second.pubkey],
+    };
+    const channels = [channel, { ...channel, id: "other-chat" }];
+    const channelList = { status: "ready" as const, channels };
+    const composer = mount(
+      { ...options, channelId, ...extra },
+      undefined,
+      undefined,
+      agents,
+    );
+    composer.setLibrary([
+      { pubkey: first.pubkey, name: "Honey" },
+      { pubkey: second.pubkey, name: "Honey" },
+    ]);
+    composer.setProfiles(
+      new Map([
+        [first.pubkey, { name: "Honey", isAgent: true }],
+        [second.pubkey, { name: "Honey", isAgent: true }],
+      ]),
+    );
+    Object.assign(composer.session, {
+      channels: {
+        ...composer.session.channels,
+        list: () => channelList,
+      },
+      channelWrites: {
+        refreshMembership: vi.fn(async () => channel),
+        addAgents: vi.fn(async () => {}),
+      },
+    });
+    return composer;
+  };
+  const write = async (
+    composer: ReturnType<typeof mount>,
+    text: string,
+    recipient = "First Honey",
+  ) => {
+    await composer.user.type(composer.input(), text);
+    await composer.user.click(screen.getByRole("button", { name: recipient }));
+  };
+  const openPicker = async (composer: ReturnType<typeof mount>) =>
+    composer.user.click(
+      await screen.findByRole("button", { name: /Model.*effort/ }),
+    );
+  const modelButton = () =>
+    screen.getByRole("button", { name: "Model for Honey in this chat" });
+  const send = async (composer: ReturnType<typeof mount>) => {
+    await composer.user.keyboard("{Escape}");
+    await composer.user.click(
+      screen.getByRole("button", { name: "Send message" }),
+    );
+  };
+  return { mountChat, write, openPicker, modelButton, send };
+}
+
+it.each(["different", "same"])(
+  "keeps pending Solo edits from two composers for %s agents and orders a later reset",
+  async (target) => {
+    const gate = deferred<void>();
+    let tail: Promise<unknown> = gate.promise;
+    Object.defineProperty(navigator, "locks", {
+      configurable: true,
+      value: {
+        request: (_name: string, run: () => unknown) => {
+          const result = tail.then(run);
+          tail = result.catch(() => {});
+          return result;
+        },
+      },
+    });
+    const agents = sessionAgents(
+      "channel",
+      [
+        { id: "fast", label: "Fast", efforts: [] },
+        { id: "deep", label: "Deep", efforts: [] },
+      ],
+      [first.pubkey, second.pubkey],
+    );
+    const { mountChat } = soloModelPreferenceHarness(agents);
+    const one = mountChat();
+    const two = mountChat();
+    const choose = async (
+      h: ReturnType<typeof mount>,
+      recipient: string,
+      select = true,
+    ) => {
+      if (select)
+        await h.user.click(
+          within(h.container).getByRole("button", { name: recipient }),
+        );
+      await h.user.click(
+        within(h.container).getByRole("button", { name: /Model.*effort/ }),
+      );
+      const model = screen
+        .getAllByRole("button", { name: "Model for Honey in this chat" })
+        .at(recipient === "First Honey" ? 0 : -1);
+      if (!model) throw new Error("Missing addressed model control");
+      await h.user.click(model);
+      await h.user.click(
+        await screen.findByRole("menuitemradio", { name: "Deep" }),
+      );
+      await h.user.keyboard("{Escape}");
+    };
+    try {
+      await choose(one, "First Honey");
+      await choose(
+        two,
+        target === "same" ? "First Honey" : "Second Honey",
+        target !== "same",
+      );
+      expect(readView("scope", "solo:model-picks:channel", null)).toBeNull();
+      await one.user.click(
+        within(one.container).getByRole("button", { name: /Model.*effort/ }),
+      );
+      await one.user.click(
+        screen.getByRole("button", { name: "Reset model and effort" }),
+      );
+    } finally {
+      await act(async () => {
+        gate.resolve();
+        await tail;
+      });
+    }
+    expect(readView("scope", "solo:model-picks:channel", null)).toEqual(
+      target === "same"
+        ? {}
+        : {
+            [second.pubkey]: { model: "deep", type: "test/agent" },
+          },
+    );
+  },
+);
+
+it("keeps a peer's newer Solo snapshot when an earlier save completes", async () => {
+  const gate = deferred<void>();
+  const started = deferred<void>();
+  let saved: Promise<unknown> | undefined;
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: {
+      request: (_name: string, run: () => unknown) => {
+        const result = run();
+        started.resolve();
+        saved = gate.promise.then(() => result);
+        return saved;
+      },
+    },
+  });
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness(
+      sessionAgents(
+        "channel",
+        [
+          { id: "fast", label: "Fast", efforts: [] },
+          { id: "deep", label: "Deep", efforts: [] },
+        ],
+        [first.pubkey, second.pubkey],
+      ),
+    );
+  const h = mountChat();
+  await write(h, "Use the peer's choice");
+  await openPicker(h);
+  await h.user.click(modelButton());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  await started.promise;
+  const storageKey = `buzz-view.v1:${JSON.stringify(["scope", "solo:model-picks:channel"])}`;
+  // Another window commits while this request's completion is still pending.
+  const newer = JSON.stringify({
+    [first.pubkey]: { model: "deep", type: "test/agent" },
+    [second.pubkey]: { model: "deep", type: "test/agent" },
+  });
+  act(() => {
+    localStorage.setItem(storageKey, newer);
+    window.dispatchEvent(
+      new StorageEvent("storage", {
+        key: storageKey,
+        newValue: newer,
+        storageArea: localStorage,
+      }),
+    );
+  });
+  await h.user.keyboard("{Escape}");
+  act(() => expect(h.commands().replaceRecipients([first, second])).toBe(true));
+  await openPicker(h);
+  const peerModel = () =>
+    screen
+      .getAllByRole("button", { name: "Model for Honey in this chat" })
+      .at(-1);
+  try {
+    expect(peerModel()).toHaveTextContent("Deep");
+  } finally {
+    await act(async () => {
+      gate.resolve();
+      await saved;
+    });
+  }
+  expect(peerModel()).toHaveTextContent("Deep");
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+    [second.pubkey]: { model: "deep" },
+  });
+});
+
+it("keeps initial saved choices pending, then supports retry without submitting defaults", async () => {
+  const gate = deferred<never>();
+  const entered = deferred<void>();
+  const transact = modelStorage.transactModelPicks;
+  let pending = true;
+  const storage = vi
+    .spyOn(modelStorage, "transactModelPicks")
+    .mockImplementation((...args) => {
+      if (!pending) return transact(...args);
+      entered.resolve();
+      return gate.promise;
+    });
+  onTestFinished(() => storage.mockRestore());
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", type: "test/agent" },
+  });
+  const { mountChat, write, send } = soloModelPreferenceHarness();
+  const h = mountChat();
+  try {
+    await entered.promise;
+    await write(h, "Keep my prompt");
+    expect(
+      h
+        .input()
+        .closest("form")
+        ?.querySelector('.buzz-loading-region[aria-busy="true"]'),
+    ).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Send message" })).toBeDisabled();
+    expect(
+      screen.getByRole("button", { name: /Model.*for this chat/ }),
+    ).toBeDisabled();
+    h.submit();
+    expect(h.messages.send).not.toHaveBeenCalled();
+  } finally {
+    await act(async () => gate.reject(new Error("IDB unavailable")));
+  }
+  expect(screen.getByRole("alert")).toHaveTextContent("Retry before sending");
+  expect(h.input()).toHaveTextContent("Keep my prompt");
+  pending = false;
+  await h.user.click(
+    screen.getByRole("button", { name: "Retry saved choices" }),
+  );
+  await choicesLoaded();
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+  });
+});
+
+it.each(["readable", "unreadable"])(
+  "waits for a saved Solo snapshot to commit before submitting New chat after a %s acknowledgement",
+  async (acknowledgement) => {
+    const gate = deferred<void>();
+    const completed = deferred<void>();
+    let saving = false;
+    let unreadable = false;
+    const original = Storage.prototype.getItem;
+    const read = vi
+      .spyOn(Storage.prototype, "getItem")
+      .mockImplementation(function (this: Storage, key) {
+        if (unreadable && key.includes("solo:model-picks:new-draft"))
+          throw new Error("Saved choice acknowledgement is unreadable");
+        return original.call(this, key);
+      });
+    onTestFinished(() => read.mockRestore());
+    Object.defineProperty(navigator, "locks", {
+      configurable: true,
+      value: {
+        request: (_name: string, run: () => unknown) =>
+          gate.promise.then(() => {
+            const saved = run();
+            unreadable = acknowledgement === "unreadable";
+            return saved;
+          }),
+      },
+    });
+    const { mountChat, write, openPicker, modelButton } =
+      soloModelPreferenceHarness();
+    const submit = vi.fn();
+    const h = mountChat("channel", {
+      submission: {
+        draftKey: "new-draft",
+        modelPicksKey: "solo:model-picks:new-draft",
+        locked: false,
+        disabled: false,
+        unsaved: (held) => {
+          if (saving && !held) completed.resolve();
+        },
+        submit,
+      },
+    });
+    await write(h, "Start with these choices");
+    await openPicker(h);
+    saving = true;
+    await h.user.click(modelButton());
+    await h.user.click(
+      await screen.findByRole("menuitemradio", { name: "Deep" }),
+    );
+    await h.user.keyboard("{Escape}");
+    await act(async () => {
+      gate.resolve();
+      // Persistence has finished, but this act batch has not committed its snapshot.
+      await completed.promise;
+      fireEvent.submit(screen.getByRole("form"));
+      expect(submit).not.toHaveBeenCalled();
+    });
+    if (acknowledgement === "unreadable") {
+      expect(
+        screen.getByText(/Could not read saved model and effort/),
+      ).toHaveTextContent("Retry before sending");
+      unreadable = false;
+      act(() => {
+        fireEvent.click(
+          screen.getByRole("button", { name: "Retry saved choices" }),
+        );
+        fireEvent.submit(screen.getByRole("form"));
+        expect(submit).not.toHaveBeenCalled();
+      });
+    } else {
+      expect(screen.getByRole("alert")).toHaveTextContent(
+        "choices are still saving",
+      );
+    }
+    await choicesLoaded();
+    fireEvent.submit(screen.getByRole("form"));
+    expect(submit).toHaveBeenCalledOnce();
+    expect(submit.mock.calls[0]?.[3]).toEqual({
+      [first.pubkey]: { model: "deep" },
+    });
+    expect(submit.mock.calls[0]?.[5]).toBe(
+      await modelStorage.transactModelPicks(
+        "scope",
+        ["solo:model-picks:new-draft"],
+        (tx) => tx.version("solo:model-picks:new-draft"),
+      ),
+    );
+  },
+);
+
+it("keeps a pending Solo choice out of Send until its persistence settles", async () => {
+  const gate = deferred<void>();
+  const started = deferred<void>();
+  let saved: Promise<unknown> | undefined;
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: {
+      request: (_name: string, run: () => unknown) => {
+        started.resolve();
+        saved = gate.promise.then(run);
+        return saved;
+      },
+    },
+  });
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness();
+  const h = mountChat();
+  await write(h, "Keep this prompt");
+  await openPicker(h);
+  await h.user.click(modelButton());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  try {
+    await send(h);
+    expect(h.messages.send).not.toHaveBeenCalled();
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "choices are still saving",
+    );
+    expect(h.input()).toHaveTextContent("Keep this prompt");
+  } finally {
+    await act(async () => {
+      gate.resolve();
+      await saved;
+    });
+  }
+  await started.promise;
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+  });
+});
+
+it.each(["missing", "rejected"])(
+  "retains Solo intent when window ownership is %s",
+  async (failure) => {
+    Object.defineProperty(navigator, "locks", {
+      configurable: true,
+      value:
+        failure === "missing"
+          ? undefined
+          : {
+              request: async () => {
+                throw new Error("Lock refused");
+              },
+            },
+    });
+    const { mountChat, write, openPicker, modelButton, send } =
+      soloModelPreferenceHarness();
+    const h = mountChat();
+    await write(h, "Use my selection");
+    await openPicker(h);
+    await h.user.click(modelButton());
+    await h.user.click(
+      await screen.findByRole("menuitemradio", { name: "Deep" }),
+    );
+    expect(await screen.findByRole("alert")).toHaveTextContent(
+      "Could not save model and effort",
+    );
+    expect(readView("scope", "solo:model-picks:channel", null)).toBeNull();
+    await send(h);
+    await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+      [first.pubkey]: { model: "deep" },
+    });
+  },
+);
+
+it("sends and restores model and effort per Solo chat and agent", async () => {
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness();
+  const h = mountChat();
+  await write(h, "a");
+  await openPicker(h);
+  await h.user.click(modelButton());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  const effort = await screen.findByLabelText("Effort for Honey in this chat");
+  effort.focus();
+  await h.user.keyboard("{ArrowRight}");
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.[0]).toBe("channel");
+  expect(h.messages.send.mock.calls[0]?.[1]).toContain("a");
+  expect(h.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high" },
+  });
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+
+  await write(h, "b", "Second Honey");
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledTimes(2));
+  expect(h.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("b"),
+    [second.pubkey],
+    [],
+  );
+
+  await write(h, "c");
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledTimes(3));
+  expect(h.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("c"),
+    [first.pubkey],
+    [],
+    undefined,
+    [],
+    { [first.pubkey]: { model: "deep", effort: "high" } },
+  );
+
+  h.retarget({ channelId: "other-chat" });
+  await write(h, "d");
+  await openPicker(h);
+  await waitFor(() => expect(modelButton()).toHaveTextContent("Fast"));
+  await h.user.keyboard("{Escape}");
+  h.retarget({ channelId: "channel" });
+  await write(h, "e");
+  await openPicker(h);
+  await waitFor(() => expect(modelButton()).toHaveTextContent("Deep"));
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledTimes(4));
+
+  h.unmount();
+  const reopened = mountChat();
+  await reopened.user.type(reopened.input(), "d");
+  await reopened.user.click(
+    screen.getByRole("button", { name: "First Honey" }),
+  );
+  await reopened.user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
+  );
+  expect(
+    screen.getByRole("button", { name: "Model for Honey in this chat" }),
+  ).toHaveTextContent("Deep");
+  expect(
+    await screen.findByLabelText("Effort for Honey in this chat"),
+  ).toHaveAttribute("aria-valuetext", "High");
+  await send(reopened);
+  await waitFor(() => expect(reopened.messages.send).toHaveBeenCalledOnce());
+  expect(reopened.messages.send.mock.calls[0]?.[1]).toContain("d");
+  expect(reopened.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
+  expect(reopened.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high" },
+  });
+});
+
+it("retains an explicitly selected default Solo model and effort after provider defaults change", async () => {
+  const efforts = [
+    { id: "low", label: "Low" },
+    { id: "high", label: "High" },
+  ];
+  const fast = { id: "fast", label: "Fast", effort: "low", efforts };
+  const models = [fast, { id: "deep", label: "Deep", efforts }];
+  const agents = sessionAgents("channel", models);
+  let current = "fast";
+  const type = agents.types()[0];
+  if (!type) throw new Error("The fixture agent type should exist.");
+  const types = [{ ...type, models: () => ({ current, models }) }];
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness({ ...agents, types: () => types } as Agents);
+  const h = mountChat();
+  await write(h, "pin the default");
+  await openPicker(h);
+  for (const name of ["Deep", "Fast"]) {
+    await h.user.click(modelButton());
+    await h.user.click(await screen.findByRole("menuitemradio", { name }));
+  }
+  const effort = await screen.findByLabelText("Effort for Honey in this chat");
+  effort.focus();
+  await h.user.keyboard("{ArrowRight}{Home}");
+  expect(effort).toHaveAttribute("aria-valuetext", "Low");
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+    [first.pubkey]: { model: "fast", effort: "low", type: "test/agent" },
+  });
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  h.unmount();
+  current = "deep";
+  fast.effort = "high";
+  const reopened = mountChat();
+  await write(reopened, "keep Fast");
+  await openPicker(reopened);
+  expect(modelButton()).toHaveTextContent("Fast");
+  expect(
+    await screen.findByLabelText("Effort for Honey in this chat"),
+  ).toHaveAttribute("aria-valuetext", "Low");
+  await send(reopened);
+  await waitFor(() => expect(reopened.messages.send).toHaveBeenCalledOnce());
+  expect(reopened.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("keep Fast"),
+    [first.pubkey],
+    [],
+    undefined,
+    [],
+    { [first.pubkey]: { model: "fast", effort: "low" } },
+  );
+});
+
+it("keeps newer Solo choices when a background upload restores its draft", async () => {
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness();
+  const h = mountChat();
+  const gate = deferred<ReturnType<typeof uploadDescriptor>>();
+  const upload = vi.fn(() => gate.promise);
+  h.retarget({ session: { ...h.session, attachments: { upload } } });
+  await write(h, "original caption");
+  await openPicker(h);
+  await h.user.click(modelButton());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  await h.user.keyboard("{Escape}");
+  attachByPaste(h.input(), attachmentFile("original.txt"));
+  try {
+    await waitFor(() => expect(upload).toHaveBeenCalledOnce());
+    await send(h);
+    await waitFor(() =>
+      expect(h.input().value).not.toContain("original caption"),
+    );
+    await openPicker(h);
+    await h.user.click(
+      screen.getByRole("button", { name: "Reset model and effort" }),
+    );
+    await h.user.keyboard("{Escape}");
+  } finally {
+    await act(async () => gate.reject(new Error("offline")));
+  }
+  await waitFor(() => expect(h.input().value).toContain("original caption"));
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({});
+  await openPicker(h);
+  expect(modelButton()).toHaveTextContent("Fast");
+  await h.user.keyboard("{Escape}");
+  await h.user.click(
+    screen.getByRole("button", { name: "Remove original.txt" }),
+  );
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send).toHaveBeenLastCalledWith(
+    "channel",
+    expect.stringContaining("original caption"),
+    [first.pubkey],
+    [],
+  );
+});
+
+it("keeps Reset available when a Solo catalog has no configurable choices", async () => {
+  const agents = sessionAgents("channel");
+  const type = agents.types()[0];
+  if (!type) throw new Error("The fixture agent type should exist.");
+  const { sessionControls: _, ...modelType } = type;
+  const types = [
+    {
+      ...modelType,
+      models: () => ({
+        current: "fast",
+        models: [{ id: "fast", label: "Fast", efforts: [] }],
+      }),
+    },
+  ];
+  const { mountChat, write, openPicker, send } = soloModelPreferenceHarness({
+    ...agents,
+    types: () => types,
+  });
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  const h = mountChat();
+  await write(h, "Use defaults");
+  await openPicker(h);
+  await h.user.click(
+    screen.getByRole("button", { name: "Reset model and effort" }),
+  );
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({});
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send).toHaveBeenCalledWith(
+    "channel",
+    expect.stringContaining("Use defaults"),
+    [first.pubkey],
+    [],
+  );
+});
+
+it("retries an unreadable initial Solo preference without silently sending defaults", async () => {
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness();
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  const storageKey = `buzz-view.v1:${JSON.stringify(["scope", "solo:model-picks:channel"])}`;
+  const getItem = Storage.prototype.getItem;
+  let unavailable = true;
+  const read = vi
+    .spyOn(Storage.prototype, "getItem")
+    .mockImplementation(function (this: Storage, key) {
+      if (key === storageKey && unavailable)
+        throw new DOMException("Storage unavailable");
+      return getItem.call(this, key);
+    });
+  onTestFinished(() => read.mockRestore());
+  const h = mountChat();
+  await write(h, "Keep my saved model");
+  await send(h);
+  expect(
+    await screen.findByText(/Could not read saved model and effort/),
+  ).toBeVisible();
+  expect(h.messages.send).not.toHaveBeenCalled();
+  await h.user.click(
+    screen.getByRole("button", { name: "Retry saved choices" }),
+  );
+  expect(
+    screen.getByText(/Could not read saved model and effort/),
+  ).toBeVisible();
+  unavailable = false;
+  await h.user.click(
+    screen.getByRole("button", { name: "Retry saved choices" }),
+  );
+  await openPicker(h);
+  expect(modelButton()).toHaveTextContent("Deep");
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high" },
+  });
+});
+
+it("uses the supported Solo model and effort when saved choices are unavailable", async () => {
+  const { mountChat, modelButton, send } = soloModelPreferenceHarness();
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "removed", effort: "high", type: "test/agent" },
+  });
+  const unsupported = mountChat();
+  await unsupported.user.type(unsupported.input(), "a");
+  await unsupported.user.click(
+    screen.getByRole("button", { name: "First Honey" }),
+  );
+  const trigger = await screen.findByRole("button", { name: /Model.*effort/ });
+  expect(trigger).not.toHaveAttribute("data-selected");
+  await unsupported.user.click(trigger);
+  expect(modelButton()).toHaveTextContent("Fast");
+  expect(
+    await screen.findByLabelText("Effort for Honey in this chat"),
+  ).toHaveAttribute("aria-valuetext", "Default");
+  await send(unsupported);
+  await waitFor(() => expect(unsupported.messages.send).toHaveBeenCalledOnce());
+  expect(unsupported.messages.send).toHaveBeenCalledWith(
+    "channel",
+    expect.stringContaining("a"),
+    [first.pubkey],
+    [],
+  );
+
+  unsupported.unmount();
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", effort: "ultra", type: "test/agent" },
+  });
+  const unsupportedEffort = mountChat();
+  await unsupportedEffort.user.type(unsupportedEffort.input(), "b");
+  await unsupportedEffort.user.click(
+    screen.getByRole("button", { name: "First Honey" }),
+  );
+  await screen.findByRole("button", { name: /Model.*effort/ });
+  await send(unsupportedEffort);
+  await waitFor(() =>
+    expect(unsupportedEffort.messages.send).toHaveBeenCalledOnce(),
+  );
+  expect(unsupportedEffort.messages.send.mock.calls[0]?.[1]).toContain("b");
+  expect(unsupportedEffort.messages.send.mock.calls[0]?.[2]).toEqual([
+    first.pubkey,
+  ]);
+  expect(unsupportedEffort.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+  });
+  unsupportedEffort.unmount();
+});
+
+it.each(
+  ["inventory", "type"].flatMap((missing) =>
+    ["retry", "reset"].map((recovery) => ({ missing, recovery })),
+  ),
+)(
+  "recovers missing Solo $missing with $recovery and keeps retained choices usable",
+  async ({ missing, recovery }) => {
+    let resolveModels!: (value: Models) => void;
+    const pendingModels = new Promise<Models>((resolve) => {
+      resolveModels = resolve;
+    });
+    const readyAgents = sessionAgents("channel");
+    const type = readyAgents.types()[0];
+    if (!type) throw new Error("The fixture agent type should exist.");
+    const delayedTypes = [{ ...type, models: () => pendingModels }];
+    const readySnapshot = readyAgents.snapshot();
+    let snapshot: ReturnType<Agents["snapshot"]> = {
+      ...readySnapshot,
+      status: missing === "type" ? "ready" : "loading",
+      agents: missing === "type" ? readySnapshot.agents : [],
+    };
+    let typesAvailable = missing !== "type";
+    const absentTypes: ReturnType<Agents["types"]> = [];
+    const listeners = new Set<() => void>();
+    const loadInventory = () => {
+      snapshot = readySnapshot;
+      typesAvailable = true;
+      for (const listener of listeners) listener();
+    };
+    const agents = {
+      ...readyAgents,
+      snapshot: () => snapshot,
+      find: (pubkey: string) =>
+        snapshot.agents.find((agent) => agent.pubkey === pubkey),
+      subscribe: (listener: () => void) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+      types: () => (typesAvailable ? delayedTypes : absentTypes),
+    } as Agents;
+    const { mountChat, write, send } = soloModelPreferenceHarness(agents);
+    writeView("scope", "solo:model-picks:channel", {
+      [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+    });
+    const h = mountChat();
+    const refresh = vi.fn(async () => loadInventory());
+    Object.assign(h.session, {
+      agentChoices: { ...h.session.agentChoices, refresh },
+    });
+    try {
+      await write(h, "a");
+      await send(h);
+      expect(h.messages.send).not.toHaveBeenCalled();
+      expect(await screen.findByRole("alert")).toHaveTextContent(
+        missing === "type"
+          ? "Saved model and effort choices could not be loaded"
+          : "Saved model and effort choices are still loading",
+      );
+      act(() => {
+        snapshot = { ...snapshot, status: "error", error: "Inventory offline" };
+        for (const listener of listeners) listener();
+      });
+      await send(h);
+      expect(h.messages.send).not.toHaveBeenCalled();
+      expect(await screen.findByRole("alert")).toHaveTextContent(
+        "Saved model and effort choices could not be loaded",
+      );
+      await h.user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      if (recovery === "reset") {
+        await h.user.click(
+          screen.getByRole("button", { name: "Reset model and effort" }),
+        );
+        expect(readView("scope", "solo:model-picks:channel", null)).toEqual({});
+        await send(h);
+        await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+        expect(h.messages.send).toHaveBeenLastCalledWith(
+          "channel",
+          expect.stringContaining("a"),
+          [first.pubkey],
+          [],
+        );
+        expect(refresh).not.toHaveBeenCalled();
+        return;
+      }
+      await h.user.click(screen.getByRole("button", { name: "Retry agents" }));
+      expect(refresh).toHaveBeenCalledOnce();
+      await h.user.keyboard("{Escape}");
+      await send(h);
+      expect(h.messages.send).not.toHaveBeenCalled();
+    } finally {
+      await act(async () => {
+        loadInventory();
+        resolveModels({
+          current: "fast",
+          models: [
+            {
+              id: "fast",
+              label: "Fast",
+              efforts: [{ id: "low", label: "Low" }],
+            },
+            {
+              id: "deep",
+              label: "Deep",
+              efforts: [{ id: "high", label: "High" }],
+            },
+          ],
+        });
+        await pendingModels;
+      });
+    }
+    await send(h);
+    await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+      [first.pubkey]: { model: "deep", effort: "high" },
+    });
+    act(() => {
+      snapshot = {
+        ...readySnapshot,
+        status: "error",
+        error: "Inventory refresh offline",
+      };
+      for (const listener of listeners) listener();
+    });
+    await write(h, "keep using the loaded choices");
+    await h.user.click(
+      await screen.findByRole("button", { name: /Model.*effort/ }),
+    );
+    expect(
+      await screen.findByRole("button", {
+        name: "Model for Honey in this chat",
+      }),
+    ).toHaveTextContent("Deep");
+    expect(
+      await screen.findByLabelText("Effort for Honey in this chat"),
+    ).toHaveAttribute("aria-valuetext", "High");
+    await send(h);
+    await waitFor(() => expect(h.messages.send).toHaveBeenCalledTimes(2));
+    expect(h.messages.send).toHaveBeenLastCalledWith(
+      "channel",
+      expect.stringContaining("keep using the loaded choices"),
+      [first.pubkey],
+      [],
+      undefined,
+      [],
+      { [first.pubkey]: { model: "deep", effort: "high" } },
+    );
+  },
+);
+
+it("keeps saved Solo choices after catalog failure and retries before sending", async () => {
+  const agents = sessionAgents("channel", [
+    { id: "fast", label: "Fast", efforts: [] },
+    {
+      id: "deep",
+      label: "Deep",
+      efforts: [{ id: "high", label: "High" }],
+    },
+  ]);
+  const type = agents.types()[0];
+  if (!type?.models) throw new Error("Expected a model catalog");
+  const models = vi
+    .fn(type.models)
+    .mockRejectedValue(new Error("Catalog offline"));
+  const types = [{ ...type, models }];
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness({ ...agents, types: () => types });
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  const h = mountChat();
+  await write(h, "Keep my choices");
+  await openPicker(h);
+  await screen.findByText(
+    /Model unavailable|Model and effort could not be loaded/,
+  );
+  await send(h);
+  expect(h.messages.send).not.toHaveBeenCalled();
+  expect(await screen.findByRole("alert")).toHaveTextContent(
+    "Saved model and effort choices could not be loaded",
+  );
+  await openPicker(h);
+  models.mockImplementation(type.models);
+  await h.user.click(screen.getByRole("button", { name: "Retry" }));
+  await waitFor(() => expect(modelButton()).toHaveTextContent("Deep"));
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high" },
+  });
+});
+
+it("resets all displayed Solo agents against storage before its event arrives", async () => {
+  const agents = sessionAgents(
+    "channel",
+    [
+      { id: "fast", label: "Fast", efforts: [] },
+      { id: "deep", label: "Deep", efforts: [] },
+    ],
+    [first.pubkey, second.pubkey],
+  );
+  const { mountChat, write, openPicker, send } =
+    soloModelPreferenceHarness(agents);
+  const unrelated = { model: "deep", type: "test/agent" };
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", type: "test/agent" },
+    [resourceOwner]: unrelated,
+  });
+  const h = mountChat();
+  await write(h, "a");
+  await h.user.click(screen.getByRole("button", { name: "Second Honey" }));
+  await openPicker(h);
+  await waitFor(() =>
+    expect(
+      screen.getAllByRole("button", {
+        name: "Model for Honey in this chat",
+      }),
+    ).toHaveLength(2),
+  );
+  // Another window has written, but this window has not received its event.
+  localStorage.setItem(
+    `buzz-view.v1:${JSON.stringify(["scope", "solo:model-picks:channel"])}`,
+    JSON.stringify({
+      [first.pubkey]: { model: "deep", type: "test/agent" },
+      [second.pubkey]: { model: "deep", type: "test/agent" },
+      [resourceOwner]: unrelated,
+    }),
+  );
+  await h.user.click(
+    screen.getByRole("button", { name: "Reset model and effort" }),
+  );
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+    [resourceOwner]: unrelated,
+  });
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send).toHaveBeenCalledWith(
+    "channel",
+    expect.stringContaining("a"),
+    [first.pubkey, second.pubkey],
+    [],
+  );
+});
+
+it("rebases picker edits onto storage updated before the displayed choices rerender", async () => {
+  const agents = sessionAgents(
+    "channel",
+    [
+      { id: "fast", label: "Fast", efforts: [] },
+      { id: "deep", label: "Deep", efforts: [] },
+    ],
+    [first.pubkey, second.pubkey],
+  );
+  const { mountChat, write, openPicker, send } =
+    soloModelPreferenceHarness(agents);
+  const key = "solo:model-picks:channel";
+  const fast = { model: "fast", type: "test/agent" };
+  const deep = { model: "deep", type: "test/agent" };
+  writeView("scope", key, { [first.pubkey]: fast, [second.pubkey]: fast });
+  const h = mountChat();
+  await write(h, "a");
+  await h.user.click(screen.getByRole("button", { name: "Second Honey" }));
+  await openPicker(h);
+  const models = await screen.findAllByRole("button", {
+    name: "Model for Honey in this chat",
+  });
+  expect(models).toHaveLength(2);
+  const firstModel = models[0];
+  if (!firstModel) throw new Error("Expected the first agent's model control");
+  await h.user.click(firstModel);
+  const option = await screen.findByRole("menuitemradio", { name: "Deep" });
+  const storageKey = `buzz-view.v1:${JSON.stringify(["scope", key])}`;
+  act(() => {
+    localStorage.setItem(
+      storageKey,
+      JSON.stringify({ [first.pubkey]: fast, [second.pubkey]: deep }),
+    );
+    window.dispatchEvent(
+      new StorageEvent("storage", {
+        key: storageKey,
+        storageArea: localStorage,
+      }),
+    );
+    fireEvent.click(option);
+  });
+  expect(readView("scope", key, null)).toEqual({
+    [first.pubkey]: deep,
+    [second.pubkey]: deep,
+  });
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+    [second.pubkey]: { model: "deep" },
+  });
+});
+
+it("keeps unsaved Solo choices across edits to another agent and storage updates", async () => {
+  const agents = sessionAgents(
+    "channel",
+    [
+      { id: "fast", label: "Fast", efforts: [] },
+      { id: "deep", label: "Deep", efforts: [] },
+    ],
+    [first.pubkey, second.pubkey],
+  );
+  const { mountChat, write, openPicker, modelButton, send } =
+    soloModelPreferenceHarness(agents);
+  const storageKey = `buzz-view.v1:${JSON.stringify(["scope", "solo:model-picks:channel"])}`;
+  const h = mountChat();
+  await write(h, "a");
+  const originalSetItem = Storage.prototype.setItem;
+  const failedWrite = vi
+    .spyOn(Storage.prototype, "setItem")
+    .mockImplementation(function (this: Storage, key, value) {
+      if (key === storageKey) throw new DOMException("Storage is full");
+      originalSetItem.call(this, key, value);
+    });
+  onTestFinished(() => failedWrite.mockRestore());
+  await openPicker(h);
+  await h.user.click(modelButton());
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  expect(await screen.findByRole("alert")).toHaveTextContent(
+    "Could not save model and effort for this chat",
+  );
+  await h.user.keyboard("{Escape}");
+  const unrelated = { model: "deep", type: "test/agent" };
+  act(() => {
+    originalSetItem.call(
+      localStorage,
+      storageKey,
+      JSON.stringify({ [resourceOwner]: unrelated }),
+    );
+    window.dispatchEvent(
+      new StorageEvent("storage", {
+        key: storageKey,
+        storageArea: localStorage,
+      }),
+    );
+  });
+  expect(screen.getByRole("alert")).toHaveTextContent(
+    "Could not save model and effort for this chat",
+  );
+  await h.user.click(screen.getByRole("button", { name: "Second Honey" }));
+  await openPicker(h);
+  const models = await waitFor(() => {
+    const buttons = screen.getAllByRole("button", {
+      name: "Model for Honey in this chat",
+    });
+    expect(buttons).toHaveLength(2);
+    return buttons;
+  });
+  expect(models[0]).toHaveTextContent("Deep");
+  const secondModel = models[1];
+  if (!secondModel) throw new Error("The second agent's model should exist.");
+  await h.user.click(secondModel);
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  await send(h);
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+    [second.pubkey]: { model: "deep" },
+  });
+  failedWrite.mockRestore();
+  await write(h, "b");
+  await h.user.click(screen.getByRole("button", { name: "Second Honey" }));
+  await openPicker(h);
+  const restoredSecondModel = screen.getAllByRole("button", {
+    name: "Model for Honey in this chat",
+  })[1];
+  if (!restoredSecondModel)
+    throw new Error("The second agent's model should exist after sending.");
+  await h.user.click(restoredSecondModel);
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Fast" }),
+  );
+  expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+    [first.pubkey]: { model: "deep", type: "test/agent" },
+    [second.pubkey]: { model: "fast", type: "test/agent" },
+    [resourceOwner]: unrelated,
+  });
+});
+
+it("resets saved Solo choices and reports persistence failures", async () => {
+  const { mountChat, openPicker, modelButton, send } =
+    soloModelPreferenceHarness();
+  writeView("scope", "solo:model-picks:channel", {
+    [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+    [second.pubkey]: { model: "deep", effort: "low", type: "test/agent" },
+  });
+  const resetChat = mountChat();
+  await resetChat.user.type(resetChat.input(), "a");
+  await resetChat.user.click(
+    screen.getByRole("button", { name: "First Honey" }),
+  );
+  await openPicker(resetChat);
+  await resetChat.user.click(
+    screen.getByRole("button", { name: "Reset model and effort" }),
+  );
+  expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+    [second.pubkey]: { model: "deep", effort: "low", type: "test/agent" },
+  });
+  await send(resetChat);
+  await waitFor(() => expect(resetChat.messages.send).toHaveBeenCalledOnce());
+  expect(resetChat.messages.send).toHaveBeenCalledWith(
     "channel",
-    expect.stringContaining("think deeper"),
+    expect.stringContaining("a"),
     [first.pubkey],
     [],
+  );
+  const key = `buzz-view.v1:${JSON.stringify([
+    "scope",
+    "solo:model-picks:channel",
+  ])}`;
+  const originalSetItem = Storage.prototype.setItem;
+  const failedWrite = vi
+    .spyOn(Storage.prototype, "setItem")
+    .mockImplementation(function (this: Storage, storageKey, value) {
+      if (storageKey === key) throw new DOMException("Storage is full");
+      originalSetItem.call(this, storageKey, value);
+    });
+  onTestFinished(() => failedWrite.mockRestore());
+
+  await resetChat.user.type(resetChat.input(), "b");
+  await openPicker(resetChat);
+  await resetChat.user.click(modelButton());
+  await resetChat.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  expect(await screen.findByRole("alert")).toHaveTextContent(
+    "Could not save model and effort for this chat",
+  );
+  await send(resetChat);
+  await waitFor(() => expect(resetChat.messages.send).toHaveBeenCalledTimes(2));
+  expect(resetChat.messages.send.mock.calls[1]?.[1]).toContain("b");
+  expect(resetChat.messages.send.mock.calls[1]?.[2]).toEqual([first.pubkey]);
+  expect(resetChat.messages.send.mock.calls[1]?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep" },
+  });
+});
+
+it("publishes a queued Solo message with the model and effort captured at submit", async () => {
+  localStorage.setItem("buzz-follow-up-behavior.v1", "queue");
+  const agents = sessionAgents("channel", [
+    { id: "fast", label: "Fast", efforts: [] },
+    {
+      id: "deep",
+      label: "Deep",
+      efforts: [
+        { id: "low", label: "Low" },
+        { id: "high", label: "High" },
+      ],
+    },
+  ]);
+  const h = mount(
+    {
+      soloConversation: true,
+      ownSoloConversation: true,
+      chatPresentation: true,
+      requireMention: true,
+    },
     undefined,
-    [],
-    { [first.pubkey]: { model: "deep", effort: "high" } },
+    "viewer",
+    agents,
+  );
+  h.setLibrary([first]);
+  h.setProfiles(new Map([[first.pubkey, { name: "Honey", isAgent: true }]]));
+  const activityListeners = new Set<() => void>();
+  let activity = {
+    status: "unavailable",
+    records: [],
+    turns: [],
+    typing: [],
+    local: [
+      {
+        agent: first.pubkey,
+        channelId: "channel",
+        messageId: "previous",
+        state: "working",
+        scope: "scope",
+        threadRootId: "",
+        startedAt: 1,
+      },
+    ],
+  };
+  const channel = {
+    id: "channel",
+    channelType: "solo" as const,
+    creator: "viewer",
+    archived: false,
+    readOnly: false,
+  };
+  const channelList = { status: "ready" as const, channels: [channel] };
+  h.retarget({
+    ownSoloConversation: true,
+    requireMention: true,
+    session: {
+      ...h.session,
+      viewer: "viewer",
+      channels: {
+        ...h.session.channels,
+        list: () => channelList,
+      },
+      channelWrites: {
+        refreshMembership: async () => ({
+          id: "channel",
+          members: [first.pubkey],
+        }),
+        addAgents: vi.fn(),
+      },
+      agentActivity: {
+        activate: () => () => {},
+        snapshot: () => activity,
+        subscribe: (listener: () => void) => {
+          activityListeners.add(listener);
+          return () => activityListeners.delete(listener);
+        },
+      },
+    } as unknown as RelaySession,
+  });
+
+  await h.user.type(h.input(), "Queued with the deep model");
+  await h.user.click(screen.getByRole("button", { name: "First Honey" }));
+  await h.user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
+  );
+  await h.user.click(
+    await screen.findByRole("button", { name: "Model for Honey in this chat" }),
   );
-  await write("First Honey", "as usual");
-  await open();
-  await h.user.click(model());
   await h.user.click(
     await screen.findByRole("menuitemradio", { name: "Deep" }),
   );
-  // Back to the agent's own model is no pick at all.
-  await h.user.click(model());
+  const effort = await screen.findByLabelText("Effort for Honey in this chat");
+  effort.focus();
+  await h.user.keyboard("{ArrowRight}");
+  await h.user.keyboard("{Escape}");
+  await h.user.click(screen.getByRole("button", { name: "Send message" }));
+  await screen.findByRole("region", { name: "Queued follow-ups" });
+  expect(h.messages.send).not.toHaveBeenCalled();
+
+  await h.user.type(h.input(), "Next message");
+  await h.user.click(screen.getByRole("button", { name: "First Honey" }));
+  await h.user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
+  );
+  await h.user.click(
+    await screen.findByRole("button", { name: "Model for Honey in this chat" }),
+  );
   await h.user.click(
     await screen.findByRole("menuitemradio", { name: "Fast" }),
   );
-  expect(model()).toHaveTextContent("Fast");
-  await send();
-  expect(h.messages.send).toHaveBeenLastCalledWith(
-    "channel",
-    expect.stringContaining("as usual"),
-    [first.pubkey],
-    [],
+  activity = {
+    ...activity,
+    local: activity.local.map((row) => ({ ...row, state: "done" })),
+  };
+  act(() => {
+    for (const listener of activityListeners) listener();
+  });
+
+  await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+  expect(h.messages.send.mock.calls[0]?.[0]).toBe("channel");
+  expect(h.messages.send.mock.calls[0]?.[1]).toContain(
+    "Queued with the deep model",
   );
+  expect(h.messages.send.mock.calls[0]?.[2]).toEqual([first.pubkey]);
+  expect(h.messages.send.mock.calls.at(-1)?.at(-1)).toEqual({
+    [first.pubkey]: { model: "deep", effort: "high" },
+  });
 });
 
 it("opens the effort picker at the effort the agent's next run uses", async () => {
@@ -5439,7 +6813,7 @@ it("keeps custom emoji text readable and sends repeated shortcodes unchanged", (
 it.each([
   ["  :party: \n\t :party:  ", true],
   [":party:".repeat(24), true],
-  [Array(24).fill(":party:").join(" ") + " 😀", false],
+  [`${Array(24).fill(":party:").join(" ")} 😀`, false],
 ])(
   "classifies images-only emoji drafts without changing their text: %s",
   (draft, imagesOnly) => {
@@ -6183,6 +7557,9 @@ it("keeps retry submission available while a new Solo draft is locked", () => {
     expect.objectContaining({ prepareForSend: expect.any(Function) }),
     // Outside Solo-with-agents no recipients are held apart from the text.
     undefined,
+    undefined,
+    undefined,
+    undefined,
   );
   expect(h.messages.send).not.toHaveBeenCalled();
 });
@@ -6805,11 +8182,19 @@ it("seeds a Berd draft's pill with the default agent once, never its text", asyn
     screen.getByRole("status", { name: "Sending to Selected. Change agents" }),
   ).toBeInTheDocument();
   h.fill("hello");
+  await choicesLoaded();
   h.submit();
   expect(submit).toHaveBeenCalledExactlyOnceWith(
     expect.objectContaining({ text: "hello", recipients: [] }),
     expect.objectContaining({ prepareForSend: expect.any(Function) }),
     [{ pubkey: second.pubkey, name: "Selected" }],
+    {},
+    {},
+    await modelStorage.transactModelPicks(
+      "scope",
+      ["solo:model-picks:channel"],
+      (tx) => tx.version("solo:model-picks:channel"),
+    ),
   );
 });
 
@@ -7423,6 +8808,32 @@ it.each(["changed", "deleted"])(
   },
 );
 
+it("keeps edit errors visible when saved Solo choices cannot be read", async () => {
+  const storage = vi
+    .spyOn(modelStorage, "transactModelPicks")
+    .mockRejectedValue(new Error("IDB unavailable"));
+  onTestFinished(() => storage.mockRestore());
+  const h = mount({ ownSoloConversation: true }, undefined, first.pubkey);
+  expect(
+    await screen.findByText(/Could not read saved model and effort/),
+  ).toBeVisible();
+  const row = editableMessage();
+  h.setRows([row]);
+  fireEvent.keyDown(h.input(), { key: "ArrowUp" });
+  h.fill("My changes");
+  h.setRows([{ ...row, content: "Another client edited this" }]);
+  expect(screen.getByRole("button", { name: "Save changes" })).toBeEnabled();
+  h.submit();
+  expect(
+    screen.getByText(/This message changed while you were editing/),
+  ).toBeVisible();
+  expect(
+    screen.getByRole("button", { name: "Retry saved choices" }),
+  ).toBeEnabled();
+  expect(h.input()).toHaveValue("My changes");
+  expect(h.messages.edit).not.toHaveBeenCalled();
+});
+
 it.each([false, true])(
   "does not publish blank or unchanged content and preserves attachment source (mention: %s)",
   (mention) => {
@@ -9813,6 +11224,9 @@ it("does not apply ordinary draft reconciliation to submission-owned recovery",
     expect.objectContaining({ prepareForSend: expect.any(Function) }),
     // Outside Solo-with-agents no recipients are held apart from the text.
     undefined,
+    undefined,
+    undefined,
+    undefined,
   );
   expect(
     screen.queryByRole("button", { name: "Load saved draft" }),
@@ -10568,6 +11982,7 @@ it("solo follow-ups keep every selected agent in the pill, never the text", asyn
     h.commands().insertText("hello");
   });
   expect(sendingTo("Honey, Honey")).toBeInTheDocument();
+  await choicesLoaded();
   h.submit();
   await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
   expect(h.messages.send.mock.calls.at(-1)?.[2]).toEqual([
@@ -11080,6 +12495,7 @@ it("an inline mention in the middle of the text replaces the pill's fallback", a
   expect(h.commands().recipients).toEqual([
     { pubkey: second.pubkey, name: "Bea" },
   ]);
+  await choicesLoaded();
   h.submit();
   await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
   expect(h.messages.send.mock.calls.at(-1)?.[2]).toEqual([second.pubkey]);
@@ -11451,6 +12867,7 @@ it("queues a tagged agent follow-up while agent choices no longer list it", asyn
   });
   // The library reloads and, for now, no longer lists the tagged agent.
   h.setLibrary([]);
+  await choicesLoaded();
   h.submit();
   await screen.findByRole("region", { name: "Queued follow-ups" });
   expect(h.messages.send).not.toHaveBeenCalled();
@@ -11533,6 +12950,7 @@ it.each([
       h.commands().insertMention(first);
       h.commands().insertText("Follow up");
     });
+    await choicesLoaded();
     h.submit();
     await screen.findByRole("region", { name: "Queued follow-ups" });
     expect(h.messages.send).not.toHaveBeenCalled();
@@ -11674,6 +13092,7 @@ it.each([true, false])(
     h.setLibrary([first]);
     h.retarget({ session, soloConversation: true, ownSoloConversation: owner });
     act(() => h.commands().insertMention(human));
+    await choicesLoaded();
     h.submit();
     await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
     expect(h.messages.send.mock.calls[0]?.[2]).toEqual([human.pubkey]);
@@ -11948,7 +13367,10 @@ it("guards automatic recipient changes using the current draft prose", () => {
 });
 
 /** A mention provider the test publishes for, over the real `@` syntax. */
-function mountPendingMention(options: Partial<MessageComposerProps> = {}) {
+function mountPendingMention(
+  options: Partial<MessageComposerProps> = {},
+  agents?: Agents,
+) {
   const publishes: ComposerCompletionProps["publish"][] = [];
   function Completion({ publish }: ComposerCompletionProps) {
     useLayoutEffect(() => {
@@ -11969,14 +13391,19 @@ function mountPendingMention(options: Partial<MessageComposerProps> = {}) {
   ];
   const empty: [] = [];
   const none = { snapshot: () => empty, subscribe: () => () => {} };
-  const h = mount({
-    ...options,
-    extensions: {
-      tools: none,
-      inline: none,
-      completions: { snapshot: () => completions, subscribe: () => () => {} },
+  const h = mount(
+    {
+      ...options,
+      extensions: {
+        tools: none,
+        inline: none,
+        completions: { snapshot: () => completions, subscribe: () => () => {} },
+      },
     },
-  });
+    undefined,
+    undefined,
+    agents,
+  );
   const resolve = vi.fn<CompletionPending["resolve"]>();
   const publish = () => {
     const publish = publishes.at(-1);
@@ -12781,6 +14208,192 @@ async function sendWhilePending(
   return { ...h, outcome };
 }
 
+it.each([
+  { recipient: first, waitsForChoices: false, label: "the same recipient" },
+  { recipient: second, waitsForChoices: true, label: "a different recipient" },
+])(
+  "captures coherent Solo choices after a pending mention resolves to $label across a storage update",
+  async ({ recipient, waitsForChoices }) => {
+    const key = "solo:model-picks:solo:new-draft";
+    const initial = {
+      [recipient.pubkey]: { model: "deep", type: "test/agent" },
+    };
+    const newer = { [recipient.pubkey]: { model: "fast", type: "test/agent" } };
+    writeView("scope", key, initial);
+    const submit = vi.fn();
+    const h = mountPendingMention(
+      {
+        ownSoloConversation: true,
+        defaultMention: first,
+        requireMention: true,
+        submission: {
+          draftKey: "solo:new-draft",
+          modelPicksKey: key,
+          locked: false,
+          disabled: false,
+          submit,
+        },
+      },
+      sessionAgents(
+        "channel",
+        [
+          { id: "fast", label: "Fast", efforts: [] },
+          { id: "deep", label: "Deep", efforts: [] },
+        ],
+        [first.pubkey, second.pubkey],
+      ),
+    );
+    h.setLibrary([first, second]);
+    h.setProfiles(
+      new Map(
+        [first, second].map(({ pubkey }) => [
+          pubkey,
+          { name: "Honey", isAgent: true },
+        ]),
+      ),
+    );
+    await choicesLoaded();
+    const outcome = deferred<MentionRecipient | null>();
+    try {
+      h.hold("honey", outcome.promise);
+      h.submit();
+      await waitFor(() =>
+        expect(
+          screen.getByRole("button", { name: "Send message" }),
+        ).toBeDisabled(),
+      );
+      expect(submit).not.toHaveBeenCalled();
+      act(() => writeView("scope", key, newer));
+      await choicesLoaded();
+    } finally {
+      await act(async () => outcome.resolve(recipient));
+    }
+    if (waitsForChoices) {
+      expect(submit).not.toHaveBeenCalled();
+      expect(screen.getByRole("alert")).toHaveTextContent(
+        "Saved model and effort choices are still loading. Try sending again shortly.",
+      );
+      expect(h.input()).toHaveValue("@Honey ");
+      expect(readView("scope", key, null)).toEqual(newer);
+      h.submit();
+    }
+    await waitFor(() => expect(submit).toHaveBeenCalledOnce());
+    expect(submit.mock.calls[0]?.slice(3)).toEqual([
+      { [recipient.pubkey]: { model: "fast" } },
+      newer,
+      await modelStorage.transactModelPicks("scope", [key], (tx) =>
+        tx.version(key),
+      ),
+    ]);
+  },
+);
+
+it.each([
+  { sticky: true, label: "saved choices in a shared Solo chat" },
+  { sticky: false, label: "consumed next-run choices in a channel" },
+])("invalidates unmounted picker state for $label", async ({ sticky }) => {
+  setRememberAgentsPreference(false);
+  const h = mountPendingMention(
+    sticky
+      ? {
+          ownSoloConversation: true,
+          soloConversation: true,
+          requireMention: true,
+        }
+      : {},
+    sessionAgents("channel", [
+      { id: "fast", label: "Fast", efforts: [] },
+      {
+        id: "deep",
+        label: "Deep",
+        efforts: [
+          { id: "low", label: "Low" },
+          { id: "high", label: "High" },
+        ],
+      },
+    ]),
+  );
+  if (sticky)
+    Object.assign(h.session, {
+      channels: { ...h.session.channels, list: () => soloList },
+      channelWrites: {
+        refreshMembership: vi.fn(async () => soloList.channels[0]),
+        addAgents: vi.fn(async () => {}),
+      },
+    });
+  h.setLibrary([first]);
+  h.setProfiles(
+    new Map([
+      [first.pubkey, { name: "Honey", isAgent: true }],
+      [second.pubkey, { name: "Sam" }],
+    ]),
+  );
+  h.fill("question");
+  act(() => h.input().replaceRecipients([first]));
+  await h.user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
+  );
+  const context = sticky ? "Honey in this chat" : "Honey's next run";
+  await h.user.click(
+    screen.getByRole("button", {
+      name: `Model for ${context}`,
+    }),
+  );
+  await h.user.click(
+    await screen.findByRole("menuitemradio", { name: "Deep" }),
+  );
+  const effort = await screen.findByLabelText(`Effort for ${context}`);
+  effort.focus();
+  await h.user.keyboard("{End}{Escape}");
+  await choicesLoaded();
+  if (sticky) {
+    act(() => h.input().removeRecipient(first.pubkey));
+    h.fill("question");
+    expect(h.input()).toHaveValue("question");
+  } else {
+    h.submit();
+    await waitFor(() => expect(h.input()).toHaveValue(""));
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+      [first.pubkey]: { model: "deep", effort: "high" },
+    });
+  }
+  expect(screen.queryByRole("button", { name: /Model.*effort/ })).toBeNull();
+  const outcome = deferred<MentionRecipient | null>();
+  try {
+    h.hold("honey", outcome.promise);
+    h.submit();
+    await waitFor(() =>
+      expect(
+        screen.getByRole("button", { name: "Send message" }),
+      ).toBeDisabled(),
+    );
+  } finally {
+    await act(async () => outcome.resolve(first));
+  }
+  if (sticky) {
+    expect(h.messages.send).not.toHaveBeenCalled();
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "Saved model and effort choices are still loading. Try sending again shortly.",
+    );
+    expect(readView("scope", "solo:model-picks:channel", null)).toEqual({
+      [first.pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+    });
+    h.submit();
+    await waitFor(() => expect(h.messages.send).toHaveBeenCalledOnce());
+    expect(h.messages.send.mock.calls[0]?.at(-1)).toEqual({
+      [first.pubkey]: { model: "deep", effort: "high" },
+    });
+  } else {
+    await waitFor(() => expect(h.messages.send).toHaveBeenCalledTimes(2));
+    expect(h.messages.send).toHaveBeenLastCalledWith(
+      "channel",
+      "@Honey ",
+      [first.pubkey],
+      [],
+    );
+  }
+});
+
 it("sending while a mention is pending waits for it, then sends the recipient", async () => {
   const h = await sendWhilePending();
   await act(async () => h.outcome.resolve(first));
diff --git a/src/features/messages/MessageComposer.tsx b/src/features/messages/MessageComposer.tsx
index 783e2cfe66..56a58c2b94 100644
--- a/src/features/messages/MessageComposer.tsx
+++ b/src/features/messages/MessageComposer.tsx
@@ -1,3 +1,10 @@
+import {
+  soloModelPicksKey,
+  parseSoloModelPicks,
+  readSoloModelPicks,
+  updateSoloModelPicks,
+} from "./solo-model-picks";
+import { subscribeModelPicks } from "./solo-model-picks-storage";
 import { useChatLinkSharing } from "./useChatLinkSharing";
 import {
   draftGif,
@@ -42,6 +49,7 @@ import { useListedChannel } from "../relay/listed-channel";
 import { FileDropOverlay } from "./FileDropOverlay";
 import { useFileDrop } from "./use-file-drop";
 import { Button } from "../../shared/design-system/ui/Button";
+import { LoadingRegion } from "../../shared/design-system/ui/LoadingRegion";
 import { IconButton } from "../../shared/design-system/ui/IconButton";
 import { Avatar } from "../../shared/design-system/ui/Avatar";
 import { useBringAgents } from "./useBringAgents";
@@ -322,6 +330,8 @@ export type MessageComposerProps = {
     attachments?: boolean;
     /** DMs can start with files alone; named Solo chats still require text. */
     allowAttachmentOnly?: boolean;
+    /** New Solo chats keep their picks on the stable draft until creation. */
+    modelPicksKey?: string;
     /** Told after each save whether the editor holds a draft it could not
      * save, which view state then misses. */
     unsaved?: ((held: boolean) => void) | undefined;
@@ -330,6 +340,9 @@ export type MessageComposerProps = {
       draft: MentionDraft,
       attachments: AttachmentDraft,
       addressed?: readonly MentionRecipient[],
+      picks?: MentionPicks,
+      draftPicks?: DraftPicks,
+      draftPicksRevision?: string | null,
     ) => void;
   };
 };
@@ -696,8 +709,140 @@ function Composer({
     session.agentChoices.snapshot,
     session.agentChoices.snapshot,
   );
-  // Model and effort picked for mentioned agents' next run; cleared by each send.
-  const [picks, setPicks] = useState<DraftPicks>({});
+  // A Solo chat keeps its explicit model/effort picks across turns and mounts.
+  const stickyPicks = !!ownSoloConversation;
+  const stickyPicksKey =
+    submission?.modelPicksKey ?? soloModelPicksKey(channelId);
+  const [picksSnapshot, setPicksSnapshot] = useState<{
+    picks: DraftPicks;
+    revision: string | null | undefined;
+  }>({ picks: {}, revision: stickyPicks ? undefined : null });
+  const [pickReadFailed, setPickReadFailed] = useState(false);
+  const [picksLoaded, setPicksLoaded] = useState(!stickyPicks);
+  const [pickReadPending, setPickReadPending] = useState(stickyPicks);
+  const committedPicks = useRef(picksSnapshot);
+  const awaitingPickCommit = useRef<typeof picksSnapshot | undefined>(
+    undefined,
+  );
+  useLayoutEffect(() => {
+    committedPicks.current = picksSnapshot;
+    if (awaitingPickCommit.current === picksSnapshot)
+      awaitingPickCommit.current = undefined;
+  }, [picksSnapshot]);
+  const { picks } = picksSnapshot;
+  const picksRevision = useRef(picksSnapshot.revision);
+  const setPicks = useCallback((next: DraftPicks, acknowledgeSave = false) => {
+    const snapshot = { picks: next, revision: picksRevision.current };
+    if (acknowledgeSave || awaitingPickCommit.current)
+      awaitingPickCommit.current = snapshot;
+    setPicksSnapshot(snapshot);
+  }, []);
+  const unsavedDraft = useRef(false);
+  const unsavedPicks = useRef(
+    new Map<
+      string,
+      { pick: DraftPicks[string] | undefined; pending: boolean }
+    >(),
+  );
+  const pendingPickSaves = useRef(0);
+  const [pickStorageFailed, setPickStorageFailed] = useState(false);
+  const pickReadRequest = useRef(0);
+  const refreshPicks = useCallback(async () => {
+    const request = ++pickReadRequest.current;
+    picksRevision.current = undefined;
+    setPickReadPending(true);
+    try {
+      const { revision, version } = await readSoloModelPicks(
+        scope,
+        stickyPicksKey,
+      );
+      if (!live.current || request !== pickReadRequest.current) return;
+      picksRevision.current = version;
+      const merged = { ...parseSoloModelPicks(revision) };
+      for (const [pubkey, { pick }] of unsavedPicks.current) {
+        if (pick) merged[pubkey] = pick;
+        else delete merged[pubkey];
+      }
+      setPicks(merged, true);
+      setPickReadFailed(false);
+      setPicksLoaded(true);
+      setPickReadPending(false);
+      setPickStorageFailed(
+        [...unsavedPicks.current.values()].some((intent) => !intent.pending),
+      );
+    } catch {
+      if (live.current && request === pickReadRequest.current) {
+        setPickReadFailed(true);
+        setPickReadPending(false);
+      }
+    }
+  }, [scope, stickyPicksKey, setPicks]);
+  useEffect(() => {
+    if (!stickyPicks) return;
+    const stop = subscribeModelPicks(scope, () => void refreshPicks());
+    void refreshPicks();
+    return () => {
+      stop();
+      pickReadRequest.current++;
+    };
+  }, [scope, stickyPicks, refreshPicks]);
+  const changePicks = (
+    next: DraftPicks,
+    resetPubkeys: readonly string[] = [],
+  ) => {
+    const before = picks;
+    const changedKeys = new Set([...Object.keys(before), ...Object.keys(next)]);
+    for (const pubkey of [...changedKeys])
+      if (JSON.stringify(before[pubkey]) === JSON.stringify(next[pubkey]))
+        changedKeys.delete(pubkey);
+    for (const pubkey of resetPubkeys) changedKeys.add(pubkey);
+    if (!stickyPicks) {
+      setPicks(next);
+      return;
+    }
+    // Each queued action owns only its mutations, plus previously failed edits.
+    // Replaying another pending action here could undo a later cross-window edit.
+    const edits = new Map(
+      [...unsavedPicks.current].filter(([, intent]) => !intent.pending),
+    );
+    for (const pubkey of changedKeys) {
+      const intent = { pick: next[pubkey], pending: true };
+      unsavedPicks.current.set(pubkey, intent);
+      edits.set(pubkey, intent);
+    }
+    for (const intent of edits.values()) intent.pending = true;
+    setPicks(next);
+    submission?.unsaved?.(true);
+    pendingPickSaves.current++;
+    void updateSoloModelPicks(
+      scope,
+      stickyPicksKey,
+      new Map([...edits].map(([pubkey, { pick }]) => [pubkey, pick])),
+    )
+      .then(async () => {
+        for (const [pubkey, intent] of edits)
+          if (unsavedPicks.current.get(pubkey) === intent)
+            unsavedPicks.current.delete(pubkey);
+        // Reread after commit: a peer may already have committed another edit.
+        await refreshPicks();
+      })
+      .catch(() => {
+        for (const intent of edits.values()) intent.pending = false;
+      })
+      .finally(() => {
+        pendingPickSaves.current--;
+        if (live.current) {
+          setPickStorageFailed(
+            [...unsavedPicks.current.values()].some(
+              (intent) => !intent.pending,
+            ),
+          );
+          submission?.unsaved?.(
+            unsavedDraft.current || unsavedPicks.current.size > 0,
+          );
+        }
+      });
+  };
   // Solo, alone with agents: the toolbar holds who hears the message when its
   // text mentions no one, and always keeps at least one agent.
   const [routed, setRouted] = useState<readonly MentionRecipient[]>([]);
@@ -706,7 +851,15 @@ function Composer({
   const [replacedKey, setReplacedKey] = useState<string>();
   const replaced = replacedKey === draftKey;
   const mentionCount = useRef(0);
-  const resolvedPicks = useRef<MentionPicks>({});
+  const resolvedPicks = useRef<
+    | {
+        source: typeof picksSnapshot;
+        pubkeys: readonly string[];
+        value: MentionPicks | null;
+        error: string | undefined;
+      }
+    | undefined
+  >(undefined);
   const agents = useContext(AgentsContext);
   /** Who a draft may address here now, the owner's agents from their other
    * communities included. */
@@ -897,7 +1050,10 @@ function Composer({
     if (save && !editing.target) {
       if (submission) {
         const saved = writeView(scope, draftKey, next);
-        submission.unsaved?.(!saved);
+        unsavedDraft.current = !saved;
+        submission.unsaved?.(
+          unsavedDraft.current || unsavedPicks.current.size > 0,
+        );
       } else {
         dirty.current = true;
         if (!conflict && !accepted) persist(next);
@@ -1215,8 +1371,8 @@ function Composer({
     setConflict(false);
     setStorageFailed(false);
   }
-  // Picks belong to the recovered revision alone. They return whenever the
-  // composer holds it unedited, never to a later edit that keeps a conflict.
+  // Message-local picks return with their recovered draft. Solo preferences
+  // remain the chat's current choices, including edits made during an upload.
   const reconcileDraft = useEffectEvent(
     (restored?: MentionDraft, recoveredPicks?: DraftPicks) => {
       if (submission || editing.target || writing.current) return;
@@ -1228,7 +1384,7 @@ function Composer({
         if (current !== undefined) {
           setAccepted(undefined);
           loadSaved(current);
-          if (restored && current === JSON.stringify(restored))
+          if (!stickyPicks && restored && current === JSON.stringify(restored))
             setPicks(recoveredPicks ?? {});
         }
         return;
@@ -1239,7 +1395,8 @@ function Composer({
       if (current === revision.current) {
         // The storage listener usually loads the recovered revision before
         // its notification arrives.
-        if (recovering && !dirty.current) setPicks(recoveredPicks ?? {});
+        if (!stickyPicks && recovering && !dirty.current)
+          setPicks(recoveredPicks ?? {});
         return;
       }
       // An explicit successful recovery may replace only the cleared follow-up,
@@ -1257,7 +1414,7 @@ function Composer({
         setConflict(true);
         return;
       } else loadSaved(current);
-      if (recovering) setPicks(recoveredPicks ?? {});
+      if (!stickyPicks && recovering) setPicks(recoveredPicks ?? {});
     },
   );
   const editingDraft = !!editing.target;
@@ -2325,14 +2482,49 @@ function Composer({
       setConflict(true);
       return;
     }
+    const choicesNow = resolvedPicks.current;
+    const picksNow = choicesNow?.source ?? committedPicks.current;
+    if (pickReadFailed) return;
+    if (pendingPickSaves.current || awaitingPickCommit.current) {
+      setError(
+        "Model and effort choices are still saving. Try sending again shortly.",
+      );
+      return;
+    }
+    // A failed save acknowledgement revokes Send before its error render commits.
+    if (stickyPicks && picksRevision.current === undefined) return;
+    if (
+      stickyPicks &&
+      (choicesNow?.value === null ||
+        sessionTargets(recipientsNow.map((item) => item.pubkey)).some(
+          (pubkey) => {
+            const saved = picksNow.picks[pubkey];
+            return (
+              (saved?.model || saved?.effort) &&
+              !choicesNow?.pubkeys.includes(pubkey)
+            );
+          },
+        ))
+    ) {
+      setError(
+        choicesNow?.error ??
+          "Saved model and effort choices are still loading. Try sending again shortly.",
+      );
+      return;
+    }
     const savedRevision = revision.current;
     const attempt = new AbortController();
     sendAttempt.current = attempt;
     const captured = valueRef.current;
     const capturedRecipients = routing ? recipientsNow : captured.recipients;
     const capturedAttachments = attachments.store.snapshot();
-    const capturedPicks = picks;
-    const capturedRunPicks = { ...picks, ...resolvedPicks.current };
+    // Mention resolution can update recipients before their picker commits.
+    // Capture only a snapshot validated for the saved choices being sent.
+    const capturedPicks = picksNow.picks;
+    const capturedPicksRevision = picksNow.revision;
+    const capturedRunPicks = stickyPicks
+      ? { ...(choicesNow?.value ?? {}) }
+      : { ...capturedPicks, ...(choicesNow?.value ?? {}) };
     // A send is an agent follow-up unless it addresses a confirmed person
     // (a loaded, non-agent profile). Those, and untagged conversation in a
     // shared chat, go out now; recipients still being classified keep the
@@ -2382,10 +2574,14 @@ function Composer({
           "Only your available agents can be mentioned in Solo chats. Remove the unavailable recipient and retry.",
         );
       if (submission) {
+        // SoloDraft filters the captured choices against its final recipient set.
         submission.submit(
           captured,
           attachments.store,
           routing ? capturedRecipients : undefined,
+          ownSoloConversation ? capturedRunPicks : undefined,
+          ownSoloConversation ? capturedPicks : undefined,
+          ownSoloConversation ? capturedPicksRevision : undefined,
         );
         return;
       }
@@ -2728,7 +2924,7 @@ function Composer({
         setReplacedKey(undefined);
         keepPick(null);
       }
-      setPicks({});
+      if (!stickyPicks) setPicks({});
       // An unchanged prefill may not render. Do not leave a caret command for
       // the next keystroke to consume after inserting its first character.
       caret.current = changed ? followUp.text.length : undefined;
@@ -3270,18 +3466,29 @@ function Composer({
             )}
             {active &&
               !editing.target &&
-              !submission &&
+              (!submission || ownSoloConversation) &&
               !!addressedKeys.length && (
                 <ComposerModels
                   profiles={session.profiles}
                   media={session.media}
                   pubkeys={addressedKeys}
                   value={picks}
-                  disabled={editingDisabled}
-                  onChange={setPicks}
-                  onResolved={(next) => {
-                    resolvedPicks.current = next;
+                  disabled={editingDisabled || pickReadFailed || !picksLoaded}
+                  resettable={stickyPicks}
+                  explicitOnly={!!submission && stickyPicks}
+                  onChange={changePicks}
+                  onResolved={(next, error) => {
+                    resolvedPicks.current =
+                      next === undefined
+                        ? undefined
+                        : {
+                            source: picksSnapshot,
+                            pubkeys: addressedKeys,
+                            value: next,
+                            error,
+                          };
                   }}
+                  onRetryInventory={() => void session.agentChoices.refresh()}
                   startsThread={startsThread}
                   place={sessionPlace}
                 />
@@ -3313,6 +3520,9 @@ function Composer({
               }
               disabled={
                 disabled ||
+                (!editing.target &&
+                  stickyPicks &&
+                  (pickReadPending || pickReadFailed)) ||
                 untagged ||
                 (!editing.target && compacting) ||
                 (!editing.target && (!!accepted || conflict || sendPending)) ||
@@ -3351,6 +3561,38 @@ function Composer({
         {(error || editing.error) && (
           <p role="alert">{error ?? editing.error}</p>
         )}
+        {stickyPicks && (
+          <LoadingRegion
+            pending={pickReadPending}
+            label="Loading saved model and effort…"
+            statusVisibility="screen-reader"
+            feedback={
+              pickReadFailed ? (
+                <div>
+                  <p role="alert">
+                    Could not read saved model and effort for this chat on this
+                    device. Retry before sending.
+                  </p>
+                  <Button
+                    type="button"
+                    disabled={pickReadPending}
+                    onClick={() => void refreshPicks()}
+                  >
+                    Retry saved choices
+                  </Button>
+                </div>
+              ) : undefined
+            }
+          >
+            {null}
+          </LoadingRegion>
+        )}
+        {pickStorageFailed && (
+          <p role="alert">
+            Could not save model and effort for this chat on this device. The
+            current choices remain until this composer closes.
+          </p>
+        )}
         {!editing.target &&
           !submission &&
           (accepted || conflict || storageFailed) && (
diff --git a/src/features/messages/composer-models/EffortSlider.tsx b/src/features/messages/composer-models/EffortSlider.tsx
index c1070d7f06..91c70e5286 100644
--- a/src/features/messages/composer-models/EffortSlider.tsx
+++ b/src/features/messages/composer-models/EffortSlider.tsx
@@ -16,6 +16,7 @@ import styles from "../ComposerModels.module.css";
 export function EffortSlider({
   avatarSrc,
   name,
+  chatScoped,
   model,
   efforts,
   resting,
@@ -25,6 +26,7 @@ export function EffortSlider({
   thumb,
 }: {
   name: string;
+  chatScoped?: boolean;
   avatarSrc: string | undefined;
   model(level?: string): ReactNode;
   efforts: readonly Effort[];
@@ -60,10 +62,10 @@ export function EffortSlider({
   const known = set || own >= 0;
   const level = known ? (efforts[at]?.label ?? "") : "Default";
   // A tap on the thumb's resting stop changes no value, so commits pick too.
-  // The run's own effort is no pick.
+  // Next-run choices clear at the default; chat choices remain explicit.
   const choose = (next: number) => {
     const effort = efforts[next]?.id;
-    pick(effort === resting ? undefined : effort);
+    pick(!chatScoped && effort === resting ? undefined : effort);
   };
   return (
     <Slider.Root
@@ -125,7 +127,11 @@ export function EffortSlider({
                 "calc(var(--thumb-width) / 2 + var(--composer-effort-position) * (100% - var(--thumb-width)))",
             }}
             inputRef={thumb}
-            aria-label={`Effort for ${name}'s next run`}
+            aria-label={
+              chatScoped
+                ? `Effort for ${name} in this chat`
+                : `Effort for ${name}'s next run`
+            }
             getAriaValueText={() => level}
           >
             <span
diff --git a/src/features/messages/solo-model-picks-lock.ts b/src/features/messages/solo-model-picks-lock.ts
new file mode 100644
index 0000000000..1eb1d3dff1
--- /dev/null
+++ b/src/features/messages/solo-model-picks-lock.ts
@@ -0,0 +1,5 @@
+/** One scope lock also covers New chat transfers and purge, never delivery. */
+export async function lockSoloModelPicks<T>(scope: string, run: () => T) {
+  if (!navigator.locks) throw new Error("Window ownership is unavailable.");
+  return navigator.locks.request(`buzz-solo-model-picks:${scope}`, run);
+}
diff --git a/src/features/messages/solo-model-picks-storage-testing.ts b/src/features/messages/solo-model-picks-storage-testing.ts
new file mode 100644
index 0000000000..4004e37b76
--- /dev/null
+++ b/src/features/messages/solo-model-picks-storage-testing.ts
@@ -0,0 +1,79 @@
+// Mounted tests exercise composer lifecycle against a fallible storage boundary.
+// The two-page browser regression owns the real IDB transaction/notification contract.
+import {
+  subscribeView,
+  viewRevision,
+  writeView,
+} from "../../shared/view-state";
+import type { ModelPicksTransaction } from "./solo-model-picks-storage";
+
+const versions = new Map<
+  string,
+  { revision: string | null; version: string }
+>();
+
+export async function transactModelPicks<T>(
+  scope: string,
+  _keys: readonly string[],
+  change: (transaction: ModelPicksTransaction) => T,
+) {
+  const version = (key: string) => {
+    const id = JSON.stringify([scope, key]);
+    const revision = viewRevision(scope, key);
+    if (revision === undefined)
+      throw new Error("Saved choices are unreadable.");
+    let saved = versions.get(id);
+    if (!saved || saved.revision !== revision) {
+      saved = { revision, version: crypto.randomUUID() };
+      versions.set(id, saved);
+    }
+    return saved.version;
+  };
+  return change({
+    revision(key) {
+      const revision = viewRevision(scope, key);
+      if (revision === undefined)
+        throw new Error("Saved choices are unreadable.");
+      return revision;
+    },
+    version,
+    write(key, value) {
+      if (!writeView(scope, key, value))
+        throw new Error("Choices were not saved.");
+      const receipt = crypto.randomUUID();
+      versions.set(JSON.stringify([scope, key]), {
+        revision: viewRevision(scope, key) ?? null,
+        version: receipt,
+      });
+      return receipt;
+    },
+  });
+}
+
+export function subscribeModelPicks(scope: string, listener: () => void) {
+  const snapshot = () => {
+    try {
+      return JSON.stringify(
+        Object.keys(localStorage)
+          .filter((key) => {
+            if (!key.startsWith("buzz-view.v1:")) return false;
+            const pair = JSON.parse(key.slice("buzz-view.v1:".length));
+            return pair[0] === scope && pair[1].startsWith("solo:model-picks:");
+          })
+          .sort()
+          .map((key) => [key, localStorage.getItem(key)]),
+      );
+    } catch {
+      return undefined;
+    }
+  };
+  let before = snapshot();
+  return subscribeView(scope, () => {
+    const after = snapshot();
+    if (after === before) return;
+    before = after;
+    listener();
+  });
+}
+export const publishModelPicks = (_scope: string) => {};
+export async function purgeSoloModelPicks(_scope: string) {}
diff --git a/src/features/messages/solo-model-picks-storage.ts b/src/features/messages/solo-model-picks-storage.ts
new file mode 100644
index 0000000000..9436287dc9
--- /dev/null
+++ b/src/features/messages/solo-model-picks-storage.ts
@@ -0,0 +1,167 @@
+import { lockSoloModelPicks } from "./solo-model-picks-lock";
+
+const databaseName = "buzz-solo-model-picks-v1";
+const listeners = new Map<string, Set<() => void>>();
+
+function openDatabase() {
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    const request = indexedDB.open(databaseName, 1);
+    request.onupgradeneeded = () => {
+      request.result
+        .createObjectStore("picks", { keyPath: ["scope", "key"] })
+        .createIndex("scope", "scope");
+    };
+    let blocked = false;
+    request.onsuccess = () => {
+      if (blocked) {
+        request.result.close();
+        return;
+      }
+      request.result.onversionchange = () => request.result.close();
+      resolve(request.result);
+    };
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => {
+      blocked = true;
+      reject(new Error("Close other Buzz windows to open saved choices."));
+    };
+  });
+}
+
+export type ModelPicksTransaction = {
+  revision(key: string): string | null;
+  version(key: string): string;
+  write(key: string, value: unknown): string;
+};
+
+/** IDB, not a page's localStorage cache, owns read/merge/compare/write. */
+export async function transactModelPicks<T>(
+  scope: string,
+  keys: readonly string[],
+  change: (transaction: ModelPicksTransaction) => T,
+) {
+  const db = await openDatabase();
+  try {
+    return await new Promise<T>((resolve, reject) => {
+      const tx = db.transaction("picks", "readwrite", {
+        durability: "strict",
+      });
+      const store = tx.objectStore("picks");
+      const revisions = new Map<string, string | null>();
+      const versions = new Map<string, string>();
+      let result: T;
+      let failure: unknown;
+      const unique = [...new Set(keys)];
+      if (!unique.length) {
+        tx.abort();
+        reject(new Error("Missing saved-choice coordinates."));
+        return;
+      }
+      for (const key of unique) {
+        const request = store.get([scope, key]);
+        request.onsuccess = () => {
+          try {
+            const revision: string | null | undefined =
+              request.result === undefined ? null : request.result.revision;
+            if (revision === undefined)
+              throw new Error("Saved choices are unreadable.");
+            const version: string =
+              request.result?.version ?? crypto.randomUUID();
+            revisions.set(key, revision);
+            versions.set(key, version);
+            if (request.result === undefined)
+              store.put({ scope, key, revision, version });
+            if (revisions.size !== unique.length) return;
+            result = change({
+              revision(key) {
+                const revision = revisions.get(key);
+                if (revision === undefined)
+                  throw new Error("Unread saved-choice coordinate.");
+                return revision;
+              },
+              version(key) {
+                const version = versions.get(key);
+                if (version === undefined)
+                  throw new Error("Unread saved-choice coordinate.");
+                return version;
+              },
+              write(key, value) {
+                if (!revisions.has(key))
+                  throw new Error("Unread saved-choice coordinate.");
+                const revision = value === null ? null : JSON.stringify(value);
+                const version = crypto.randomUUID();
+                revisions.set(key, revision);
+                versions.set(key, version);
+                store.put({ scope, key, revision, version });
+                return version;
+              },
+            });
+          } catch (error) {
+            failure = error;
+            tx.abort();
+          }
+        };
+      }
+      tx.oncomplete = () => resolve(result);
+      tx.onabort = () =>
+        reject(
+          failure ?? tx.error ?? new Error("Saved-choice transaction aborted."),
+        );
+      tx.onerror = () => reject(tx.error);
+    });
+  } finally {
+    db.close();
+  }
+}
+
+export function subscribeModelPicks(scope: string, listener: () => void) {
+  let subscribers = listeners.get(scope);
+  if (!subscribers) {
+    subscribers = new Set();
+    listeners.set(scope, subscribers);
+  }
+  subscribers.add(listener);
+  const channel = new BroadcastChannel(`${databaseName}:${scope}`);
+  channel.onmessage = listener;
+  return () => {
+    channel.close();
+    subscribers.delete(listener);
+    if (!subscribers.size) listeners.delete(scope);
+  };
+}
+
+/** Notifications carry no snapshot; readers always reread committed IDB state. */
+export function publishModelPicks(scope: string) {
+  for (const listener of listeners.get(scope) ?? []) listener();
+  const channel = new BroadcastChannel(`${databaseName}:${scope}`);
+  channel.postMessage(null);
+  channel.close();
+}
+
+export async function purgeSoloModelPicks(scope: string) {
+  if (typeof indexedDB === "undefined") return;
+  return lockSoloModelPicks(scope, async () => {
+    const db = await openDatabase();
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const tx = db.transaction("picks", "readwrite", {
+          durability: "strict",
+        });
+        const store = tx.objectStore("picks");
+        const request = store
+          .index("scope")
+          .getAllKeys(IDBKeyRange.only(scope));
+        request.onsuccess = () => {
+          for (const key of request.result) store.delete(key);
+        };
+        tx.oncomplete = () => resolve();
+        tx.onabort = () =>
+          reject(tx.error ?? new Error("Saved-choice purge aborted."));
+        tx.onerror = () => reject(tx.error);
+      });
+      publishModelPicks(scope);
+    } finally {
+      db.close();
+    }
+  });
+}
diff --git a/src/features/messages/solo-model-picks.ts b/src/features/messages/solo-model-picks.ts
new file mode 100644
index 0000000000..d0769a2fa4
--- /dev/null
+++ b/src/features/messages/solo-model-picks.ts
@@ -0,0 +1,78 @@
+import type { DraftPicks } from "./ComposerModels";
+import { lockSoloModelPicks } from "./solo-model-picks-lock";
+export { lockSoloModelPicks } from "./solo-model-picks-lock";
+import {
+  publishModelPicks,
+  transactModelPicks,
+} from "./solo-model-picks-storage";
+
+export const soloModelPicksKey = (channelId: string) =>
+  `solo:model-picks:${channelId}`;
+
+export function parseSoloModelPicks(
+  revision: string | null | undefined,
+): DraftPicks {
+  let saved: unknown;
+  try {
+    saved = JSON.parse(revision ?? "null");
+  } catch {
+    return {};
+  }
+  if (!saved || typeof saved !== "object" || Array.isArray(saved)) return {};
+  return Object.fromEntries(
+    Object.entries(saved).flatMap(([pubkey, pick]) => {
+      if (
+        !/^[0-9a-f]{64}$/.test(pubkey) ||
+        !pick ||
+        typeof pick !== "object" ||
+        Array.isArray(pick)
+      )
+        return [];
+      const record = pick as Record<string, unknown>;
+      const model = typeof record.model === "string" ? record.model : undefined;
+      const effort =
+        typeof record.effort === "string" ? record.effort : undefined;
+      const type = typeof record.type === "string" ? record.type : undefined;
+      return model || effort
+        ? [
+            [
+              pubkey,
+              {
+                ...(model ? { model } : {}),
+                ...(effort ? { effort } : {}),
+                ...(type ? { type } : {}),
+              },
+            ],
+          ]
+        : [];
+    }),
+  );
+}
+
+export function readSoloModelPicks(scope: string, key: string) {
+  return transactModelPicks(scope, [key], (tx) => ({
+    revision: tx.revision(key),
+    version: tx.version(key),
+  }));
+}
+
+export function updateSoloModelPicks(
+  scope: string,
+  key: string,
+  edits: ReadonlyMap<string, DraftPicks[string] | undefined>,
+) {
+  return lockSoloModelPicks(scope, async () => {
+    const saved = await transactModelPicks(scope, [key], (tx) => {
+      const revision = tx.revision(key);
+      const picks = { ...parseSoloModelPicks(revision) };
+      for (const [pubkey, pick] of edits) {
+        if (pick) picks[pubkey] = pick;
+        else delete picks[pubkey];
+      }
+      const version = tx.write(key, picks);
+      return { picks, version };
+    });
+    publishModelPicks(scope);
+    return saved;
+  });
+}
diff --git a/src/features/relay/partition-purge.ts b/src/features/relay/partition-purge.ts
index e1b561314a..d773ff5141 100644
--- a/src/features/relay/partition-purge.ts
+++ b/src/features/relay/partition-purge.ts
@@ -3,6 +3,7 @@ import { purgeOutboxStorage } from "./outbox-storage";
 import { relayPartition } from "./partition";
 import { createHeadPersistence } from "./persistence";
 import { purgeReadStateStorage } from "./read-state-storage";
+import { purgeSoloModelPicks } from "../messages/solo-model-picks-storage";
 
 /** Clears the relay's durable stores for one partition, each through the
  * caller's `attempt` so an unavailable store neither keeps the others nor goes
@@ -27,4 +28,7 @@ export async function purgeRelayPartition(
   await attempt("read state", () => purgeReadStateStorage(partition));
   await attempt("outbox", () => purgeOutboxStorage(partition));
   await attempt("artifacts", () => purgeArtifactStorage(viewer, origin));
+  await attempt("model and effort choices", () =>
+    purgeSoloModelPicks(partition),
+  );
 }
diff --git a/src/features/solo/SoloDraft.test.tsx b/src/features/solo/SoloDraft.test.tsx
index 3161f0cad3..b268357fe3 100644
--- a/src/features/solo/SoloDraft.test.tsx
+++ b/src/features/solo/SoloDraft.test.tsx
@@ -15,9 +15,11 @@ import {
 } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import type { RelaySession } from "../relay/session";
+import * as modelStorage from "../messages/solo-model-picks-storage";
 import { readView, writeView } from "../../shared/view-state";
 import { linkedDraftKey, type LinkedChat } from "./linked-chat";
 import { SoloDraft, resetNewChatProject } from "./SoloDraft";
+import { ToastProvider } from "../../shared/design-system/ui/Toast";
 import { ChatNotStarted, createChannelWrites } from "../relay/channel-writes";
 import { createOutbox } from "../relay/outbox";
 import { keypair, signed } from "../relay/testing";
@@ -29,19 +31,31 @@ import type {
 } from "../conversation/contracts";
 import { createAgentChoices } from "../agents/choices";
 import { createAgentLibrary } from "../agents/library";
+import { AgentsContext } from "../agents/react";
+import type { Agents } from "../agents/service";
 import { MentionCompletion } from "../../bundled/mentions/MentionCompletion";
 import { mentionQuery } from "../../bundled/mentions/mention-query";
 import type { ComposerCompletion } from "../conversation/contracts";
 import type { Contribution } from "../../plugins/contributions";
 
+vi.mock(
+  "../messages/solo-model-picks-storage",
+  () => import("../messages/solo-model-picks-storage-testing"),
+);
+
 composerDOMFixture();
 afterEach(cleanup);
 afterEach(() => {
   vi.unstubAllGlobals();
+  Reflect.deleteProperty(navigator, "locks");
   delete (HTMLElement.prototype as Partial<HTMLElement>).scrollIntoView;
 });
 beforeEach(() => {
   localStorage.clear();
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: { request: async (_name: string, run: () => unknown) => run() },
+  });
   // jsdom lacks what the completion popup uses to position and reveal rows.
   vi.stubGlobal(
     "ResizeObserver",
@@ -497,13 +511,18 @@ it("a prompt that can't be saved back leaves an open New chat as it is", async (
   const refuse = refusedStart(test);
   writeView("test", "solo:new-draft", taggedDraft("Audit the flow"));
   writeView("test", "solo:settings", { name: "Audit the flow" });
+  const picks = { ["a".repeat(64)]: { model: "deep", type: "test/agent" } };
+  writeView("test", "solo:model-picks:solo:new-draft", picks);
+  const agents = soloModelAgents();
   const view = () => (
-    <SoloDraft
-      session={test.session}
-      scope="test"
-      onStarted={onStarted}
-      onFailed={onFailed}
-    />
+    <AgentsContext.Provider value={agents}>
+      <SoloDraft
+        session={test.session}
+        scope="test"
+        onStarted={onStarted}
+        onFailed={onFailed}
+      />
+    </AgentsContext.Provider>
   );
   const first = render(view());
   await user.click(screen.getByRole("button", { name: "Send message" }));
@@ -516,16 +535,37 @@ it("a prompt that can't be saved back leaves an open New chat as it is", async (
     await waitFor(() =>
       expect(onFailed).toHaveBeenCalledWith(
         expect.any(String),
-        `Couldn't start "Audit the flow": Channel creation rejected. Your message could not be saved on this device.`,
+        expect.stringContaining("Retry to restore your message"),
+        expect.any(Function),
       ),
     );
+    expect(onFailed.mock.calls[0]?.[1]).toContain(
+      "Your message could not be saved on this device.",
+    );
+    expect(onFailed.mock.calls[0]?.[1]).not.toContain("Window ownership");
     // Nothing else is given back either: the settings would be those of a
     // prompt New chat does not hold.
     expect(screen.getByRole("textbox")).not.toHaveTextContent("Audit");
     expect(readView("test", "solo:settings", null)).toBeNull();
+    expect(
+      readView("test", "solo:model-picks:solo:new-draft", null) ?? {},
+    ).toEqual({});
   } finally {
     storage.mockRestore();
   }
+  await act(async () => onFailed.mock.calls[0]?.[2]());
+  expect(screen.getByRole("textbox")).toHaveTextContent("Audit the flow");
+  expect(readView("test", "solo:settings", null)).toMatchObject({
+    name: "Audit the flow",
+  });
+  expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual(
+    picks,
+  );
+  expect(onFailed.mock.calls[1]?.[1]).toContain(
+    "Your message is back in New chat",
+  );
+  expect(onFailed.mock.calls[1]?.[2]).toBeUndefined();
+  expect(test.messages.send).toHaveBeenCalledOnce();
 });
 it("a newer draft the composer couldn't save still keeps a refused prompt out of New chat", async () => {
   const test = setup(),
@@ -535,13 +575,16 @@ it("a newer draft the composer couldn't save still keeps a refused prompt out of
   const refuse = refusedStart(test);
   const refused = taggedDraft("Audit");
   writeView("test", "solo:new-draft", refused);
+  const modelAgents = soloModelAgents();
   const view = () => (
-    <SoloDraft
-      session={test.session}
-      scope="test"
-      onStarted={onStarted}
-      onFailed={onFailed}
-    />
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft
+        session={test.session}
+        scope="test"
+        onStarted={onStarted}
+        onFailed={onFailed}
+      />
+    </AgentsContext.Provider>
   );
   const first = render(view());
   await user.click(screen.getByRole("button", { name: "Send message" }));
@@ -561,6 +604,22 @@ it("a newer draft the composer couldn't save still keeps a refused prompt out of
     );
     fireEvent.input(input);
     expect(readView("test", "solo:new-draft", null)).toBe("");
+    // Saving a model choice must not clear the unsaved text guard either.
+    await user.click(
+      screen.getByRole("button", { name: "Model and effort for this chat" }),
+    );
+    await user.click(
+      screen.getByRole("button", {
+        name: "Model for Member agent in this chat",
+      }),
+    );
+    await user.click(
+      await screen.findByRole("menuitemradio", { name: "Deep" }),
+    );
+    // Remove the durable choice so only the unsaved text protects recovery.
+    act(() => {
+      writeView("test", "solo:model-picks:solo:new-draft", null);
+    });
     await refuse();
     await waitFor(() =>
       expect(onFailed).toHaveBeenCalledWith(
@@ -1810,7 +1869,7 @@ it("starts a new chat with a session card and no caption", async () => {
   writeView("test", "solo:new-draft", taggedDraft(link));
   render(<SoloDraft session={h.session} scope="test" onStarted={started} />);
   const send = screen.getByRole("button", { name: "Send message" });
-  expect(send).toBeEnabled();
+  await waitFor(() => expect(send).toBeEnabled());
   await user.click(send);
   await waitFor(() => expect(started).toHaveBeenCalled());
   expect(h.channelWrites.create).toHaveBeenCalledOnce();
@@ -2019,6 +2078,962 @@ it("a first message that can't go out waits in the new chat's composer with its
   ).toEqual([notes]);
 });
 
+function soloModelAgents() {
+  const pubkey = "a".repeat(64);
+  const agent = {
+    pubkey,
+    key: pubkey,
+    name: "Member agent",
+    type: "test/agent",
+  };
+  const snapshot = { status: "ready", agents: [agent] };
+  const types = [
+    {
+      key: "test/agent",
+      models: () => ({
+        current: "fast",
+        sendDefaults: true,
+        models: [
+          { id: "fast", label: "Fast", efforts: [] },
+          {
+            id: "deep",
+            label: "Deep",
+            efforts: [
+              { id: "low", label: "Low" },
+              { id: "high", label: "High" },
+            ],
+          },
+        ],
+      }),
+    },
+  ];
+  return {
+    find: (key: string) => (key === pubkey ? agent : undefined),
+    joinable: () => [],
+    sessionState: () => "unavailable" as const,
+    subscribe: () => () => {},
+    snapshot: () => snapshot,
+    types: () => types,
+  } as unknown as Agents;
+}
+
+it("sends the selected model and effort with a Solo chat's first message", async () => {
+  const test = setup(),
+    onStarted = vi.fn(),
+    user = userEvent.setup();
+  const pubkey = "a".repeat(64);
+  const modelAgents = soloModelAgents();
+  writeView("test", "solo:new-draft", taggedDraft("Start with care"));
+  const firstMount = render(
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+    </AgentsContext.Provider>,
+  );
+
+  await user.click(
+    await screen.findByRole("button", { name: /Model.*effort/ }),
+  );
+  await user.click(
+    await screen.findByRole("button", {
+      name: "Model for Member agent in this chat",
+    }),
+  );
+  await user.click(await screen.findByRole("menuitemradio", { name: "Deep" }));
+  const effort = await screen.findByLabelText(
+    "Effort for Member agent in this chat",
+  );
+  effort.focus();
+  await user.keyboard("{ArrowRight}");
+  expect(effort).toHaveAttribute("aria-valuetext", "High");
+
+  expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual({
+    [pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  firstMount.unmount();
+  render(
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+    </AgentsContext.Provider>,
+  );
+  await user.click(
+    screen.getByRole("button", { name: "Model and effort for this chat" }),
+  );
+  const restoredModel = await screen.findByRole("button", {
+    name: "Model for Member agent in this chat",
+  });
+  expect(restoredModel).toHaveTextContent("Deep");
+  expect(
+    await screen.findByLabelText("Effort for Member agent in this chat"),
+  ).toHaveAttribute("aria-valuetext", "High");
+
+  await user.keyboard("{Escape}");
+  await user.click(screen.getByRole("button", { name: "Send message" }));
+  await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+  const [id] = onStarted.mock.calls[0] ?? [];
+  expect(test.messages.send).toHaveBeenLastCalledWith(
+    id,
+    "@Member agent Start with care",
+    [pubkey],
+    [],
+    undefined,
+    [],
+    { [pubkey]: { model: "deep", effort: "high" } },
+  );
+  expect(readView("test", `solo:model-picks:${id}`, null)).toEqual({
+    [pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  await waitFor(() =>
+    expect(
+      readView("test", "solo:model-picks:solo:new-draft", null),
+    ).toBeNull(),
+  );
+});
+
+it("retains a saved first-chat model when its catalog no longer needs controls", async () => {
+  const test = setup(),
+    onStarted = vi.fn(),
+    user = userEvent.setup();
+  const pubkey = "a".repeat(64);
+  const agents = soloModelAgents();
+  let release!: () => void;
+  const ready = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const types = [
+    {
+      key: "test/agent",
+      models: async () => {
+        await ready;
+        return {
+          current: "deep",
+          sendDefaults: true,
+          models: [{ id: "deep", label: "Deep", efforts: [] }],
+        };
+      },
+    },
+  ];
+  const modelAgents = { ...agents, types: () => types } as unknown as Agents;
+  const picks = { [pubkey]: { model: "deep", type: "test/agent" } };
+  writeView("test", "solo:new-draft", taggedDraft("Keep my model"));
+  writeView("test", "solo:model-picks:solo:new-draft", picks);
+  render(
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+    </AgentsContext.Provider>,
+  );
+
+  await user.click(
+    await screen.findByRole("button", {
+      name: "Model and effort for this chat",
+    }),
+  );
+  try {
+    expect(await screen.findByText("Loading model and effort…")).toBeVisible();
+  } finally {
+    await act(async () => release());
+  }
+  expect(
+    screen.getByRole("button", { name: "Reset model and effort" }),
+  ).toBeVisible();
+  expect(
+    screen.queryByRole("button", {
+      name: "Model for Member agent in this chat",
+    }),
+  ).toBeNull();
+  await user.keyboard("{Escape}");
+  await user.click(screen.getByRole("button", { name: "Send message" }));
+  await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+  const [id] = onStarted.mock.calls[0] ?? [];
+  expect(test.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [pubkey]: { model: "deep" },
+  });
+  expect(readView("test", `solo:model-picks:${id}`, null)).toEqual(picks);
+  expect(readView("test", "solo:model-picks:solo:new-draft", null)).toBeNull();
+});
+
+it("restores model and effort after a refused first Solo start", async () => {
+  const test = setup(),
+    onStarted = vi.fn(),
+    onFailed = vi.fn(),
+    user = userEvent.setup();
+  const pubkey = "a".repeat(64);
+  const modelAgents = soloModelAgents();
+  const refuse = refusedStart(test);
+  writeView("test", "solo:new-draft", taggedDraft("Retry with care"));
+  render(
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft
+        session={test.session}
+        scope="test"
+        onStarted={onStarted}
+        onFailed={onFailed}
+      />
+    </AgentsContext.Provider>,
+  );
+
+  await user.click(
+    screen.getByRole("button", { name: "Model and effort for this chat" }),
+  );
+  await user.click(
+    screen.getByRole("button", { name: "Model for Member agent in this chat" }),
+  );
+  await user.click(await screen.findByRole("menuitemradio", { name: "Deep" }));
+  const effort = await screen.findByLabelText(
+    "Effort for Member agent in this chat",
+  );
+  effort.focus();
+  await user.keyboard("{ArrowRight}");
+  await user.keyboard("{Escape}");
+  await user.click(screen.getByRole("button", { name: "Send message" }));
+  await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+  const [id] = onStarted.mock.calls[0] ?? [];
+  expect(test.messages.send.mock.calls[0]?.at(-1)).toEqual({
+    [pubkey]: { model: "deep", effort: "high" },
+  });
+
+  await refuse();
+  await waitFor(() => expect(onFailed).toHaveBeenCalledOnce());
+  expect(readView("test", `solo:model-picks:${id}`, null)).toBeNull();
+  expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual({
+    [pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+  });
+  expect(
+    screen.getByRole("button", { name: "Model and effort for this chat" }),
+  ).toBeVisible();
+
+  test.channelWrites.ready = Promise.resolve();
+  await user.click(screen.getByRole("button", { name: "Send message" }));
+  await waitFor(() => expect(onStarted).toHaveBeenCalledTimes(2));
+  expect(test.messages.send.mock.calls[1]?.at(-1)).toEqual({
+    [pubkey]: { model: "deep", effort: "high" },
+  });
+});
+
+it.each(["select", "reset"])(
+  "consumes the saved New chat baseline after an unsaved %s and storage recovery",
+  async (action) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      user = userEvent.setup();
+    const pubkey = "a".repeat(64);
+    const key = "solo:model-picks:solo:new-draft";
+    const modelAgents = soloModelAgents();
+    writeView("test", "solo:new-draft", taggedDraft("First start"));
+    const baseline = {
+      [pubkey]: {
+        model: action === "select" ? "fast" : "deep",
+        type: "test/agent",
+      },
+    };
+    writeView("test", key, baseline);
+    const view = () => (
+      <AgentsContext.Provider value={modelAgents}>
+        <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+      </AgentsContext.Provider>
+    );
+    const first = render(view());
+    await user.click(
+      await screen.findByRole("button", { name: /Model.*effort/ }),
+    );
+    const storage = failingViewWrites([key]);
+    try {
+      if (action === "select") {
+        await user.click(
+          await screen.findByRole("button", {
+            name: "Model for Member agent in this chat",
+          }),
+        );
+        await user.click(
+          await screen.findByRole("menuitemradio", { name: "Deep" }),
+        );
+      } else {
+        await user.click(
+          screen.getByRole("button", { name: "Reset model and effort" }),
+        );
+      }
+      expect(readView("test", key, null)).toEqual(baseline);
+    } finally {
+      storage.mockRestore();
+    }
+    await user.keyboard("{Escape}");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+    const [id] = onStarted.mock.calls[0] ?? [];
+    expect(test.messages.send.mock.calls[0]?.[6]).toEqual(
+      action === "select" ? { [pubkey]: { model: "deep" } } : undefined,
+    );
+    expect(readView("test", `solo:model-picks:${id}`, null)).toEqual(
+      action === "select"
+        ? { [pubkey]: { model: "deep", type: "test/agent" } }
+        : null,
+    );
+    expect(readView("test", key, null)).toBeNull();
+    first.unmount();
+    writeView("test", "solo:new-draft", taggedDraft("Next start"));
+    render(view());
+    await user.click(
+      await screen.findByRole("button", { name: /Model.*effort/ }),
+    );
+    expect(
+      await screen.findByRole("button", {
+        name: "Model for Member agent in this chat",
+      }),
+    ).toHaveTextContent("Fast");
+  },
+);
+
+it.each(["before Send", "after notification", "during upload"])(
+  "compares shared model choices against the accepted Send snapshot for a write %s while uploading",
+  async (timing) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      user = userEvent.setup();
+    const pubkey = "a".repeat(64);
+    const key = "solo:model-picks:solo:new-draft";
+    const newer = { [pubkey]: { model: "fast", type: "test/agent" } };
+    let release!: () => void;
+    const pending = new Promise<typeof notes>((resolve) => {
+      release = () => resolve(notes);
+    });
+    const uploadForNewChat = vi.fn(() => pending);
+    Object.assign(test.session, { attachments: { uploadForNewChat } });
+    writeView("test", "solo:new-draft", taggedDraft("First start"));
+    writeView("test", key, {
+      [pubkey]: { model: "deep", effort: "high", type: "test/agent" },
+    });
+    render(
+      <AgentsContext.Provider value={soloModelAgents()}>
+        <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+      </AgentsContext.Provider>,
+    );
+    try {
+      await user.upload(
+        screen.getByLabelText("Choose attachments"),
+        new File(["notes"], "notes.txt", { type: "text/plain" }),
+      );
+      await waitFor(() => expect(uploadForNewChat).toHaveBeenCalledOnce());
+      if (timing === "during upload")
+        await user.click(screen.getByRole("button", { name: "Send message" }));
+      const storageKey = `buzz-view.v1:${JSON.stringify(["test", key])}`;
+      localStorage.setItem(storageKey, JSON.stringify(newer));
+      if (timing === "after notification") {
+        const send = screen.getByRole("button", { name: "Send message" });
+        act(() => {
+          // Deliver the external revision, then submit before its render commits.
+          window.dispatchEvent(
+            new StorageEvent("storage", {
+              key: storageKey,
+              storageArea: localStorage,
+            }),
+          );
+          send.click();
+        });
+        // IDB's post-notification read must commit before a second Send.
+        expect(test.channelWrites.start).not.toHaveBeenCalled();
+        await waitFor(() =>
+          expect(
+            screen
+              .getByRole("form")
+              .querySelector('.buzz-loading-region[aria-busy="true"]'),
+          ).toBeNull(),
+        );
+        await user.click(send);
+      }
+      if (timing === "before Send")
+        await user.click(screen.getByRole("button", { name: "Send message" }));
+      expect(
+        screen.getByRole("button", { name: "Send message" }),
+      ).toBeDisabled();
+      expect(test.channelWrites.start).not.toHaveBeenCalled();
+    } finally {
+      await act(async () => {
+        release();
+        await pending;
+      });
+    }
+    await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+    expect(test.messages.send.mock.calls[0]?.at(-1)).toEqual({
+      [pubkey]:
+        timing === "after notification"
+          ? { model: "fast" }
+          : { model: "deep", effort: "high" },
+    });
+    // After notification the accepted Send consumes the reconciled snapshot;
+    // otherwise a write unseen by that Send belongs to the next draft.
+    expect(readView("test", key, null)).toEqual(
+      timing === "after notification" ? null : newer,
+    );
+  },
+);
+
+it("keeps a newer New chat draft while the first start awaits model ownership", async () => {
+  const test = setup(),
+    onStarted = vi.fn(),
+    user = userEvent.setup();
+  writeView("test", "solo:new-draft", taggedDraft("First start"));
+  render(
+    <AgentsContext.Provider value={soloModelAgents()}>
+      <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+    </AgentsContext.Provider>,
+  );
+  let release!: () => void;
+  const pending = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let entered!: () => void;
+  const requested = new Promise<void>((resolve) => {
+    entered = resolve;
+  });
+  Object.defineProperty(navigator, "locks", {
+    configurable: true,
+    value: {
+      request: async (_name: string, run: () => unknown) => {
+        entered();
+        await pending;
+        return run();
+      },
+    },
+  });
+  const newer = taggedDraft("Newer draft");
+  try {
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await requested;
+    expect(test.messages.send).toHaveBeenCalledOnce();
+    expect(onStarted).not.toHaveBeenCalled();
+    // Another context can begin its next draft while local ownership is pending.
+    writeView("test", "solo:new-draft", newer);
+    writeView("test", "solo:settings", { name: "Newer title" });
+  } finally {
+    await act(async () => {
+      release();
+      await pending;
+    });
+  }
+  await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+  expect(readView("test", "solo:new-draft", null)).toEqual(newer);
+  expect(readView("test", "solo:settings", null)).toEqual({
+    name: "Newer title",
+  });
+});
+
+it.each([
+  ...["created", "refused"].flatMap((outcome) =>
+    ["saved", "unsaved"].map((storage) => ({ outcome, storage })),
+  ),
+  { outcome: "refused", storage: "pending" },
+  { outcome: "refused", storage: "reset" },
+])(
+  "keeps a later New chat's $storage choices separate while the first start is $outcome",
+  async ({ outcome, storage }) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      onFailed = vi.fn(),
+      user = userEvent.setup();
+    const pubkey = "a".repeat(64);
+    const modelAgents = soloModelAgents();
+    const picks = { [pubkey]: { model: "deep", type: "test/agent" } };
+    let settle!: () => void;
+    const ready = new Promise<void>((resolve, reject) => {
+      settle = () => {
+        if (outcome === "created") resolve();
+        else reject(new ChatNotStarted("Channel creation rejected"));
+      };
+    });
+    test.channelWrites.ready = ready;
+    writeView("test", "solo:new-draft", taggedDraft("First start"));
+    writeView("test", "solo:model-picks:solo:new-draft", picks);
+    const view = () => (
+      <AgentsContext.Provider value={modelAgents}>
+        <SoloDraft
+          session={test.session}
+          scope="test"
+          onStarted={onStarted}
+          onFailed={onFailed}
+        />
+      </AgentsContext.Provider>
+    );
+    const first = render(view());
+    let writes: ReturnType<typeof failingViewWrites> | undefined;
+    let release: (() => void) | undefined;
+    let tail: Promise<unknown> = Promise.resolve();
+    try {
+      await user.click(screen.getByRole("button", { name: "Send message" }));
+      await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+      first.unmount();
+      render(view());
+      if (storage === "pending") {
+        tail = new Promise<void>((resolve) => {
+          release = resolve;
+        });
+        let entered!: () => void;
+        const requested = new Promise<void>((resolve) => {
+          entered = resolve;
+        });
+        Object.defineProperty(navigator, "locks", {
+          configurable: true,
+          value: {
+            request: (_name: string, run: () => unknown) => {
+              entered();
+              const result = tail.then(run);
+              tail = result.catch(() => {});
+              return result;
+            },
+          },
+        });
+        // Queue refusal recovery before the new pick's save can acquire ownership.
+        await act(async () => {
+          settle();
+          await ready.catch(() => {});
+          await requested;
+        });
+      }
+      if (storage === "unsaved")
+        writes = failingViewWrites(["solo:model-picks:solo:new-draft"]);
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      const model = screen.getByRole("button", {
+        name: "Model for Member agent in this chat",
+      });
+      expect(model).toHaveTextContent("Fast");
+      // Deliberately choose the same model: equality with the first start's
+      // snapshot must not let that start clear this later draft's choice.
+      await user.click(model);
+      await user.click(
+        await screen.findByRole("menuitemradio", { name: "Deep" }),
+      );
+      if (storage === "reset") {
+        await user.click(
+          screen.getByRole("button", { name: "Reset model and effort" }),
+        );
+        await waitFor(() =>
+          expect(
+            readView("test", "solo:model-picks:solo:new-draft", null),
+          ).toEqual({}),
+        );
+      }
+      if (writes) {
+        expect(screen.getByRole("alert")).toHaveTextContent(
+          "Could not save model and effort",
+        );
+        writes.mockRestore();
+        // A successful text save must not clear the unsaved model guard.
+        const input = screen.getByRole("textbox") as HTMLTextAreaElement;
+        input.value = " ";
+        fireEvent.input(input);
+      }
+    } finally {
+      writes?.mockRestore();
+      await act(async () => {
+        release?.();
+        await tail;
+        if (storage !== "pending") settle();
+        await ready.catch(() => {});
+      });
+    }
+    if (outcome === "refused")
+      await waitFor(() => expect(onFailed).toHaveBeenCalledOnce());
+    expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual(
+      storage === "unsaved" ? null : storage === "reset" ? {} : picks,
+    );
+    if (storage === "reset")
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+    expect(
+      screen.getByRole("button", {
+        name: "Model for Member agent in this chat",
+      }),
+    ).toHaveTextContent(storage === "reset" ? "Fast" : "Deep");
+    expect(screen.getByRole("textbox")).not.toHaveTextContent("First start");
+    if (outcome === "refused")
+      expect(onFailed).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining("New chat has a newer draft"),
+      );
+  },
+);
+
+it.each(
+  ["missing", "rejected"].flatMap((ownership) => [
+    ...["transfer", "restore"].flatMap((failureAt) =>
+      [false, true].map((newer) => ({
+        ownership,
+        failureAt,
+        newer,
+        reset: false,
+      })),
+    ),
+    { ownership, failureAt: "transfer", newer: false, reset: true },
+  ]),
+)(
+  "retains a refused start for retry after $ownership ownership at $failureAt, protecting newer work=$newer, reset=$reset",
+  async ({ ownership, failureAt, newer, reset }) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      onFailed = vi.fn(),
+      user = userEvent.setup();
+    const pubkey = "a".repeat(64);
+    const picks = { [pubkey]: { model: "deep", type: "test/agent" } };
+    const modelKey = "solo:model-picks:solo:new-draft";
+    const modelAgents = soloModelAgents();
+    const refuse = refusedStart(test);
+    writeView(
+      "test",
+      "solo:new-draft",
+      taggedDraft("Keep this refused message"),
+    );
+    writeView("test", modelKey, picks);
+    const view = () => (
+      <AgentsContext.Provider value={modelAgents}>
+        <SoloDraft
+          session={test.session}
+          scope="test"
+          onStarted={onStarted}
+          onFailed={onFailed}
+        />
+      </AgentsContext.Provider>
+    );
+    const first = render(view());
+    const locks = navigator.locks;
+    const failOwnership = () =>
+      Object.defineProperty(navigator, "locks", {
+        configurable: true,
+        value:
+          ownership === "missing"
+            ? undefined
+            : {
+                request: async () => {
+                  throw new Error("Lock refused");
+                },
+              },
+      });
+    if (failureAt === "transfer") failOwnership();
+    if (reset) {
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      await user.click(
+        screen.getByRole("button", { name: "Reset model and effort" }),
+      );
+      await waitFor(() =>
+        expect(screen.getByRole("alert")).toHaveTextContent(
+          "Could not save model and effort",
+        ),
+      );
+    }
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+    const id = onStarted.mock.calls[0]?.[0];
+    first.unmount();
+    render(view());
+    failOwnership();
+    const draftPicks = failureAt === "transfer" ? picks : null;
+    const chatPicks = failureAt === "transfer" ? null : picks;
+    try {
+      await refuse();
+      await waitFor(() => expect(onFailed).toHaveBeenCalledOnce());
+      // Ownership failure changes neither shared model map.
+      expect(readView("test", modelKey, null)).toEqual(draftPicks);
+      expect(readView("test", `solo:model-picks:${id}`, null)).toEqual(
+        chatPicks,
+      );
+      expect(onFailed.mock.calls[0]?.[1]).toContain("Window ownership");
+      const retry = onFailed.mock.calls[0]?.[2];
+      expect(retry).toEqual(expect.any(Function));
+      await act(async () => {
+        await retry();
+      });
+      expect(onFailed).toHaveBeenCalledTimes(2);
+      expect(onFailed.mock.calls[1]?.[2]).toBe(retry);
+      expect(readView("test", modelKey, null)).toEqual(draftPicks);
+      expect(readView("test", `solo:model-picks:${id}`, null)).toEqual(
+        chatPicks,
+      );
+    } finally {
+      Object.defineProperty(navigator, "locks", {
+        configurable: true,
+        value: locks,
+      });
+    }
+    if (newer) {
+      await user.type(screen.getByRole("textbox"), "Newer draft");
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      await user.click(
+        screen.getByRole("button", {
+          name: "Model for Member agent in this chat",
+        }),
+      );
+      await user.click(
+        await screen.findByRole("menuitemradio", { name: "Fast" }),
+      );
+    }
+    await act(async () => {
+      const retry = onFailed.mock.calls[1]?.[2];
+      await Promise.all([retry(), retry()]);
+    });
+    await waitFor(() => expect(onFailed).toHaveBeenCalledTimes(3));
+    expect(screen.getByRole("textbox")).toHaveTextContent(
+      newer ? "Newer draft" : "Keep this refused message",
+    );
+    expect(readView("test", modelKey, null)).toEqual(
+      newer
+        ? { [pubkey]: { model: "fast", type: "test/agent" } }
+        : reset
+          ? {}
+          : picks,
+    );
+    expect(readView("test", `solo:model-picks:${id}`, null)).toBeNull();
+    expect(onFailed.mock.calls[2]?.[1]).toContain(
+      newer ? "New chat has a newer draft" : "Your message is back in New chat",
+    );
+    // A stale callback is harmless after a completed restore.
+    writeView("test", `solo:model-picks:${id}`, picks);
+    await act(async () => {
+      await onFailed.mock.calls[1]?.[2]();
+    });
+    expect(readView("test", `solo:model-picks:${id}`, null)).toEqual(picks);
+    expect(onFailed).toHaveBeenCalledTimes(3);
+    expect(test.messages.send).toHaveBeenCalledOnce();
+    if (reset) {
+      expect(test.messages.send.mock.calls[0]?.[6]).toBeUndefined();
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      expect(
+        screen.getByRole("button", {
+          name: "Model for Member agent in this chat",
+        }),
+      ).toHaveTextContent("Fast");
+      await user.keyboard("{Escape}");
+      test.channelWrites.ready = Promise.resolve();
+      await user.click(screen.getByRole("button", { name: "Send message" }));
+      await waitFor(() => expect(onStarted).toHaveBeenCalledTimes(2));
+      expect(test.messages.send.mock.calls[1]?.[6]).toBeUndefined();
+    }
+  },
+);
+
+it.each(["newer text", "failed prompt write"])(
+  "retains recovery through failed compensation after %s during the model commit",
+  async (interruption) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      onFailed = vi.fn(),
+      user = userEvent.setup();
+    const modelKey = "solo:model-picks:solo:new-draft";
+    const picks = { ["a".repeat(64)]: { model: "deep", type: "test/agent" } };
+    let refuse!: () => void;
+    test.channelWrites.ready = new Promise<void>((_resolve, reject) => {
+      refuse = () => reject(new ChatNotStarted("Channel creation rejected"));
+    });
+    void test.channelWrites.ready.catch(() => {});
+    writeView("test", "solo:new-draft", taggedDraft("Original prompt"));
+    writeView("test", modelKey, picks);
+    render(
+      <AgentsContext.Provider value={soloModelAgents()}>
+        <SoloDraft
+          session={test.session}
+          scope="test"
+          onStarted={onStarted}
+          onFailed={onFailed}
+        />
+      </AgentsContext.Provider>,
+    );
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+    let release!: () => void, entered!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const committed = new Promise<void>((resolve) => {
+      entered = resolve;
+    });
+    const transact = modelStorage.transactModelPicks;
+    let failUndo = true;
+    let held = false;
+    const storage = vi
+      .spyOn(modelStorage, "transactModelPicks")
+      .mockImplementation(async (scope, keys, change) => {
+        if (held && keys.length === 1 && failUndo)
+          throw new Error("IDB compensation unavailable");
+        const result = await transact(scope, keys, change);
+        if (!held && keys.length === 2) {
+          held = true;
+          entered();
+          await gate;
+        }
+        return result;
+      });
+    let textFailure: ReturnType<typeof failingViewWrites> | undefined;
+    try {
+      act(() => refuse());
+      await committed;
+      if (interruption === "newer text")
+        fireEvent.input(screen.getByRole("textbox"), {
+          target: { textContent: "Newer prompt" },
+        });
+      else textFailure = failingViewWrites(["solo:new-draft"]);
+      await act(async () => {
+        release();
+      });
+      await waitFor(() => expect(onFailed).toHaveBeenCalledOnce());
+      const retry = onFailed.mock.calls[0]?.[2];
+      expect(retry).toEqual(expect.any(Function));
+      await act(async () => retry());
+      expect(onFailed.mock.calls[1]?.[2]).toBe(retry);
+      failUndo = false;
+      textFailure?.mockRestore();
+      await act(async () => retry());
+      expect(onFailed).toHaveBeenCalledTimes(3);
+      expect(screen.getByRole("textbox")).toHaveTextContent(
+        interruption === "newer text" ? "Newer prompt" : "Original prompt",
+      );
+      expect(readView("test", modelKey, null)).toEqual(
+        interruption === "newer text" ? {} : picks,
+      );
+      expect(test.messages.send).toHaveBeenCalledOnce();
+    } finally {
+      release();
+      textFailure?.mockRestore();
+      storage.mockRestore();
+    }
+  },
+);
+
+it.each(["chat", "draft", "missing", "rejected"])(
+  "reports and recovers failed first-send choice storage for the %s",
+  async (failure) => {
+    const test = setup(),
+      onStarted = vi.fn(),
+      user = userEvent.setup();
+    const pubkey = "a".repeat(64);
+    const picks = { [pubkey]: { model: "deep", type: "test/agent" } };
+    writeView("test", "solo:new-draft", taggedDraft("Keep the first send"));
+    writeView("test", "solo:model-picks:solo:new-draft", picks);
+    const create = test.channelWrites.start.getMockImplementation();
+    if (!create) throw new Error("Expected the start fixture implementation");
+    let storage: ReturnType<typeof failingViewWrites> | undefined;
+    test.channelWrites.start.mockImplementationOnce((...args) => {
+      if (failure === "missing" || failure === "rejected") {
+        Object.defineProperty(navigator, "locks", {
+          configurable: true,
+          value:
+            failure === "missing"
+              ? undefined
+              : {
+                  request: async () => {
+                    throw new Error("Lock refused");
+                  },
+                },
+        });
+      } else
+        storage = failingViewWrites([
+          failure === "chat"
+            ? `solo:model-picks:${args[0]}`
+            : "solo:model-picks:solo:new-draft",
+        ]);
+      return create(...args);
+    });
+    render(
+      <ToastProvider>
+        <AgentsContext.Provider value={soloModelAgents()}>
+          <SoloDraft
+            session={test.session}
+            scope="test"
+            onStarted={onStarted}
+          />
+        </AgentsContext.Provider>
+      </ToastProvider>,
+    );
+    try {
+      await user.click(screen.getByRole("button", { name: "Send message" }));
+      await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+      expect(test.messages.send.mock.calls[0]?.at(-1)).toEqual({
+        [pubkey]: { model: "deep" },
+      });
+      expect(
+        await screen.findByRole("dialog", {
+          name:
+            failure === "chat"
+              ? "Could not save model and effort for this chat. Choose them again before your next message."
+              : "Could not clear model and effort from New chat. Reset them before starting another chat.",
+        }),
+      ).toBeVisible();
+    } finally {
+      storage?.mockRestore();
+    }
+    if (failure === "draft") {
+      expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual(
+        picks,
+      );
+      await user.click(
+        screen.getByRole("button", { name: "Model and effort for this chat" }),
+      );
+      await user.click(
+        screen.getByRole("button", { name: "Reset model and effort" }),
+      );
+      expect(readView("test", "solo:model-picks:solo:new-draft", null)).toEqual(
+        {},
+      );
+      expect(test.messages.send).toHaveBeenCalledOnce();
+    }
+  },
+);
+
+it("keeps provider defaults unchanged on an unconfigured Solo first message", async () => {
+  const test = setup(),
+    onStarted = vi.fn(),
+    user = userEvent.setup();
+  const pubkey = "a".repeat(64);
+  const agent = {
+    pubkey,
+    key: pubkey,
+    name: "Member agent",
+    type: "test/agent",
+  };
+  const snapshot = { status: "ready", agents: [agent] };
+  const types = [
+    {
+      key: "test/agent",
+      models: () => ({
+        current: "fast",
+        sendDefaults: true,
+        models: [
+          { id: "fast", label: "Fast", efforts: [] },
+          { id: "deep", label: "Deep", efforts: [] },
+        ],
+      }),
+    },
+  ];
+  const modelAgents = {
+    find: (key: string) => (key === pubkey ? agent : undefined),
+    joinable: () => [],
+    sessionState: () => "unavailable" as const,
+    subscribe: () => () => {},
+    snapshot: () => snapshot,
+    types: () => types,
+  } as unknown as Agents;
+  writeView("test", "solo:new-draft", taggedDraft("Use configured defaults"));
+  render(
+    <AgentsContext.Provider value={modelAgents}>
+      <SoloDraft session={test.session} scope="test" onStarted={onStarted} />
+    </AgentsContext.Provider>,
+  );
+
+  await user.click(screen.getByRole("button", { name: "Send message" }));
+  await waitFor(() => expect(onStarted).toHaveBeenCalledOnce());
+  const [id] = onStarted.mock.calls[0] ?? [];
+  expect(test.messages.send).toHaveBeenLastCalledWith(
+    id,
+    "@Member agent Use configured defaults",
+    [pubkey],
+  );
+  expect(readView("test", `solo:model-picks:${id}`, null)).toBeNull();
+});
+
 it("resumes a new chat's interrupted upload after navigating away and back", async () => {
   const test = setup(),
     onStarted = vi.fn(),
diff --git a/src/features/solo/SoloDraft.tsx b/src/features/solo/SoloDraft.tsx
index 45e081a1ae..44e09e1efc 100644
--- a/src/features/solo/SoloDraft.tsx
+++ b/src/features/solo/SoloDraft.tsx
@@ -8,6 +8,7 @@ import { ChatNotStarted } from "../relay/channel-writes";
 import { DraftSettings } from "./DraftSettings";
 import { SoloDraftView } from "./SoloPresentation";
 import { IconButton } from "../../shared/design-system/ui/IconButton";
+import { useToastNotification } from "../../shared/design-system/ui/Toast";
 import { GearIcon } from "../../shared/design-system/icons";
 import {
   defaultsRevision,
@@ -24,6 +25,17 @@ import {
   viewRevision,
 } from "../../shared/view-state";
 import { MessageComposer } from "../messages/MessageComposer";
+import {
+  parseSoloModelPicks,
+  soloModelPicksKey,
+  lockSoloModelPicks,
+} from "../messages/solo-model-picks";
+import {
+  transactModelPicks,
+  publishModelPicks,
+} from "../messages/solo-model-picks-storage";
+import type { DraftPicks } from "../messages/ComposerModels";
+import type { MentionPicks } from "../relay/messages";
 import { useDefaultAgent } from "./default-agent";
 import { WorkspaceControl } from "./WorkspaceControl";
 import { rememberedMentions } from "../messages/remembered-mentions";
@@ -90,15 +102,44 @@ function dropOtherAgentTag(scope: string, key: string, agent?: string) {
 
 /** Whether New chat holds nothing of the person's since a start cleared it:
  * tags at most, no files, and its settings and workspace untouched. */
-function blankNewChat(session: RelaySession, scope: string, key: string) {
+function blankNewChat(
+  session: RelaySession,
+  scope: string,
+  key: string,
+  choices: string | null,
+  allowUnclearedPicks = false,
+) {
   const saved = mentionDraft(readView<unknown>(scope, `${key}:new-draft`, ""));
   return (
     (!composerMarkdown(saved).trim() || addressingOnly(saved)) &&
     !attachmentDraftCount(session, `${scope}:${key}:new-draft`) &&
+    (!Object.keys(parseSoloModelPicks(choices)).length ||
+      allowUnclearedPicks) &&
     readView(scope, `${key}:settings`, null) === null &&
     readView(scope, `${key}:new-project`, null) === null
   );
 }
+
+/** Keep only explicit draft selections validated for a first-send recipient. */
+function firstChatPicks(
+  draftPicks: DraftPicks | undefined,
+  validated: MentionPicks,
+  recipients: readonly string[],
+): DraftPicks {
+  return Object.fromEntries(
+    Object.entries(draftPicks ?? {}).flatMap(([pubkey, saved]) => {
+      const sent = validated[pubkey];
+      if (!sent || !recipients.includes(pubkey)) return [];
+      const { model, effort, type } = saved;
+      const pick = {
+        ...(model && model === sent.model ? { model } : {}),
+        ...(effort && effort === sent.effort ? { effort } : {}),
+        ...(type ? { type } : {}),
+      };
+      return pick.model || pick.effort ? [[pubkey, pick] as const] : [];
+    }),
+  );
+}
 /** Open New chats. Asked whether they hold work of the person's that view
  * state does not show: a draft that couldn't be saved, or Settings being
  * edited. Told when a refused start gives their draft back, since their
@@ -138,7 +179,9 @@ export function SoloDraft({
    * what was sent in it went back to New chat. It does unless a draft was
    * begun there since (an earlier refused prompt included) or it can't be
    * saved on this device; its settings may be saved only in part. */
-  onFailed?: ((id: string, message: string) => void) | undefined;
+  onFailed?:
+    | ((id: string, message: string, retry?: () => Promise<void>) => void)
+    | undefined;
   projectId?: string | undefined;
 }) {
   const draftKey = linkedId
@@ -146,6 +189,7 @@ export function SoloDraft({
     : projectId
       ? `solo:project:${projectId}`
       : "solo";
+  const notify = useToastNotification();
   // Before the composer reads it: a named agent replaces a saved draft that
   // only tags another agent, since that tag was the earlier default.
   useState(() => dropOtherAgentTag(scope, `${draftKey}:new-draft`, agent));
@@ -202,7 +246,7 @@ export function SoloDraft({
   }, [focusRequest]);
   // The remount replaces the editor; one that had the caret keeps it.
   const [restored, setRestored] = useState({ count: 0, focus: false });
-  // Whether the composer holds text it couldn't save.
+  // Whether the composer holds text or model choices it has not saved.
   const unsaved = useRef(false);
   useEffect(() => {
     const chat = {
@@ -248,6 +292,9 @@ export function SoloDraft({
     draft: MentionDraft,
     files: AttachmentDraft,
     addressed?: readonly MentionRecipient[],
+    picks?: MentionPicks,
+    draftPicks?: DraftPicks,
+    draftPicksRevision?: string | null,
   ) {
     const text = composerMarkdown(draft);
     if (submitting.current || !text.trim() || !available) return;
@@ -271,6 +318,9 @@ export function SoloDraft({
     const { ttlSeconds } = draftSettings;
     const project = selectedProject;
     const canvas = draftCanvas;
+    const draftModelPicksKey = soloModelPicksKey(`${draftKey}:new-draft`);
+    const chatModelPicksKey = soloModelPicksKey(channelId);
+    const startingDraftPicks = draftPicks ?? {};
     try {
       if (typeof name !== "string")
         throw new Error("The chat name could not be verified.");
@@ -351,13 +401,36 @@ export function SoloDraft({
             }
           : undefined,
       );
+      // Observe admission immediately, even while local persistence awaits ownership.
+      void ready.catch(() => {});
+      const firstPicks: MentionPicks = Object.fromEntries(
+        Object.entries(picks ?? {}).filter(([pubkey]) =>
+          recipients.includes(pubkey),
+        ),
+      );
+      const retainedPicks = firstChatPicks(
+        startingDraftPicks,
+        firstPicks,
+        recipients,
+      );
       try {
-        session.messages.send(
-          channelId,
-          text,
-          recipients,
-          ...(uploaded.length ? [uploaded] : []),
-        );
+        if (Object.keys(firstPicks).length)
+          session.messages.send(
+            channelId,
+            text,
+            recipients,
+            uploaded,
+            undefined,
+            [],
+            firstPicks,
+          );
+        else
+          session.messages.send(
+            channelId,
+            text,
+            recipients,
+            ...(uploaded.length ? [uploaded] : []),
+          );
         files.clear();
         writeView(
           scope,
@@ -383,71 +456,198 @@ export function SoloDraft({
       writeView(scope, `${draftKey}:new-draft`, source ? null : "");
       writeView(scope, `${draftKey}:new-draft:agents`, null);
       writeView(scope, `${draftKey}:new-project`, null);
-      onStarted(channelId);
+      let savedChatPicks = !Object.keys(retainedPicks).length;
+      let clearedPicks: "saved" | "changed" | "failed" = "failed";
+      let ownedDraftVersion = draftPicksRevision;
+      try {
+        await lockSoloModelPicks(scope, async () => {
+          const cleared = await transactModelPicks(
+            scope,
+            [chatModelPicksKey, draftModelPicksKey],
+            (tx) => {
+              if (!savedChatPicks)
+                tx.write(chatModelPicksKey, {
+                  ...retainedPicks,
+                  ...parseSoloModelPicks(tx.revision(chatModelPicksKey)),
+                });
+              if (tx.version(draftModelPicksKey) !== draftPicksRevision)
+                return undefined;
+              // An already-empty draft has no model choice to consume. Keep its
+              // receipt so another choice-free start does not disown recovery.
+              return tx.revision(draftModelPicksKey) === null
+                ? tx.version(draftModelPicksKey)
+                : tx.write(draftModelPicksKey, null);
+            },
+          );
+          savedChatPicks = true;
+          ownedDraftVersion = cleared;
+          clearedPicks = cleared === undefined ? "changed" : "saved";
+          publishModelPicks(scope);
+        });
+      } catch {
+        // Delivery retains its frozen choices; neither shared map is changed unlocked.
+      }
+      if (mounted.current) onStarted(channelId);
+      if (clearedPicks === "failed")
+        notify(
+          "Could not clear model and effort from New chat. Reset them before starting another chat.",
+          "error",
+        );
+      if (!savedChatPicks)
+        notify(
+          "Could not save model and effort for this chat. Choose them again before your next message.",
+          "error",
+        );
       // Only a start that made no chat ends here; the chat and its messages
       // are dropped (see channelWrites.start), and what was sent returns to a
       // New chat still blank. Any other miss leaves the chat listed, with its
       // messages' own Retry.
       void ready.catch((reason: unknown) => {
         if (!(reason instanceof ChatNotStarted)) return;
-        writeView(scope, `draft:${channelId}`, null);
-        clearAttachmentDraft(session, `${scope}:draft:${channelId}`);
-        const open = [...openNewChats].filter(
-          (chat) => chat.scope === scope && chat.key === draftKey,
-        );
-        const blank =
-          blankNewChat(session, scope, draftKey) &&
-          !open.some((chat) => chat.editing());
-        // The text first: when it can't be saved, an open New chat may hold
-        // unsaved text of its own, so nothing else is given back.
-        const returned =
-          blank && writeView(scope, `${draftKey}:new-draft`, draft);
-        // What else could not be saved: the toast says so, since a retry
-        // would otherwise silently use the defaults instead.
-        const missing: string[] = [];
-        const returnedTo = `${scope}\n${draftKey}`;
-        if (returned) {
-          restoredPrompts.set(returnedTo, JSON.stringify(draft));
-          if (source && !writeView(scope, draftKey, source))
-            missing.push("link");
-          if (!writeView(scope, `${draftKey}:settings`, draftSettings))
-            missing.push("settings");
-          if (!writeView(scope, `${draftKey}:new-project`, project))
-            missing.push("workspace");
-          // The pill's agents, when it routed the send; the composer reads
-          // them as it mounts. Tags in the text carry their own.
-          if (
-            addressed &&
-            !draft.recipients.length &&
-            !writeView(scope, `${draftKey}:new-draft:agents`, addressed)
-          )
-            missing.push("agents");
-          attachmentDraft(
-            session,
-            `${scope}:${draftKey}:new-draft`,
-            channelId,
-            true,
-          ).adopt(attached);
-          for (const chat of open) chat.restored();
-        }
-        const why = /[.!?]$/.test(reason.message)
-          ? reason.message
-          : `${reason.message}.`;
-        const earlier = restoredPrompts.get(returnedTo);
-        const outcome = returned
-          ? missing.length
-            ? `Your message is back in New chat, but its ${new Intl.ListFormat(
-                undefined,
-                { type: "conjunction" },
-              ).format(missing)} could not be saved on this device.`
-            : "Your message is back in New chat."
-          : blank
-            ? "Your message could not be saved on this device."
-            : earlier !== undefined &&
-                viewRevision(scope, `${draftKey}:new-draft`) === earlier
-              ? "New chat holds an earlier message that couldn't be sent, so this one was not restored."
-              : "New chat has a newer draft, so your message was not restored.";
-        onFailed?.(channelId, `Couldn't start "${name}": ${why} ${outcome}`);
+        let restoring = false;
+        let restored = false;
+        let prepared: { before: string | null; written: string } | undefined;
+        const restore = async () => {
+          if (restoring || restored) return;
+          restoring = true;
+          let failedPromptWrite = false;
+          try {
+            await lockSoloModelPicks(scope, async () => {
+              const open = () =>
+                [...openNewChats].filter(
+                  (chat) => chat.scope === scope && chat.key === draftKey,
+                );
+              const blankWith = (choices: string | null) =>
+                blankNewChat(
+                  session,
+                  scope,
+                  draftKey,
+                  choices,
+                  clearedPicks === "failed",
+                ) && !open().some((chat) => chat.editing());
+              const saved = await transactModelPicks(
+                scope,
+                [chatModelPicksKey, draftModelPicksKey],
+                (tx) => {
+                  const current = tx.version(draftModelPicksKey);
+                  const ownPrepared =
+                    prepared?.written === current ? prepared : undefined;
+                  const before = ownPrepared
+                    ? ownPrepared.before
+                    : tx.revision(draftModelPicksKey);
+                  // Even an equal-value Reset belongs to the later writer.
+                  const blank =
+                    (ownPrepared !== undefined ||
+                      current === ownedDraftVersion) &&
+                    blankWith(before);
+                  tx.write(chatModelPicksKey, null);
+                  const written = blank
+                    ? tx.write(draftModelPicksKey, startingDraftPicks)
+                    : undefined;
+                  return { before, blank, written };
+                },
+              );
+              if (saved.written)
+                prepared = { before: saved.before, written: saved.written };
+              publishModelPicks(scope);
+              // Text can change while IDB commits. Keep that newer work, undoing only
+              // this attempt's model restoration while we still own the scope lock.
+              const blank = saved.blank && blankWith(saved.before);
+              const undoPrepared = async () => {
+                if (!prepared) return;
+                const undo = prepared;
+                const version = await transactModelPicks(
+                  scope,
+                  [draftModelPicksKey],
+                  (tx) => {
+                    if (tx.version(draftModelPicksKey) === undo.written)
+                      return tx.write(
+                        draftModelPicksKey,
+                        undo.before === null
+                          ? null
+                          : parseSoloModelPicks(undo.before),
+                      );
+                  },
+                );
+                ownedDraftVersion = version;
+                prepared = undefined;
+                publishModelPicks(scope);
+              };
+              if (!blank) await undoPrepared();
+              // The text first: when it can't be saved, an open New chat may hold
+              // unsaved text of its own, so nothing else is given back.
+              const returned =
+                blank && writeView(scope, `${draftKey}:new-draft`, draft);
+              if (blank && !returned) {
+                await undoPrepared();
+                failedPromptWrite = true;
+                throw new Error("The recovered prompt could not be saved.");
+              }
+              writeView(scope, `draft:${channelId}`, null);
+              clearAttachmentDraft(session, `${scope}:draft:${channelId}`);
+              // What else could not be saved: the toast says so, since a retry
+              // would otherwise silently use the defaults instead.
+              const missing: string[] = [];
+              const returnedTo = `${scope}\n${draftKey}`;
+              if (returned) {
+                restoredPrompts.set(returnedTo, JSON.stringify(draft));
+                if (source && !writeView(scope, draftKey, source))
+                  missing.push("link");
+                if (!writeView(scope, `${draftKey}:settings`, draftSettings))
+                  missing.push("settings");
+                if (!writeView(scope, `${draftKey}:new-project`, project))
+                  missing.push("workspace");
+                // The pill's agents, when it routed the send; the composer reads
+                // them as it mounts. Tags in the text carry their own.
+                if (
+                  addressed &&
+                  !draft.recipients.length &&
+                  !writeView(scope, `${draftKey}:new-draft:agents`, addressed)
+                )
+                  missing.push("agents");
+                attachmentDraft(
+                  session,
+                  `${scope}:${draftKey}:new-draft`,
+                  channelId,
+                  true,
+                ).adopt(attached);
+                for (const chat of open()) chat.restored();
+              }
+              const why = /[.!?]$/.test(reason.message)
+                ? reason.message
+                : `${reason.message}.`;
+              const earlier = restoredPrompts.get(returnedTo);
+              const outcome = returned
+                ? missing.length
+                  ? `Your message is back in New chat, but its ${new Intl.ListFormat(
+                      undefined,
+                      { type: "conjunction" },
+                    ).format(missing)} could not be saved on this device.`
+                  : "Your message is back in New chat."
+                : earlier !== undefined &&
+                    viewRevision(scope, `${draftKey}:new-draft`) === earlier
+                  ? "New chat holds an earlier message that couldn't be sent, so this one was not restored."
+                  : "New chat has a newer draft, so your message was not restored.";
+              restored = true;
+              onFailed?.(
+                channelId,
+                `Couldn't start "${name}": ${why} ${outcome}`,
+              );
+            });
+          } catch {
+            const unavailable = failedPromptWrite
+              ? "Your message could not be saved on this device."
+              : "Window ownership or saved choices are unavailable.";
+            onFailed?.(
+              channelId,
+              `Couldn't start "${name}": ${reason.message}. ${unavailable} Retry to restore your message.`,
+              restore,
+            );
+          } finally {
+            restoring = false;
+          }
+        };
+        void restore();
       });
     } catch (reason) {
       if (mounted.current)
@@ -496,6 +696,7 @@ export function SoloDraft({
         }
         submission={{
           draftKey: `${draftKey}:new-draft`,
+          modelPicksKey: soloModelPicksKey(`${draftKey}:new-draft`),
           // The space ends the link, so typing after it writes prose.
           initialDraft: source && `${source.link} `,
           locked: busy,
@@ -504,8 +705,8 @@ export function SoloDraft({
           unsaved: (held) => {
             unsaved.current = held;
           },
-          submit: (draft, files, addressed) => {
-            void start(draft, files, addressed);
+          submit: (draft, files, addressed, picks, draftPicks, revision) => {
+            void start(draft, files, addressed, picks, draftPicks, revision);
           },
         }}
       />
diff --git a/tests/browser/composer-models.spec.mjs b/tests/browser/composer-models.spec.mjs
index c97ef84390..f2940f1348 100644
--- a/tests/browser/composer-models.spec.mjs
+++ b/tests/browser/composer-models.spec.mjs
@@ -1,5 +1,34 @@
 import { test, expect } from "./source-fixture.mjs";
 
+test.afterEach(async ({ context }, testInfo) => {
+  if (
+    testInfo.status === testInfo.expectedStatus ||
+    !testInfo.title.includes("shares storage and lock ownership")
+  )
+    return;
+  for (const [index, page] of context.pages().entries()) {
+    const snapshot = await page.evaluate(async () => ({
+      picks: await (
+        await import("/src/features/messages/solo-model-picks.ts")
+      ).readSoloModelPicks(
+        "composer-models-fixture",
+        "solo:model-picks:fixture",
+      ),
+      models: [
+        ...document.querySelectorAll('button[aria-label^="Model for"]'),
+      ].map((button) => ({
+        name: button.getAttribute("aria-label"),
+        text: button.textContent,
+      })),
+      locks: await navigator.locks.query(),
+    }));
+    await testInfo.attach(`model-persistence-page-${index}.json`, {
+      body: JSON.stringify(snapshot, null, 2),
+      contentType: "application/json",
+    });
+  }
+});
+
 // Capture transitions at the DOM-change boundary. transitionrun is queued and
 // can arrive after a busy renderer has already finished the entrance.
 async function holdPickerMotion(page) {
@@ -46,6 +75,49 @@ test("effort picker opens, follows the keyboard and returns focus", async ({
   await expect(trigger).toBeFocused();
 });
 
+test("Solo first-send choices stay selected until explicit reset", async ({
+  page,
+}, testInfo) => {
+  await page.goto("/tests/fixtures/composer-models.html?solo");
+  const trigger = page.getByRole("button", {
+    name: "Model and effort for this chat",
+  });
+  await expect(trigger).toBeVisible();
+  await page.screenshot({
+    path: testInfo.outputPath("solo-model-picker-before-selection.png"),
+  });
+  await trigger.click();
+  await page
+    .getByRole("button", { name: "Model for Honey in this chat" })
+    .click();
+  await page.getByRole("menuitemradio", { name: "Alternate model" }).click();
+  const effort = page.getByRole("slider", {
+    name: "Effort for Honey in this chat",
+  });
+  await expect(effort).toHaveAttribute("aria-valuetext", "Medium");
+  await effort.focus();
+  await page.keyboard.press("ArrowRight");
+  await expect(effort).toHaveAttribute("aria-valuetext", "High");
+  await page.keyboard.press("Escape");
+  await expect(trigger).toHaveAttribute("data-selected", "");
+
+  await trigger.click();
+  const popup = page.getByRole("dialog");
+  await expect(
+    popup.getByRole("button", { name: "Model for Honey in this chat" }),
+  ).toContainText("Alternate model");
+  await expect(effort).toHaveAttribute("aria-valuetext", "High");
+  await expect(
+    popup.getByRole("button", { name: "Reset model and effort" }),
+  ).toBeVisible();
+  await popup.screenshot({ path: testInfo.outputPath("solo-first-send.png") });
+
+  await popup.getByRole("button", { name: "Reset model and effort" }).click();
+  await expect(trigger).not.toHaveAttribute("data-selected");
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+  await expect(trigger).toBeFocused();
+});
+
 // Browser-only: inherited animated progress, real track geometry and label clamping.
 // A DOM emulator cannot catch the fill jumping ahead or the label moving backwards.
 test("entrance keeps the fill and delayed model button attached to the handle", async ({
@@ -217,3 +289,288 @@ test("keyboard-opened picker stays settled when switching to the pointer", async
   expect(after.x).toBeCloseTo(before.x, 0);
   expect(after.opacity).toBe(1);
 });
+
+// Real same-origin IDB transactions, notifications and Web Locks span two pages; mounted tests
+// own pending intent, resets, Send and refused-start lifecycle permutations.
+test("Solo model persistence shares storage and lock ownership across pages", async ({
+  page,
+  context,
+}) => {
+  const other = await context.newPage();
+  await Promise.all([
+    page.goto("/tests/fixtures/composer-models.html?solo&persist"),
+    other.goto("/tests/fixtures/composer-models.html?solo&persist"),
+  ]);
+  await page.evaluate(async () => {
+    const { lockSoloModelPicks } = await import(
+      "/src/features/messages/solo-model-picks.ts"
+    );
+    const gate = new Promise((resolve) => {
+      window.releaseModelLock = resolve;
+    });
+    await new Promise((resolve) => {
+      window.modelLock = lockSoloModelPicks("composer-models-fixture", () => {
+        resolve();
+        return gate;
+      });
+    });
+  });
+  const trigger = (page) =>
+    page.getByRole("button", { name: "Model and effort for this chat" });
+  try {
+    for (const [target, name] of [
+      [page, "Honey"],
+      [other, "Bumble"],
+    ]) {
+      await trigger(target).click();
+      await target
+        .getByRole("button", { name: `Model for ${name} in this chat` })
+        .click();
+      await target
+        .getByRole("menuitemradio", { name: "Alternate model" })
+        .click();
+      await expect(trigger(target)).toHaveAttribute("data-selected", "");
+    }
+    // Both UI actions completed, but the real lock is still held elsewhere.
+    expect(
+      await page.evaluate(async () =>
+        (await import("/src/features/messages/solo-model-picks.ts"))
+          .readSoloModelPicks(
+            "composer-models-fixture",
+            "solo:model-picks:fixture",
+          )
+          .then((saved) => saved.revision),
+      ),
+    ).toBeNull();
+  } finally {
+    await page.evaluate(async () => {
+      window.releaseModelLock();
+      await window.modelLock;
+    });
+  }
+  // Each page must observe its peer's edit through a post-commit notification.
+  await expect(
+    page.getByRole("button", { name: "Model for Bumble in this chat" }),
+  ).toContainText("Alternate model");
+  await expect(
+    other.getByRole("button", { name: "Model for Honey in this chat" }),
+  ).toContainText("Alternate model");
+  await page.reload();
+  await trigger(page).click();
+  await expect(
+    page.getByRole("button", { name: "Model for Honey in this chat" }),
+  ).toContainText("Alternate model");
+  await expect(
+    page.getByRole("button", { name: "Model for Bumble in this chat" }),
+  ).toContainText("Alternate model");
+});
+
+// An IDB transaction alone cannot order a purge behind a save waiting on a Web Lock.
+test("Solo choice purge waits for already queued saves", async ({ page }) => {
+  await page.goto("/tests/fixtures/composer-models.html");
+  await page.evaluate(async () => {
+    const { lockSoloModelPicks, updateSoloModelPicks } = await import(
+      "/src/features/messages/solo-model-picks.ts"
+    );
+    const { purgeSoloModelPicks } = await import(
+      "/src/features/messages/solo-model-picks-storage.ts"
+    );
+    const gate = new Promise((resolve) => {
+      window.releaseModelLock = resolve;
+    });
+    await new Promise((resolve) => {
+      window.modelLock = lockSoloModelPicks("purge", () => {
+        resolve();
+        return gate;
+      });
+    });
+    window.queuedModelSave = updateSoloModelPicks(
+      "purge",
+      "solo:model-picks:fixture",
+      new Map([["a".repeat(64), { model: "fixture" }]]),
+    );
+    window.modelPurge = purgeSoloModelPicks("purge").then(() => {
+      window.modelPurgeFinished = true;
+    });
+  });
+  try {
+    // Both implementations reach a boundary: an unlocked purge completes,
+    // while a locked one waits behind the save. Neither depends on runner speed.
+    await expect
+      .poll(() =>
+        page.evaluate(async () => {
+          const { pending } = await navigator.locks.query();
+          return (
+            window.modelPurgeFinished === true ||
+            pending.filter(
+              (lock) => lock.name === "buzz-solo-model-picks:purge",
+            ).length === 2
+          );
+        }),
+      )
+      .toBe(true);
+  } finally {
+    await page.evaluate(async () => {
+      window.releaseModelLock();
+      await Promise.all([
+        window.modelLock,
+        window.queuedModelSave,
+        window.modelPurge,
+      ]);
+    });
+  }
+  expect(
+    await page.evaluate(async () => {
+      const { readSoloModelPicks } = await import(
+        "/src/features/messages/solo-model-picks.ts"
+      );
+      return (await readSoloModelPicks("purge", "solo:model-picks:fixture"))
+        .revision;
+    }),
+  ).toBeNull();
+});
+
+// Real IDB commit/abort and storage availability are browser contracts, not jsdom mocks.
+test("Solo choice initialization and first-send compare/clear commit atomically", async ({
+  page,
+}) => {
+  await page.goto("/tests/fixtures/composer-models.html");
+  const result = await page.evaluate(async () => {
+    const { transactModelPicks, purgeSoloModelPicks } = await import(
+      "/src/features/messages/solo-model-picks-storage.ts"
+    );
+    const { readSoloModelPicks } = await import(
+      "/src/features/messages/solo-model-picks.ts"
+    );
+    const { writeView, viewRevision } = await import(
+      "/src/shared/view-state.ts"
+    );
+    const scope = "initialization",
+      kept = "initialization-other",
+      draft = "solo:model-picks:new",
+      chat = "solo:model-picks:chat";
+    const original = {
+      ["a".repeat(64)]: { model: "alternate", effort: "high" },
+    };
+    const newer = { ["b".repeat(64)]: { model: "fixture" } };
+    writeView(scope, draft, original);
+    const read = async (scope, key) =>
+      (await readSoloModelPicks(scope, key)).revision;
+    const getItem = Storage.prototype.getItem;
+    let freshWithoutLocalStorage, savedWithoutLocalStorage;
+    Storage.prototype.getItem = function (key) {
+      if (key === `buzz-view.v1:${JSON.stringify([scope, draft])}`)
+        throw new DOMException("Legacy storage unavailable");
+      return getItem.call(this, key);
+    };
+    try {
+      freshWithoutLocalStorage = await read(scope, draft);
+      await transactModelPicks(scope, [draft], (tx) =>
+        tx.write(draft, original),
+      );
+      savedWithoutLocalStorage = await read(scope, draft);
+    } finally {
+      Storage.prototype.getItem = getItem;
+    }
+    let aborted = false;
+    try {
+      await transactModelPicks(scope, [draft, chat], (tx) => {
+        tx.write(chat, original);
+        tx.write(draft, null);
+        throw new Error("Simulated failure after both writes were queued");
+      });
+    } catch {
+      aborted = true;
+    }
+    const afterAbort = [await read(scope, draft), await read(scope, chat)];
+    const baseline = (await readSoloModelPicks(scope, draft)).version;
+    const cleared = await transactModelPicks(scope, [draft, chat], (tx) => {
+      tx.write(chat, original);
+      if (tx.version(draft) !== baseline) return false;
+      tx.write(draft, null);
+      return true;
+    });
+    const afterTransfer = [await read(scope, draft), await read(scope, chat)];
+    const clearedReceipt = (await readSoloModelPicks(scope, draft)).version;
+    await transactModelPicks(scope, [draft], (tx) => tx.write(draft, original));
+    await transactModelPicks(scope, [draft], (tx) => tx.write(draft, {}));
+    const restoredAfterReset = await transactModelPicks(
+      scope,
+      [draft],
+      (tx) => {
+        if (tx.version(draft) !== clearedReceipt) return false;
+        tx.write(draft, original);
+        return true;
+      },
+    );
+    const afterReset = await read(scope, draft);
+    await transactModelPicks(scope, [draft], (tx) => tx.write(draft, null));
+    // Unrelated view-state bytes cannot resurrect consumed choices.
+    const legacy = viewRevision(scope, draft);
+    writeView(scope, draft, newer);
+    const afterLegacyWrite = await read(scope, draft);
+    await transactModelPicks(scope, [draft], (tx) => tx.write(draft, newer));
+    const clearedNewer = await transactModelPicks(scope, [draft], (tx) => {
+      if (tx.version(draft) !== baseline) return false;
+      tx.write(draft, null);
+      return true;
+    });
+    const afterCompare = await read(scope, draft);
+    const beforeEqualWrite = (await readSoloModelPicks(scope, draft)).version;
+    await transactModelPicks(scope, [draft], (tx) => tx.write(draft, newer));
+    const undidEqualWrite = await transactModelPicks(scope, [draft], (tx) => {
+      if (tx.version(draft) !== beforeEqualWrite) return false;
+      tx.write(draft, null);
+      return true;
+    });
+    const afterStaleUndo = await read(scope, draft);
+    await transactModelPicks(kept, [draft], (tx) => tx.write(draft, original));
+    // Purge cannot revive view-state bytes and does not touch another scope.
+    writeView(scope, "solo:model-picks:unread", original);
+    await purgeSoloModelPicks(scope);
+    return {
+      aborted,
+      freshWithoutLocalStorage,
+      savedWithoutLocalStorage,
+      afterAbort,
+      cleared,
+      afterTransfer,
+      restoredAfterReset,
+      afterReset,
+      undidEqualWrite,
+      afterStaleUndo,
+      legacy,
+      afterLegacyWrite,
+      clearedNewer,
+      afterCompare,
+      purged: await read(scope, draft),
+      purgedUnread: await read(scope, "solo:model-picks:unread"),
+      purgedLegacy: viewRevision(scope, draft),
+      kept: await read(kept, draft),
+    };
+  });
+  const original = JSON.stringify({
+    ["a".repeat(64)]: { model: "alternate", effort: "high" },
+  });
+  const newer = JSON.stringify({ ["b".repeat(64)]: { model: "fixture" } });
+  expect(result).toEqual({
+    aborted: true,
+    freshWithoutLocalStorage: null,
+    savedWithoutLocalStorage: original,
+    afterAbort: [original, null],
+    cleared: true,
+    afterTransfer: [null, original],
+    restoredAfterReset: false,
+    afterReset: "{}",
+    undidEqualWrite: false,
+    afterStaleUndo: newer,
+    legacy: original,
+    afterLegacyWrite: null,
+    clearedNewer: false,
+    afterCompare: newer,
+    purged: null,
+    purgedUnread: null,
+    purgedLegacy: newer,
+    kept: original,
+  });
+});
diff --git a/tests/fixtures/composer-models.tsx b/tests/fixtures/composer-models.tsx
index 8429f23348..c541291d00 100644
--- a/tests/fixtures/composer-models.tsx
+++ b/tests/fixtures/composer-models.tsx
@@ -1,11 +1,18 @@
 // The real composer control and React lifecycle, with a read-only model catalog.
 // No native harness, relay, credentials or live agent execution.
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { createRoot } from "react-dom/client";
 import { ComposerModels } from "../../src/features/messages/ComposerModels";
 import { AgentsContext } from "../../src/features/agents/react";
 import type { Agents } from "../../src/features/agents/service";
-import type { MentionPicks } from "../../src/features/relay/messages";
+import type { DraftPicks } from "../../src/features/messages/ComposerModels";
+import {
+  parseSoloModelPicks,
+  readSoloModelPicks,
+  soloModelPicksKey,
+  updateSoloModelPicks,
+} from "../../src/features/messages/solo-model-picks";
+import { subscribeModelPicks } from "../../src/features/messages/solo-model-picks-storage";
 import type { ProfileQueries } from "../../src/features/relay/profile-directory";
 import { createAppearance } from "../../src/shared/theme/service";
 import { useKeyboardFocusVisibility } from "../../src/shared/design-system/useKeyboardFocusVisibility";
@@ -13,29 +20,54 @@ import "../../src/shared/styles/globals.css";
 
 createAppearance();
 const pubkey = "a".repeat(64);
+const peer = "b".repeat(64);
+const persistence = new URLSearchParams(window.location.search).has("persist");
+const scope = "composer-models-fixture";
+const key = soloModelPicksKey("fixture");
 const snapshot = {
   status: "ready",
-  agents: [{ pubkey, name: "Honey", type: "test/agent" }],
+  agents: [
+    { pubkey, name: "Honey", type: "test/agent" },
+    { pubkey: peer, name: "Bumble", type: "test/agent" },
+  ],
 };
+let failCatalog = new URLSearchParams(window.location.search).has(
+  "catalog-error",
+);
 const types = [
   {
     key: "test/agent",
-    models: () => ({
-      current: "fixture",
-      models: [
-        {
-          id: "fixture",
-          label: "Fixture model",
-          effort: "medium",
-          efforts: [
-            { id: "low", label: "Low" },
-            { id: "medium", label: "Medium" },
-            { id: "high", label: "High" },
-          ],
-        },
-        { id: "alternate", label: "Alternate model", efforts: [] },
-      ],
-    }),
+    models: () => {
+      if (failCatalog) {
+        failCatalog = false;
+        throw new Error("Fixture catalog is temporarily unavailable");
+      }
+      return {
+        current: "fixture",
+        models: [
+          {
+            id: "fixture",
+            label: "Fixture model",
+            effort: "medium",
+            efforts: [
+              { id: "low", label: "Low" },
+              { id: "medium", label: "Medium" },
+              { id: "high", label: "High" },
+            ],
+          },
+          {
+            id: "alternate",
+            label: "Alternate model",
+            effort: "medium",
+            efforts: [
+              { id: "low", label: "Low" },
+              { id: "medium", label: "Medium" },
+              { id: "high", label: "High" },
+            ],
+          },
+        ],
+      };
+    },
   },
 ];
 // The catalog is immutable; these are the only service reads the control uses.
@@ -55,22 +87,70 @@ const media = () => undefined;
 const ignoreResolved = () => {};
 function Fixture() {
   useKeyboardFocusVisibility();
-  const [picks, setPicks] = useState<MentionPicks>({});
+  const solo = new URLSearchParams(window.location.search).has("solo");
+  const [picks, setPicks] = useState<DraftPicks>({});
+  const [error, setError] = useState("");
+  const [ready, setReady] = useState(!persistence);
+  useEffect(() => {
+    if (!persistence) return;
+    let live = true;
+    const refresh = async () => {
+      try {
+        const { revision } = await readSoloModelPicks(scope, key);
+        if (live) {
+          setPicks(parseSoloModelPicks(revision));
+          setReady(true);
+        }
+      } catch (reason) {
+        if (live) setError(String(reason));
+      }
+    };
+    const stop = subscribeModelPicks(scope, () => void refresh());
+    void refresh();
+    return () => {
+      live = false;
+      stop();
+    };
+  }, []);
+  const changePicks = (next: DraftPicks, reset: readonly string[] = []) => {
+    setPicks(next);
+    if (!persistence) return;
+    const changed = new Set([
+      ...Object.keys(picks),
+      ...Object.keys(next),
+      ...reset,
+    ]);
+    const edits = new Map(
+      [...changed]
+        .filter(
+          (pubkey) =>
+            reset.includes(pubkey) ||
+            JSON.stringify(picks[pubkey]) !== JSON.stringify(next[pubkey]),
+        )
+        .map((pubkey) => [pubkey, next[pubkey]]),
+    );
+    void updateSoloModelPicks(scope, key, edits).catch((reason) =>
+      setError(String(reason)),
+    );
+  };
   return (
     <AgentsContext.Provider value={agents}>
       <main className="mx-auto flex max-w-2xl flex-col gap-4 p-8">
         <h1 className="text-title">Composer model and effort</h1>
         <button type="button">Outside the picker</button>
+        {error && <p role="alert">{error}</p>}
         <form aria-label="Composer controls">
           <ComposerModels
-            pubkeys={[pubkey]}
+            pubkeys={persistence ? [pubkey, peer] : [pubkey]}
             profiles={profiles}
             media={media}
             value={picks}
-            disabled={false}
+            disabled={!ready}
+            resettable={solo}
+            explicitOnly={solo}
             startsThread={false}
             place={{ channelId: "fixture" }}
-            onChange={setPicks}
+            onChange={changePicks}
             onResolved={ignoreResolved}
           />
         </form>