diff --git a/backend/cortex_backend/api/jobs.py b/backend/cortex_backend/api/jobs.py
index bde4eb9..c8ab408 100644
--- a/backend/cortex_backend/api/jobs.py
+++ b/backend/cortex_backend/api/jobs.py
@@ -98,6 +98,7 @@ class _JobRecord:
     prepared: bool = False
     preparation_error: str | None = None
     cancel_event: Event = field(default_factory=Event)
+    commit_started: bool = False
     status: JobStatus = "queued"
     sequence: int = 0
     error: str | None = None
@@ -127,6 +128,39 @@ def publish_progress(
         payload = {"message": message, **dict(data or {})}
         self.publish_event("progress", phase=phase, data=payload)
 
+    def begin_commit(
+        self,
+        phase: str,
+        message: str,
+        *,
+        data: Mapping[str, Any] | None = None,
+    ) -> bool:
+        """Atomically cross the point after which cancellation is too late.
+
+        The worker must call this immediately before its first durable result
+        mutation.  Sharing the registry lock with :meth:`JobRegistry.cancel`
+        gives the two operations one unambiguous order: cancellation wins and
+        this returns ``False``, or commit wins and later cancellation is inert.
+        """
+        payload = {"message": message, **dict(data or {})}
+        with self._registry._lock:
+            if (
+                self._record.status != "running"
+                or self._record.cancel_event.is_set()
+            ):
+                return False
+            if self._record.commit_started:
+                return True
+            self._record.commit_started = True
+            self._registry._append_event(
+                self._record,
+                kind="progress",
+                status="running",
+                phase=phase,
+                data=payload,
+            )
+            return True
+
     def publish_event(
         self,
         kind: EventKind,
@@ -392,7 +426,11 @@ def active_snapshot(self, *, kind: JobKind) -> JobSnapshot | None:
     def cancel(self, job_id: str, *, owner: str) -> JobSnapshot:
         record = self._owned_record(job_id, owner)
         with self._lock:
-            if record.status not in TERMINAL_STATUSES and record.status != "cancelling":
+            if (
+                not record.commit_started
+                and record.status not in TERMINAL_STATUSES
+                and record.status != "cancelling"
+            ):
                 record.cancel_event.set()
                 self._append_event(
                     record,
@@ -443,6 +481,8 @@ async def shutdown(self) -> None:
                 if record.status not in TERMINAL_STATUSES
             ]
             for record in records:
+                if record.commit_started:
+                    continue
                 if record.status != "cancelling":
                     record.cancel_event.set()
                     self._append_event(
@@ -493,7 +533,9 @@ async def _run(
             with self._lock:
                 if record.status in TERMINAL_STATUSES:
                     return
-                if record.status == "cancelling" or record.cancel_event.is_set():
+                if not record.commit_started and (
+                    record.status == "cancelling" or record.cancel_event.is_set()
+                ):
                     self._finalize_cancellation(record)
                     return
                 data = dict(
@@ -510,6 +552,7 @@ async def _run(
             with self._lock:
                 if (
                     record.status not in TERMINAL_STATUSES
+                    and not record.commit_started
                     and (record.status == "cancelling" or record.cancel_event.is_set())
                 ):
                     self._finalize_cancellation(record)
@@ -518,7 +561,9 @@ async def _run(
             with self._lock:
                 if record.status in TERMINAL_STATUSES:
                     return
-                if record.status == "cancelling" or record.cancel_event.is_set():
+                if not record.commit_started and (
+                    record.status == "cancelling" or record.cancel_event.is_set()
+                ):
                     self._finalize_cancellation(record)
                     return
                 logging.error(
diff --git a/backend/cortex_backend/api/routes.py b/backend/cortex_backend/api/routes.py
index 99217bc..815df47 100644
--- a/backend/cortex_backend/api/routes.py
+++ b/backend/cortex_backend/api/routes.py
@@ -1869,23 +1869,10 @@ def runner(sink, cancel_event):
                 history_messages=prepared_history,
             )
             # The generation service checks cancellation around its model work,
-            # but the API owns the following persistence and optional title work.
-            # Keep those side effects behind explicit checkpoints as well.
+            # while the API owns streaming and persistence. Keep everything
+            # cancellable until begin_commit atomically seals the durable result.
             if cancel_event.is_set():
                 return {"cancelled": True}
-            code_execution_job_id = _queue_code_proposal(
-                request,
-                principal,
-                settings,
-                generation_snapshot.job_id,
-                result,
-            )
-            if code_execution_job_id:
-                sink.publish_progress(
-                    "code_approval",
-                    "A local code task is waiting for your approval.",
-                    data={"execution_job_id": code_execution_job_id},
-                )
             if result.thoughts:
                 for delta in _chunks(result.thoughts):
                     if cancel_event.is_set():
@@ -1904,14 +1891,7 @@ def runner(sink, cancel_event):
                     data={"delta": delta},
                 )
 
-            for memo in result.memory_command.additions:
-                if cancel_event.is_set():
-                    return {"cancelled": True}
-                deps.memories.add_memo(memo)
-            if cancel_event.is_set():
-                return {"cancelled": True}
-            sink.publish_progress("persisting", "Saving the response.")
-            if cancel_event.is_set():
+            if not sink.begin_commit("persisting", "Saving the response."):
                 return {"cancelled": True}
             stats_payload = asdict(result.stats) if result.stats else None
             if target_message_id is None:
@@ -1934,13 +1914,40 @@ def runner(sink, cancel_event):
                 )
                 assistant_message_id = target_message_id
 
-            if cancel_event.is_set():
-                return {"cancelled": True}
+            # The assistant turn is the canonical generation result. Code and
+            # memory actions are optional derivatives: queue them only after the
+            # answer exists, and never invalidate that answer if they fail.
+            code_execution_job_id = None
+            try:
+                code_execution_job_id = _queue_code_proposal(
+                    request,
+                    principal,
+                    settings,
+                    generation_snapshot.job_id,
+                    result,
+                )
+            except Exception as exc:
+                logging.warning(
+                    "Cortex code proposal queueing failed (%s).", type(exc).__name__
+                )
+            if code_execution_job_id:
+                sink.publish_progress(
+                    "code_approval",
+                    "A local code task is waiting for your approval.",
+                    data={"execution_job_id": code_execution_job_id},
+                )
+
+            for memo in result.memory_command.additions:
+                try:
+                    deps.memories.add_memo(memo)
+                except Exception as exc:
+                    logging.warning(
+                        "Cortex memory update failed (%s).", type(exc).__name__
+                    )
+
             updated_chat = deps.chats.get_chat(thread_id) or {"messages": []}
             title = str(updated_chat.get("title") or "New Chat")
             if target_message_id is None and title == "New Chat":
-                if cancel_event.is_set():
-                    return {"cancelled": True}
                 raw_title = None
                 title_generator = getattr(
                     deps.generation, "generate_chat_title", None
@@ -1955,8 +1962,6 @@ def runner(sink, cancel_event):
                             "Cortex chat title generation failed (%s).",
                             type(exc).__name__,
                         )
-                if cancel_event.is_set():
-                    return {"cancelled": True}
                 generated_title = normalize_title(raw_title, fallback="")
                 if (
                     not generated_title
@@ -1964,8 +1969,6 @@ def runner(sink, cancel_event):
                 ):
                     generated_title = title_from_first_message(payload.user_input)
                 if generated_title != title:
-                    if cancel_event.is_set():
-                        return {"cancelled": True}
                     try:
                         deps.chats.rename_chat(thread_id, generated_title)
                         title = generated_title
@@ -1973,8 +1976,6 @@ def runner(sink, cancel_event):
                         logging.warning(
                             "Cortex title update failed (%s).", type(exc).__name__
                         )
-            if cancel_event.is_set():
-                return {"cancelled": True}
             updated_chat = deps.chats.get_chat(thread_id) or updated_chat
             return {
                 "thread_id": thread_id,
diff --git a/backend/cortex_backend/launcher/frontend.py b/backend/cortex_backend/launcher/frontend.py
index e85bb67..ae3d768 100644
--- a/backend/cortex_backend/launcher/frontend.py
+++ b/backend/cortex_backend/launcher/frontend.py
@@ -200,14 +200,15 @@ def build_frontend(
     frontend_root = frontend_root.resolve()
     if not (frontend_root / "package.json").is_file():
         raise FrontendBuildError("frontend/package.json is missing from the source checkout.")
-    lock = lock_digest(frontend_root)
-    node_major = _major_version("node")
-    npm_major = _major_version("npm")
     build_root = _stage_frontend_source(frontend_root)
     staging = build_root / f".cortex-dist-staging-{uuid.uuid4().hex}"
     dist = frontend_root / "dist"
     backup = frontend_root / f".cortex-dist-backup-{uuid.uuid4().hex}"
     try:
+        lock = lock_digest(build_root)
+        source = source_digest(build_root)
+        node_major = _major_version("node")
+        npm_major = _major_version("npm")
         _install_if_needed(build_root, lock)
         _run(
             [_tool_name("npm"), "run", "build", "--", "--outDir", str(staging)],
@@ -217,7 +218,7 @@ def build_frontend(
             raise FrontendBuildError("Frontend build completed without index.html.")
         manifest = FrontendManifest(
             lock_digest=lock,
-            source_digest=source_digest(frontend_root),
+            source_digest=source,
             node_major=node_major,
             npm_major=npm_major,
             built_at=datetime.now(timezone.utc).isoformat(),
diff --git a/frontend/src/app/App.test.tsx b/frontend/src/app/App.test.tsx
index 5407acd..57468bb 100644
--- a/frontend/src/app/App.test.tsx
+++ b/frontend/src/app/App.test.tsx
@@ -3,6 +3,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import userEvent from "@testing-library/user-event";
 import { App } from "./App";
 import { CortexApi } from "../api/client";
+import { useChatStore } from "../stores/useChatStore";
 import { ToastProvider } from "./ToastProvider";
 
 describe("App", () => {
@@ -42,6 +43,40 @@ describe("App", () => {
     expect(screen.queryByLabelText(/token/i)).not.toBeInTheDocument();
   });
 
+  it("returns to onboarding and clears a persisted generation when its stream session expires", async () => {
+    window.sessionStorage.setItem("cortex.session.token", "local-session");
+    window.sessionStorage.setItem("cortex.active.generation", JSON.stringify({
+      jobId: "job-expired",
+      threadId: "thread-expired",
+      lastEventId: 3,
+    }));
+    window.history.replaceState({}, "", "/chat/thread-expired");
+    const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+    const fetcher = vi.fn<typeof fetch>(async (input) => {
+      const url = String(input);
+      if (url.endsWith("/system")) return json({ status: "ok", preview: true, session_required: true, started_at: "2026-07-21T18:00:00Z" });
+      if (url.endsWith("/chat-groups")) return json([]);
+      if (url.endsWith("/chats")) return json([{ id: "thread-expired", title: "Interrupted", timestamp: "2026-07-21T18:00:00Z" }]);
+      if (url.endsWith("/chats/thread-expired")) return json({ id: "thread-expired", title: "Interrupted", timestamp: "2026-07-21T18:00:00Z", revision: 1, messages: [] });
+      if (url.endsWith("/settings")) return json({ settings: { models: { chat: "model-a", title: null }, appearance: { theme: "dark" } } });
+      if (url.endsWith("/memories")) return json({ memos: [] });
+      if (url.endsWith("/models")) return json({ required_models: [], optional_models: [], installed_models: ["model-a"], connection: { success: true, status: "connected", message: "Ready" } });
+      if (url.endsWith("/generations/job-expired/events")) return json({ detail: "Local session expired." }, 401);
+      return json({ detail: "Unexpected test route." }, 404);
+    });
+
+    render(<ToastProvider><App api={new CortexApi("/api/v1", fetcher)} /></ToastProvider>);
+
+    expect(await screen.findByRole("heading", { name: "Start local workspace" })).toBeVisible();
+    expect(fetcher.mock.calls.filter(([input]) => String(input).endsWith("/generations/job-expired/events"))).toHaveLength(1);
+    expect(window.sessionStorage.getItem("cortex.session.token")).toBeNull();
+    expect(window.sessionStorage.getItem("cortex.active.generation")).toBeNull();
+    expect(useChatStore.getState().generation).toMatchObject({ jobId: null, phase: "idle" });
+  });
+
   it("opens the workspace when the model service is unavailable", async () => {
     window.sessionStorage.setItem("cortex.session.token", "local-session");
     const json = (body: unknown, status = 200) => new Response(JSON.stringify(body), {
diff --git a/frontend/src/app/App.tsx b/frontend/src/app/App.tsx
index f5e2976..13af88c 100644
--- a/frontend/src/app/App.tsx
+++ b/frontend/src/app/App.tsx
@@ -482,7 +482,7 @@ function AuthenticatedWorkspace({ api, onSessionExpired }: { api: CortexApi; onS
       <AppShell chats={chats} activeChatId={routeChatId} modelConnection={models.connection} theme={theme} executionTasks={visibleExecutionTasks} onCancelExecution={cancelExecution} onDecideExecutionApproval={decideExecutionApproval} onLoadCodeSource={loadCodeSource} onOpenSettings={() => { if (route.kind === "chat") setSettingsReturnChatId(route.threadId); }} onRenameChat={renameChat} onDeleteChat={deleteChat} groups={groups} onCreateGroup={createGroup} onRenameGroup={renameGroup} onDeleteGroup={deleteGroup} onToggleGroup={toggleGroup} onMoveChat={moveChat}>
         {route.kind === "settings"
           ? <SettingsRoute activeChatId={settingsReturnChatId} settings={settings} memos={memos} saving={saving} memoryBusy={memoryBusy} onSave={saveSettings} onAddMemory={addMemory} onReplaceMemory={replaceMemory} onClearMemory={clearMemory} models={models} modelBusy={modelBusy} modelProgress={modelProgress} setupUrl={system.ollama_setup_url ?? "https://ollama.com/download"} onCheckModels={checkModels} onPullModel={pullModel} llamacppStatus={llamacppStatus} onDownloadGGUF={downloadGGUFModel} />
-          : <ChatRoute threadId={routeChatId} api={api} runtimeReady={runtimeConnected && selectedModelAvailable} runtimeMessage={models.connection?.message ?? null} localModels={localModels} selectedModel={selectedModel} selectedModelSupportsVision={selectedModelSupportsVision} modelBusy={modelBusy || saving} onSelectModel={chooseLocalModel} onRescanModels={checkModels} onChatChanged={upsertChatSummary} onForked={upsertChatSummary} />}
+          : <ChatRoute threadId={routeChatId} api={api} runtimeReady={runtimeConnected && selectedModelAvailable} runtimeMessage={models.connection?.message ?? null} localModels={localModels} selectedModel={selectedModel} selectedModelSupportsVision={selectedModelSupportsVision} modelBusy={modelBusy || saving} onSelectModel={chooseLocalModel} onRescanModels={checkModels} onChatChanged={upsertChatSummary} onForked={upsertChatSummary} onSessionExpired={onSessionExpired} />}
       </AppShell>
       <CommandPalette
         chats={chats}
@@ -508,9 +508,9 @@ function updateModelProgress(event: SSEEvent, setProgress: (progress: ModelProgr
   setProgress({ model, status, percent });
 }
 
-function ChatRoute({ threadId, api, runtimeReady, runtimeMessage, localModels, selectedModel, selectedModelSupportsVision, modelBusy, onSelectModel, onRescanModels, onChatChanged, onForked }: { threadId: string | null; api: CortexApi; runtimeReady: boolean; runtimeMessage: string | null; localModels: readonly string[]; selectedModel: string | null; selectedModelSupportsVision: boolean | null; modelBusy: boolean; onSelectModel: (model: string) => Promise<boolean>; onRescanModels: () => Promise<void>; onChatChanged: (chat: ChatResponse) => void; onForked: (chat: ChatResponse) => void }) {
+function ChatRoute({ threadId, api, runtimeReady, runtimeMessage, localModels, selectedModel, selectedModelSupportsVision, modelBusy, onSelectModel, onRescanModels, onChatChanged, onForked, onSessionExpired }: { threadId: string | null; api: CortexApi; runtimeReady: boolean; runtimeMessage: string | null; localModels: readonly string[]; selectedModel: string | null; selectedModelSupportsVision: boolean | null; modelBusy: boolean; onSelectModel: (model: string) => Promise<boolean>; onRescanModels: () => Promise<void>; onChatChanged: (chat: ChatResponse) => void; onForked: (chat: ChatResponse) => void; onSessionExpired: () => void }) {
   const navigate = useNavigate();
-  return <ChatPage api={api} threadId={threadId} runtimeReady={runtimeReady} runtimeMessage={runtimeMessage} localModels={localModels} selectedModel={selectedModel} selectedModelSupportsVision={selectedModelSupportsVision} modelBusy={modelBusy} onSelectModel={onSelectModel} onRescanModels={onRescanModels} onThreadCreated={(id) => navigate(chatPath(id), { replace: true })} onChatChanged={onChatChanged} onForked={(chat) => { onForked(chat); navigate(chatPath(chat.id)); }} />;
+  return <ChatPage api={api} threadId={threadId} runtimeReady={runtimeReady} runtimeMessage={runtimeMessage} localModels={localModels} selectedModel={selectedModel} selectedModelSupportsVision={selectedModelSupportsVision} modelBusy={modelBusy} onSelectModel={onSelectModel} onRescanModels={onRescanModels} onThreadCreated={(id) => navigate(chatPath(id), { replace: true })} onChatChanged={onChatChanged} onForked={(chat) => { onForked(chat); navigate(chatPath(chat.id)); }} onSessionExpired={onSessionExpired} />;
 }
 
 function SettingsRoute({ activeChatId, ...props }: Omit<SettingsPanelProps, "onClose"> & { activeChatId: string | null }) {
diff --git a/frontend/src/features/chat/ChatPage.test.tsx b/frontend/src/features/chat/ChatPage.test.tsx
index 5dd892a..a74e1cd 100644
--- a/frontend/src/features/chat/ChatPage.test.tsx
+++ b/frontend/src/features/chat/ChatPage.test.tsx
@@ -57,6 +57,7 @@ function renderChat(api: CortexApi, threadId = "thread-a", selectedModelSupports
       onThreadCreated={vi.fn()}
       onChatChanged={vi.fn()}
       onForked={vi.fn()}
+      onSessionExpired={vi.fn()}
     />,
   );
 }
@@ -163,6 +164,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
 
@@ -198,6 +200,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
     await waitFor(() => expect(api.chat).toHaveBeenCalledWith("thread-b"));
@@ -215,6 +218,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
     await waitFor(() => expect(api.chat).toHaveBeenCalledTimes(3));
@@ -250,6 +254,7 @@ describe("ChatPage composer integration", () => {
           onThreadCreated={setThreadId}
           onChatChanged={vi.fn()}
           onForked={vi.fn()}
+          onSessionExpired={vi.fn()}
         />
       );
     }
@@ -296,6 +301,7 @@ describe("ChatPage composer integration", () => {
           onThreadCreated={setThreadId}
           onChatChanged={vi.fn()}
           onForked={vi.fn()}
+          onSessionExpired={vi.fn()}
         />
       );
     }
@@ -364,6 +370,7 @@ describe("ChatPage composer integration", () => {
           onThreadCreated={setThreadId}
           onChatChanged={vi.fn()}
           onForked={vi.fn()}
+          onSessionExpired={vi.fn()}
         />
       );
     }
@@ -448,6 +455,8 @@ describe("ChatPage composer integration", () => {
 
     await waitFor(() => expect(details).not.toHaveAttribute("open"));
     expect(screen.queryByText("Live")).not.toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Stop generating" })).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Finishing response" })).toBeDisabled();
   });
 
   it("retains the exact draft if generation acceptance fails", async () => {
@@ -501,6 +510,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
     const composerB = await screen.findByLabelText("Message Cortex");
@@ -521,6 +531,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
     await waitFor(() => {
@@ -555,6 +566,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
 
@@ -563,6 +575,46 @@ describe("ChatPage composer integration", () => {
     expect(screen.getByLabelText("Message Cortex")).toBeEnabled();
   });
 
+  it("does not stay stuck in stopping when cancellation loses to persistence", async () => {
+    const user = userEvent.setup();
+    const cancelGeneration = vi.fn(async () => ({
+      job_id: "job-committing",
+      kind: "generation" as const,
+      status: "running" as const,
+      sequence: 3,
+    }));
+    const api = chatApi({
+      generate: vi.fn().mockResolvedValue({
+        job_id: "job-committing",
+        kind: "generation",
+        status: "queued",
+        thread_id: "thread-a",
+        user_message_id: "message-1",
+      }),
+      cancelGeneration,
+      streamGeneration: vi.fn((_jobId, _onEvent, options: { signal?: AbortSignal } = {}) =>
+        new Promise<void>((_resolve, reject) => {
+          options.signal?.addEventListener(
+            "abort",
+            () => reject(new DOMException("Aborted", "AbortError")),
+            { once: true },
+          );
+        }),
+      ),
+    });
+    renderChat(api);
+
+    await user.type(await screen.findByLabelText("Message Cortex"), "Persist this answer");
+    await user.click(screen.getByRole("button", { name: "Send message" }));
+    await user.click(await screen.findByRole("button", { name: "Stop generating" }));
+
+    await waitFor(() => expect(cancelGeneration).toHaveBeenCalledWith("job-committing"));
+    expect(screen.queryByRole("button", { name: "Stopping response" })).not.toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Stop generating" })).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Finishing response" })).toBeDisabled();
+    expect(screen.getByText("Finishing response...")).toBeVisible();
+  });
+
   it("regenerates from the selected user turn instead of stale cross-chat or composer state", async () => {
     const user = userEvent.setup();
     const originalAttachment: ChatAttachment = {
@@ -632,6 +684,7 @@ describe("ChatPage composer integration", () => {
         onThreadCreated={vi.fn()}
         onChatChanged={vi.fn()}
         onForked={vi.fn()}
+        onSessionExpired={vi.fn()}
       />,
     );
     expect(await screen.findByText("Answer from B")).toBeInTheDocument();
diff --git a/frontend/src/features/chat/ChatPage.tsx b/frontend/src/features/chat/ChatPage.tsx
index 595c132..b07c3ef 100644
--- a/frontend/src/features/chat/ChatPage.tsx
+++ b/frontend/src/features/chat/ChatPage.tsx
@@ -35,6 +35,7 @@ type Props = {
   onThreadCreated: (threadId: string) => void;
   onChatChanged: (chat: ChatResponse) => void;
   onForked: (chat: ChatResponse) => void;
+  onSessionExpired: () => void;
 };
 
 type ScopedError = {
@@ -75,12 +76,13 @@ export function ChatPage({
   onThreadCreated,
   onChatChanged,
   onForked,
+  onSessionExpired,
 }: Props) {
   const generation = useChatStore((state) => state.generation);
   const generationOptionsByThread = useChatStore((state) => state.generationOptionsByThread);
   const setThreadOptions = useChatStore((state) => state.setThreadOptions);
   const generationDefaults = useSettingsStore((state) => state.settings?.generation) ?? DEFAULT_GENERATION_SETTINGS;
-  const { start, consume, stop } = useGenerationStream(api);
+  const { start, consume, stop } = useGenerationStream(api, onSessionExpired);
   const [chat, setChat] = useState<ChatResponse | null>(null);
   const [resolvedThreadId, setResolvedThreadId] = useState<string | null>(threadId);
   const [drafts, setDrafts] = useState<Record<string, string>>(() => ({
@@ -192,7 +194,7 @@ export function ChatPage({
     : generation.phase === "stopping"
       ? "stopping"
       : generation.jobId
-        ? "generating"
+        ? generation.contentReady ? "finishing" : "generating"
         : starting
           ? "starting"
           : "ready";
@@ -396,7 +398,16 @@ export function ChatPage({
     useChatStore.getState().markStopping(jobId);
     useChatStore.getState().setStatusText(jobId, "Stopping response...");
     try {
-      await api.cancelGeneration(jobId);
+      const snapshot = await api.cancelGeneration(jobId);
+      if (snapshot.status !== "cancelling" && snapshot.status !== "cancelled") {
+        // Persistence has already crossed the backend's commit barrier, so a
+        // late stop is intentionally inert. Reflect that response instead of
+        // leaving the composer disabled in a false "Stopping" state while the
+        // durable answer finishes its optional bookkeeping.
+        useChatStore.getState().markContentReady(jobId);
+        useChatStore.getState().revertStopping(jobId);
+        useChatStore.getState().setStatusText(jobId, "Finishing response...");
+      }
     } catch (requestError) {
       useChatStore.getState().revertStopping(jobId);
       setGenerationError({
diff --git a/frontend/src/features/chat/MessageComposer.test.tsx b/frontend/src/features/chat/MessageComposer.test.tsx
index 7005be9..cdedca5 100644
--- a/frontend/src/features/chat/MessageComposer.test.tsx
+++ b/frontend/src/features/chat/MessageComposer.test.tsx
@@ -141,6 +141,19 @@ describe("MessageComposer", () => {
     stop.resolve();
   });
 
+  it("shows non-cancellable finishing work without offering another stop", async () => {
+    const user = userEvent.setup();
+    const onStop = vi.fn();
+    render(<ComposerHarness phase="finishing" onStop={onStop} />);
+
+    expect(screen.getByText("Finishing response…")).toBeVisible();
+    expect(screen.getByRole("button", { name: "Finishing response" })).toBeDisabled();
+    expect(screen.queryByRole("button", { name: "Stop generating" })).not.toBeInTheDocument();
+    await user.click(screen.getByLabelText("Message Cortex"));
+    await user.keyboard("{Escape}");
+    expect(onStop).not.toHaveBeenCalled();
+  });
+
   it("keeps drafting available while the local runtime is unavailable", async () => {
     const user = userEvent.setup();
     render(<ComposerHarness phase="unavailable" />);
diff --git a/frontend/src/features/chat/MessageComposer.tsx b/frontend/src/features/chat/MessageComposer.tsx
index 46a2382..6302a1e 100644
--- a/frontend/src/features/chat/MessageComposer.tsx
+++ b/frontend/src/features/chat/MessageComposer.tsx
@@ -50,7 +50,7 @@ function LlamaRuntimeBadge({ selectedModel }: { selectedModel: string }) {
   );
 }
 
-export type ComposerPhase = "ready" | "starting" | "generating" | "stopping" | "unavailable";
+export type ComposerPhase = "ready" | "starting" | "generating" | "stopping" | "finishing" | "unavailable";
 
 export type MessageComposerProps = {
   value: string;
@@ -134,7 +134,8 @@ export function MessageComposer({
     && !attachmentsBusy
     && !imageInputBlocked;
   const isStopping = phase === "stopping";
-  const isGenerating = phase === "generating" || isStopping;
+  const isFinishing = phase === "finishing";
+  const isGenerating = phase === "generating" || isStopping || isFinishing;
   // Runtime availability gates sending, not workspace configuration. Users
   // must still be able to choose a discovered model while the current model
   // is missing or the local service is reconnecting.
@@ -183,7 +184,7 @@ export function MessageComposer({
   };
 
   const stop = async () => {
-    if (!isGenerating || isStopping || stopPendingRef.current) return;
+    if (!isGenerating || isStopping || isFinishing || stopPendingRef.current) return;
     stopPendingRef.current = true;
     try {
       await onStop();
@@ -229,6 +230,8 @@ export function MessageComposer({
     ? "Starting response…"
     : phase === "stopping"
       ? "Stopping response…"
+      : phase === "finishing"
+        ? "Finishing response…"
       : phase === "generating"
         ? generationElsewhere ? "Generating in another thread" : "Generating…"
         : phase === "unavailable"
@@ -347,12 +350,12 @@ export function MessageComposer({
                 <button
                   className="composer-primary-control composer-stop-control"
                   type="button"
-                  aria-label={isStopping ? "Stopping response" : "Stop generating"}
-                  title={isStopping ? "Stopping response" : "Stop generating"}
-                  disabled={isStopping}
+                  aria-label={isStopping ? "Stopping response" : isFinishing ? "Finishing response" : "Stop generating"}
+                  title={isStopping ? "Stopping response" : isFinishing ? "Finishing response" : "Stop generating"}
+                  disabled={isStopping || isFinishing}
                   onClick={() => void stop()}
                 >
-                  {isStopping ? <LoaderCircle aria-hidden="true" size={17} className="composer-control-spinner" /> : <Square aria-hidden="true" size={15} fill="currentColor" />}
+                  {isStopping || isFinishing ? <LoaderCircle aria-hidden="true" size={17} className="composer-control-spinner" /> : <Square aria-hidden="true" size={15} fill="currentColor" />}
                 </button>
               ) : (
                 <button
diff --git a/frontend/src/hooks/useGenerationStream.test.ts b/frontend/src/hooks/useGenerationStream.test.ts
index 2aa0835..ec42d17 100644
--- a/frontend/src/hooks/useGenerationStream.test.ts
+++ b/frontend/src/hooks/useGenerationStream.test.ts
@@ -32,12 +32,14 @@ function fakeApi(overrides: Partial<CortexApi> = {}): CortexApi {
   } as unknown as CortexApi;
 }
 
+const ignoreSessionExpiry = () => undefined;
+
 describe("useGenerationStream", () => {
   afterEach(() => window.sessionStorage.clear());
 
   it("start() persists the job to sessionStorage and moves the store to starting", () => {
     const api = fakeApi();
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const onCompleted = vi.fn().mockResolvedValue(undefined);
     const onFailed = vi.fn();
 
@@ -59,7 +61,7 @@ describe("useGenerationStream", () => {
         });
       }),
     });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const onCompleted = vi.fn().mockResolvedValue(undefined);
     const onFailed = vi.fn();
 
@@ -87,7 +89,7 @@ describe("useGenerationStream", () => {
         });
       }),
     });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
 
     act(() => {
       result.current.start("job-persist", "thread-persist", vi.fn().mockResolvedValue(undefined), vi.fn());
@@ -117,7 +119,7 @@ describe("useGenerationStream", () => {
         });
       }),
     });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
 
     act(() => {
       result.current.start("job-3", "thread-3", vi.fn().mockResolvedValue(undefined), vi.fn());
@@ -135,7 +137,7 @@ describe("useGenerationStream", () => {
   it("on generation.completed calls onCompleted, clears sessionStorage, and resets the store to idle", async () => {
     const { streamGeneration, emitEvent } = terminalAwareStream();
     const api = fakeApi({ streamGeneration });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const onCompleted = vi.fn().mockResolvedValue(undefined);
 
     act(() => {
@@ -164,7 +166,7 @@ describe("useGenerationStream", () => {
     // resolves.
     const { streamGeneration, emitEvent } = terminalAwareStream();
     const api = fakeApi({ streamGeneration });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
 
     let resolveReload: (() => void) | null = null;
     const onCompleted = vi.fn(() => new Promise<void>((resolve) => { resolveReload = resolve; }));
@@ -193,7 +195,7 @@ describe("useGenerationStream", () => {
   it("on generation.failed calls onFailed with the event message and resets the store", async () => {
     const { streamGeneration, emitEvent } = terminalAwareStream();
     const api = fakeApi({ streamGeneration });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const onFailed = vi.fn();
 
     act(() => {
@@ -214,7 +216,7 @@ describe("useGenerationStream", () => {
       options.signal?.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true });
     }));
     const api = fakeApi({ streamGeneration });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const job = { jobId: "job-6", threadId: "thread-6", lastEventId: 0 };
 
     await act(async () => {
@@ -228,7 +230,7 @@ describe("useGenerationStream", () => {
 
   it("stop() aborts the in-flight stream without treating it as a terminal failure", async () => {
     const api = fakeApi();
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
     const onFailed = vi.fn();
 
     act(() => {
@@ -244,16 +246,43 @@ describe("useGenerationStream", () => {
     expect(onFailed).not.toHaveBeenCalled();
   });
 
-  it("stops without reconnecting when the stream rejects with a 401", async () => {
+  it("clears the tracked generation and expires the session without reconnecting when the stream rejects with a 401", async () => {
     const streamGeneration = vi.fn().mockRejectedValue(new ApiError(401, "Local session expired."));
     const api = fakeApi({ streamGeneration });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const onSessionExpired = vi.fn();
+    const onFailed = vi.fn();
+    const { result } = renderHook(() => useGenerationStream(api, onSessionExpired));
 
-    await act(async () => {
-      await result.current.consume({ jobId: "job-8", threadId: "thread-8", lastEventId: 0 }, vi.fn().mockResolvedValue(undefined), vi.fn());
+    act(() => {
+      result.current.start("job-8", "thread-8", vi.fn().mockResolvedValue(undefined), onFailed);
     });
 
+    await waitFor(() => expect(onSessionExpired).toHaveBeenCalledTimes(1));
     expect(streamGeneration).toHaveBeenCalledTimes(1);
+    expect(api.generationStatus).not.toHaveBeenCalled();
+    expect(onFailed).not.toHaveBeenCalled();
+    expect(readActiveJob()).toBeNull();
+    expect(useChatStore.getState().generation).toMatchObject({ jobId: null, phase: "idle" });
+  });
+
+  it("clears the tracked generation and expires the session when the status fallback rejects with a 401", async () => {
+    const streamGeneration = vi.fn().mockRejectedValue(new Error("connection dropped"));
+    const generationStatus = vi.fn().mockRejectedValue(new ApiError(401, "Local session expired."));
+    const api = fakeApi({ streamGeneration, generationStatus });
+    const onSessionExpired = vi.fn();
+    const onFailed = vi.fn();
+    const { result } = renderHook(() => useGenerationStream(api, onSessionExpired));
+
+    act(() => {
+      result.current.start("job-status-401", "thread-status-401", vi.fn().mockResolvedValue(undefined), onFailed);
+    });
+
+    await waitFor(() => expect(onSessionExpired).toHaveBeenCalledTimes(1));
+    expect(streamGeneration).toHaveBeenCalledTimes(1);
+    expect(generationStatus).toHaveBeenCalledTimes(1);
+    expect(onFailed).not.toHaveBeenCalled();
+    expect(readActiveJob()).toBeNull();
+    expect(useChatStore.getState().generation).toMatchObject({ jobId: null, phase: "idle" });
   });
 
   it("reconnects with the accumulated cursor after a transient (non-401) stream error", async () => {
@@ -268,7 +297,7 @@ describe("useGenerationStream", () => {
       });
     });
     const api = fakeApi({ streamGeneration, generationStatus });
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
 
     act(() => {
       void result.current.consume({ jobId: "job-9", threadId: "thread-9", lastEventId: 0 }, vi.fn().mockResolvedValue(undefined), vi.fn());
@@ -300,7 +329,7 @@ describe("useGenerationStream", () => {
     });
     const api = fakeApi({ streamGeneration, generationStatus });
     const onFailed = vi.fn();
-    const { result } = renderHook(() => useGenerationStream(api));
+    const { result } = renderHook(() => useGenerationStream(api, ignoreSessionExpiry));
 
     act(() => {
       void result.current.consume({ jobId: "job-10", threadId: "thread-10", lastEventId: 0 }, vi.fn().mockResolvedValue(undefined), onFailed);
diff --git a/frontend/src/hooks/useGenerationStream.ts b/frontend/src/hooks/useGenerationStream.ts
index 0993bf1..d42305f 100644
--- a/frontend/src/hooks/useGenerationStream.ts
+++ b/frontend/src/hooks/useGenerationStream.ts
@@ -32,6 +32,7 @@ function delay(milliseconds: number): Promise<void> {
 
 type OnCompleted = (threadId: string) => Promise<void>;
 type OnFailed = (threadId: string, message: string) => void;
+type OnSessionExpired = () => void;
 
 /**
  * Coalesces many rapid push() calls into at most one flush per animation
@@ -77,7 +78,7 @@ function createRafBatchedFlusher(flush: (buffered: string) => void) {
  * Error handling stays with the caller (ChatPage) via onFailed, since it's
  * displayed scoped to whichever thread is currently being viewed.
  */
-export function useGenerationStream(api: CortexApi) {
+export function useGenerationStream(api: CortexApi, onSessionExpired: OnSessionExpired) {
   const consumingRef = useRef<string | null>(null);
   const abortRef = useRef<AbortController | null>(null);
 
@@ -91,6 +92,7 @@ export function useGenerationStream(api: CortexApi) {
       abortRef.current = controller;
       let cursor = job.lastEventId;
       let terminal = false;
+      let sessionExpired = false;
       // Set alongside `terminal`, never awaited until the finally block below
       // -- endGeneration() must not clear the store's jobId (and unmount the
       // pending bubble) before the reload it triggers has actually put the
@@ -147,7 +149,10 @@ export function useGenerationStream(api: CortexApi) {
             }
           } catch (streamError) {
             if (controller.signal.aborted) return;
-            if (streamError instanceof ApiError && streamError.status === 401) return;
+            if (streamError instanceof ApiError && streamError.status === 401) {
+              sessionExpired = true;
+              break;
+            }
             try {
               const snapshot = await api.generationStatus(job.jobId);
               if (snapshot.status === "succeeded" || snapshot.status === "failed" || snapshot.status === "cancelled") {
@@ -170,7 +175,10 @@ export function useGenerationStream(api: CortexApi) {
               // the pending message bubble reporting "Generating" forever
               // with no live connection left to correct it. Treat it like
               // any other dropped connection instead: keep retrying.
-              if (statusError instanceof ApiError && statusError.status === 401) return;
+              if (statusError instanceof ApiError && statusError.status === 401) {
+                sessionExpired = true;
+                break;
+              }
               useChatStore.getState().setStatusText(job.jobId, "Connection interrupted. Reconnecting...");
               await delay(RECONNECT_DELAY_MS);
             }
@@ -185,27 +193,28 @@ export function useGenerationStream(api: CortexApi) {
         // completion/abort is never silently dropped.
         contentFlusher.flushNow();
         thoughtsFlusher.flushNow();
-        if (terminal) {
-          if (completion) {
-            // Wait for the reload that puts the real, persisted message in
-            // the transcript before dropping the store's jobId below --
-            // otherwise the pending bubble unmounts (jobId cleared) a beat
-            // before the real one is ready to take its place, and the
-            // response visibly vanishes for the length of that request
-            // before "popping" back in once it resolves. onCompleted
-            // implementations (reconcileChat) already catch and report
-            // their own failures, so this is just a wait, not error
-            // handling.
-            await completion.catch(() => undefined);
-          }
+        if (terminal && completion) {
+          // Wait for the reload that puts the real, persisted message in
+          // the transcript before dropping the store's jobId below --
+          // otherwise the pending bubble unmounts (jobId cleared) a beat
+          // before the real one is ready to take its place, and the
+          // response visibly vanishes for the length of that request
+          // before "popping" back in once it resolves. onCompleted
+          // implementations (reconcileChat) already catch and report
+          // their own failures, so this is just a wait, not error
+          // handling.
+          await completion.catch(() => undefined);
+        }
+        if (terminal || sessionExpired) {
           const stored = readActiveJob();
           if (stored?.jobId === job.jobId) clearActiveJob();
           useChatStore.getState().endGeneration(job.jobId);
         }
         consumingRef.current = null;
+        if (sessionExpired) onSessionExpired();
       }
     },
-    [api],
+    [api, onSessionExpired],
   );
 
   const start = useCallback(
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index 73d0d53..08814b5 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -1,24 +1,8 @@
-import { copyFileSync, mkdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 
-function syncCortexIcon() {
-  const source = fileURLToPath(new URL("../assets/cortex.svg", import.meta.url));
-  const targetDirectory = fileURLToPath(new URL("./public/", import.meta.url));
-  const target = fileURLToPath(new URL("./public/cortex.svg", import.meta.url));
-
-  return {
-    name: "sync-cortex-icon",
-    buildStart() {
-      mkdirSync(targetDirectory, { recursive: true });
-      copyFileSync(source, target);
-    },
-  };
-}
-
 export default defineConfig({
-  plugins: [syncCortexIcon(), react()],
+  plugins: [react()],
   server: {
     port: Number(process.env.CORTEX_FRONTEND_PORT ?? 5173),
     proxy: {
diff --git a/tests/test_api_contract.py b/tests/test_api_contract.py
index 96d0ee8..90ca83d 100644
--- a/tests/test_api_contract.py
+++ b/tests/test_api_contract.py
@@ -478,3 +478,149 @@ def runner(sink, cancel_event):
             await registry.shutdown()
 
     asyncio.run(exercise())
+
+
+def test_job_registry_commit_barrier_linearizes_cancellation():
+    async def wait_for_event(event: Event):
+        for _ in range(200):
+            if event.is_set():
+                return
+            await asyncio.sleep(0.001)
+        raise AssertionError("worker did not reach its synchronization point")
+
+    async def wait_for_status(
+        registry: JobRegistry, job_id: str, expected: str
+    ):
+        for _ in range(200):
+            snapshot = registry.status(job_id, owner="owner")
+            if snapshot.status == expected:
+                return snapshot
+            await asyncio.sleep(0.001)
+        raise AssertionError(f"job did not reach {expected}")
+
+    async def exercise():
+        registry = JobRegistry(poll_seconds=0.001)
+        before_barrier = Event()
+        release_before_barrier = Event()
+        after_barrier = Event()
+        release_after_barrier = Event()
+        barrier_results: list[bool] = []
+
+        def cancellable_runner(sink, _cancel_event):
+            before_barrier.set()
+            release_before_barrier.wait(timeout=1)
+            barrier_results.append(
+                sink.begin_commit("persisting", "Saving the response.")
+            )
+            return {"persisted": barrier_results[-1]}
+
+        def committed_runner(sink, _cancel_event):
+            barrier_results.append(
+                sink.begin_commit("persisting", "Saving the response.")
+            )
+            after_barrier.set()
+            release_after_barrier.wait(timeout=1)
+            return {"persisted": True}
+
+        try:
+            cancellable = await registry.start(
+                kind="generation",
+                owner="owner",
+                thread_id="thread-before",
+                runner=cancellable_runner,
+            )
+            await wait_for_event(before_barrier)
+            assert registry.cancel(cancellable.job_id, owner="owner").status == "cancelling"
+            release_before_barrier.set()
+            cancelled = await wait_for_status(
+                registry, cancellable.job_id, "cancelled"
+            )
+            assert cancelled.result is None
+            assert barrier_results == [False]
+            cancelled_events = [
+                event
+                async for event in registry.events(cancellable.job_id, owner="owner")
+            ]
+            assert not any(event.phase == "persisting" for event in cancelled_events)
+
+            committed = await registry.start(
+                kind="generation",
+                owner="owner",
+                thread_id="thread-after",
+                runner=committed_runner,
+            )
+            await wait_for_event(after_barrier)
+            too_late = registry.cancel(committed.job_id, owner="owner")
+            assert too_late.status == "running"
+            release_after_barrier.set()
+            succeeded = await wait_for_status(registry, committed.job_id, "succeeded")
+            assert succeeded.result == {"persisted": True}
+            assert barrier_results == [False, True]
+            committed_events = [
+                event
+                async for event in registry.events(committed.job_id, owner="owner")
+            ]
+            assert any(event.phase == "persisting" for event in committed_events)
+            assert not any(event.status == "cancelling" for event in committed_events)
+            assert not any(event.status == "cancelled" for event in committed_events)
+        finally:
+            release_before_barrier.set()
+            release_after_barrier.set()
+            await registry.shutdown()
+
+    asyncio.run(exercise())
+
+
+def test_job_registry_shutdown_cancels_only_before_commit():
+    async def exercise():
+        async def wait_for_event(event: Event):
+            for _ in range(200):
+                if event.is_set():
+                    return
+                await asyncio.sleep(0.001)
+            raise AssertionError("worker did not reach its synchronization point")
+
+        before_registry = JobRegistry(poll_seconds=0.001)
+        before_started = Event()
+
+        def before_runner(_sink, cancel_event):
+            before_started.set()
+            cancel_event.wait(timeout=1)
+            return {"persisted": False}
+
+        before = await before_registry.start(
+            kind="generation",
+            owner="owner",
+            thread_id="thread-before-shutdown",
+            runner=before_runner,
+        )
+        await wait_for_event(before_started)
+        await before_registry.shutdown()
+        assert before_registry.status(before.job_id, owner="owner").status == "cancelled"
+
+        after_registry = JobRegistry(poll_seconds=0.001)
+        after_barrier = Event()
+        release_after_barrier = Event()
+
+        def after_runner(sink, _cancel_event):
+            assert sink.begin_commit("persisting", "Saving the response.")
+            after_barrier.set()
+            release_after_barrier.wait(timeout=1)
+            return {"persisted": True}
+
+        after = await after_registry.start(
+            kind="generation",
+            owner="owner",
+            thread_id="thread-after-shutdown",
+            runner=after_runner,
+        )
+        await wait_for_event(after_barrier)
+        shutdown = asyncio.create_task(after_registry.shutdown())
+        await asyncio.sleep(0.01)
+        assert not shutdown.done()
+        assert after_registry.status(after.job_id, owner="owner").status == "running"
+        release_after_barrier.set()
+        await shutdown
+        assert after_registry.status(after.job_id, owner="owner").status == "succeeded"
+
+    asyncio.run(exercise())
diff --git a/tests/test_launcher.py b/tests/test_launcher.py
index 0a6dba5..9c5caab 100644
--- a/tests/test_launcher.py
+++ b/tests/test_launcher.py
@@ -414,6 +414,16 @@ def test_frontend_manifest_detects_source_changes(tmp_path: Path):
     assert frontend_module.needs_build(root) is True
 
 
+def test_frontend_public_icon_matches_canonical_asset():
+    repository_root = Path(__file__).resolve().parents[1]
+    canonical = repository_root / "assets" / "cortex.svg"
+    frontend_icon = repository_root / "frontend" / "public" / "cortex.svg"
+
+    assert frontend_icon.read_bytes() == canonical.read_bytes(), (
+        "The checked-in web icon is stale; run `npm run icons` from frontend/."
+    )
+
+
 def test_frontend_build_replaces_bundle_atomically_and_records_manifest(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ):
@@ -466,6 +476,38 @@ def fake_run(command: list[str], *, cwd: Path) -> None:
     assert not list(tmp_path.glob(".cortex-frontend-build-*"))
 
 
+def test_frontend_build_manifest_describes_staged_snapshot_during_live_edits(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+):
+    root = _frontend_fixture(tmp_path)
+    staged_lock_digest = frontend_module.lock_digest(root)
+    staged_source_digest = frontend_module.source_digest(root)
+    monkeypatch.setattr(frontend_module, "_major_version", lambda _: 24)
+    monkeypatch.setattr(frontend_module, "_install_if_needed", lambda *_args: None)
+
+    def fake_run(command: list[str], *, cwd: Path) -> None:
+        assert frontend_module.lock_digest(cwd) == staged_lock_digest
+        assert frontend_module.source_digest(cwd) == staged_source_digest
+        (root / "src" / "App.tsx").write_text(
+            "export default { changedDuringBuild: true };",
+            encoding="utf-8",
+        )
+        output = Path(command[-1])
+        output.mkdir(parents=True)
+        (output / "index.html").write_text("staged snapshot", encoding="utf-8")
+
+    monkeypatch.setattr(frontend_module, "_run", fake_run)
+
+    dist = frontend_module.build_frontend(root)
+    manifest = frontend_module.read_manifest(dist)
+
+    assert manifest is not None
+    assert manifest.lock_digest == staged_lock_digest
+    assert manifest.source_digest == staged_source_digest
+    assert frontend_module.needs_build(root) is True
+    assert not list(tmp_path.glob(".cortex-frontend-build-*"))
+
+
 def test_frontend_install_failure_leaves_live_node_modules_untouched(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ):
diff --git a/tests/test_web_chat_parity.py b/tests/test_web_chat_parity.py
index d617d75..63aa8ea 100644
--- a/tests/test_web_chat_parity.py
+++ b/tests/test_web_chat_parity.py
@@ -8,6 +8,7 @@
 
 from fastapi.testclient import TestClient
 
+import cortex_backend.api.routes as api_routes
 from cortex_backend.api import build_demo_dependencies, create_app
 from cortex_backend.testing.fake_ollama import FakeOllamaState, create_fake_ollama_app
 
@@ -180,7 +181,60 @@ def test_failed_generation_keeps_user_turn_without_successful_assistant():
         assert [message["role"] for message in chat["messages"]] == ["user"]
 
 
-def test_cancelled_generation_waits_for_worker_and_skips_response_persistence():
+def test_derived_effect_failures_do_not_invalidate_the_persisted_assistant(
+    monkeypatch,
+):
+    dependencies = build_demo_dependencies()
+    code_observations: list[bool] = []
+    memory_observations: list[bool] = []
+
+    def assistant_exists() -> bool:
+        summaries = dependencies.chats.list_summaries()
+        if not summaries:
+            return False
+        chat = dependencies.chats.get_chat(summaries[0]["id"])
+        return bool(chat and chat["messages"][-1]["role"] == "assistant")
+
+    def fail_code_proposal(*_args, **_kwargs):
+        code_observations.append(assistant_exists())
+        raise RuntimeError("derived code failure")
+
+    def fail_memory(_memo):
+        memory_observations.append(assistant_exists())
+        raise RuntimeError("derived memory failure")
+
+    monkeypatch.setattr(api_routes, "_queue_code_proposal", fail_code_proposal)
+    monkeypatch.setattr(dependencies.memories, "add_memo", fail_memory)
+    app = create_app(dependencies, allowed_hosts=("testserver",))
+
+    with TestClient(app) as client:
+        headers = _session(client, app)
+        accepted = client.post(
+            "/api/v1/generations",
+            json={"request_id": "derived-failure-1", "user_input": "!remember tea"},
+            headers=headers,
+        ).json()
+        with client.stream(
+            "GET",
+            f"/api/v1/generations/{accepted['job_id']}/events",
+            headers=headers,
+        ) as response:
+            events = _events("".join(response.iter_text()))
+
+        assert events[-1]["event"] == "generation.completed"
+        assert code_observations == [True]
+        assert memory_observations == [True]
+        assert dependencies.memories.get_memos() == []
+        chat = client.get(
+            f"/api/v1/chats/{accepted['thread_id']}", headers=headers
+        ).json()
+        assert [message["role"] for message in chat["messages"]] == [
+            "user",
+            "assistant",
+        ]
+
+
+def test_precommit_cancellation_waits_for_worker_and_skips_response_persistence():
     state = FakeOllamaState(
         generation_delay_seconds=0.2,
         title_response="This title must not be persisted",
@@ -233,7 +287,7 @@ def test_cancelled_generation_waits_for_worker_and_skips_response_persistence():
         assert [message["role"] for message in chat["messages"]] == ["user"]
 
 
-def test_cancelling_during_title_generation_does_not_apply_a_late_title():
+def test_cancellation_after_commit_does_not_downgrade_the_persisted_response():
     dependencies = build_demo_dependencies()
     title_started = Event()
     release_title = Event()
@@ -261,7 +315,7 @@ def delayed_title(snapshot, response):
                 headers=headers,
             )
             assert cancelled.status_code == 200
-            assert cancelled.json()["status"] == "cancelling"
+            assert cancelled.json()["status"] == "running"
             blocked = client.post(
                 "/api/v1/generations",
                 json={"thread_id": accepted["thread_id"], "user_input": "must wait"},
@@ -277,12 +331,13 @@ def delayed_title(snapshot, response):
             headers=headers,
         ) as response:
             events = _events("".join(response.iter_text()))
-        assert events[-1]["event"] == "generation.cancelled"
-        assert "generation.completed" not in [event["event"] for event in events]
+        assert events[-1]["event"] == "generation.completed"
+        assert "generation.cancelling" not in [event["event"] for event in events]
+        assert "generation.cancelled" not in [event["event"] for event in events]
         chat = client.get(
             f"/api/v1/chats/{accepted['thread_id']}", headers=headers
         ).json()
-        assert chat["title"] == "New Chat"
+        assert chat["title"] == "Late title"
         assert [message["role"] for message in chat["messages"]] == [
             "user",
             "assistant",