From a26eceba283ce3c02645ab4ef516be4ae2241da8 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:12:14 +0000
Subject: [PATCH 01/18] feat(artifacts): add a status bar to the Agent
 interface status view

Shows the agent's live activity, the last message's delivery state, a
collapsible transcript peek and Start here from the agent's last reply,
above the sandboxed status page.
---
 docs/workspaces/artifacts.mdx                 |   2 +
 .../AgentInterfaceStatusView.test.tsx         | 136 +++++++++-
 .../ArtifactsTab/AgentInterfaceStatusView.tsx | 213 +++++++++++++++-
 .../agentInterfaceStatusBar.test.ts           | 237 ++++++++++++++++++
 .../ArtifactsTab/agentInterfaceStatusBar.ts   | 237 ++++++++++++++++++
 .../stories/App.agentInterface.stories.tsx    | 103 +++++++-
 src/common/constants/storage.ts               |   4 +
 .../builtInSkillContent.generated.ts          |   2 +
 8 files changed, 927 insertions(+), 7 deletions(-)
 create mode 100644 src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
 create mode 100644 src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts

diff --git a/docs/workspaces/artifacts.mdx b/docs/workspaces/artifacts.mdx
index 34be8790ed8..10929bd3350 100644
--- a/docs/workspaces/artifacts.mdx
+++ b/docs/workspaces/artifacts.mdx
@@ -161,6 +161,8 @@ When the workspace has an active goal, Xum keeps `goal.status.html` up to date i
 - When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.
 - On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.
 
+A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript** opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.
+
 ### Status page agent
 
 **Status page agent** is a sub-experiment of Artifacts that needs Agent interface view. Turn both on under the Artifacts row in **Settings > Experiments**: the **Status page agent** row shows there only while Agent interface view is on. When it is on, a separate status page agent keeps `status.html` current, so the main agent spends no time or tokens on the page.
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index b99e3be6d8c..3e9a80a86f1 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -1,13 +1,15 @@
 // Bootstrap Happy DOM before react-dom evaluates (see MemoryTab.test.tsx).
 import "../../../../../tests/ui/dom";
 
-import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, jest, spyOn, test } from "bun:test";
 import { act, cleanup, fireEvent, render, waitFor, within } from "@testing-library/react";
 import { useRef, useState, type ReactNode } from "react";
 import { installDom } from "../../../../../tests/ui/dom";
 import { APIProvider, type APIClient } from "@/browser/contexts/API";
 import { ThemeProvider } from "@/browser/contexts/ThemeContext";
-import { workspaceStore } from "@/browser/stores/WorkspaceStore";
+import * as WorkspaceStoreModule from "@/browser/stores/WorkspaceStore";
+import { workspaceStore, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
+import { overlayWorkspaceStoreRaw } from "@/browser/stores/workspaceStoreTestOverlay";
 import { KEYBINDS } from "@/browser/utils/ui/keybinds";
 import {
   createTestApiClient,
@@ -18,6 +20,7 @@ import {
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
 import { EXPERIMENT_IDS } from "@/common/constants/experiments";
 import type { ArtifactListing, ArtifactReadResult } from "@/common/orpc/schemas/artifacts";
+import type { DisplayedMessage } from "@/common/types/message";
 import { AgentInterfaceStatusView } from "./AgentInterfaceStatusView";
 import { ArtifactsPanel } from "./ArtifactsPanel";
 import { useMainPaneAgentInterfaceView } from "./agentInterfaceView";
@@ -121,6 +124,99 @@ function Wrapper(props: { children: ReactNode }) {
   );
 }
 
+/** Workspace states the status bar reads, for workspaces the real store never registered. */
+const seededStates = new Map<string, WorkspaceState>();
+const restoreSpies: Array<() => void> = [];
+
+function seedWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
+  if (restoreSpies.length === 0) {
+    const realStore = WorkspaceStoreModule.useWorkspaceStoreRaw();
+    const store = overlayWorkspaceStoreRaw(realStore, {
+      hasRegisteredWorkspace: (id: string) =>
+        seededStates.has(id) || realStore.hasRegisteredWorkspace(id),
+      getWorkspaceState: (id: string) => seededStates.get(id) ?? realStore.getWorkspaceState(id),
+    });
+    const storeSpy = spyOn(WorkspaceStoreModule, "useWorkspaceStoreRaw").mockReturnValue(store);
+    // Start Here's transcript barrier: a seeded workspace has a complete replay.
+    const realCaughtUp = workspaceStore.isWorkspaceTranscriptCaughtUp;
+    const barrierSpy = spyOn(workspaceStore, "isWorkspaceTranscriptCaughtUp").mockImplementation(
+      (id: string) => seededStates.has(id) || realCaughtUp(id)
+    );
+    restoreSpies.push(
+      () => storeSpy.mockRestore(),
+      () => barrierSpy.mockRestore()
+    );
+  }
+  seededStates.set(workspaceId, {
+    name: workspaceId,
+    messages: [],
+    queuedMessage: null,
+    heldInputs: [],
+    canInterrupt: false,
+    isCompacting: false,
+    isStreamStarting: false,
+    awaitingUserQuestion: false,
+    loading: false,
+    isTranscriptCaughtUp: true,
+    transcriptReplayFailed: false,
+    isHydratingTranscript: false,
+    isTranscriptStale: false,
+    isIncrementalCatchUp: false,
+    hasOlderHistory: false,
+    loadingOlderHistory: false,
+    muxMessages: [],
+    currentModel: null,
+    currentThinkingLevel: null,
+    recencyTimestamp: null,
+    todos: [],
+    loadedSkills: [],
+    skillLoadErrors: [],
+    agentStatus: undefined,
+    activeWorkflowRunCount: 0,
+    activeBashMonitorCount: 0,
+    lastAbortReason: null,
+    pendingStreamStartTime: null,
+    pendingStreamModel: null,
+    runtimeStatus: null,
+    autoRetryStatus: null,
+    ...patch,
+  });
+}
+
+/** A turn mid-way: the user's prompt, the agent's reply so far, and a bash call still running. */
+const MID_TURN: DisplayedMessage[] = [
+  {
+    type: "user",
+    id: "u1",
+    historyId: "u1",
+    content: "Run the slow check",
+    historySequence: 1,
+    timestamp: Date.now(),
+  },
+  {
+    type: "assistant",
+    id: "a1",
+    historyId: "a1",
+    content: "Starting the check now.",
+    historySequence: 2,
+    isStreaming: false,
+    isPartial: false,
+    isCompacted: false,
+    isIdleCompacted: false,
+  },
+  {
+    type: "tool",
+    id: "t1",
+    historyId: "t1",
+    toolCallId: "call1",
+    toolName: "bash",
+    args: { script: "sleep 20", display_name: "Slow check" },
+    status: "executing",
+    isPartial: false,
+    historySequence: 3,
+  },
+];
+
 /** The main pane's wiring: the poll and shortcut hook, then the status view it selects. */
 function MainPane(props: { workspaceId: string }) {
   const view = useMainPaneAgentInterfaceView(props.workspaceId);
@@ -229,6 +325,8 @@ describe("Agent interface status view", () => {
 
   afterEach(() => {
     cleanup();
+    for (const restore of restoreSpies.splice(0)) restore();
+    seededStates.clear();
     resetTestExperiments();
     cleanupDom?.();
     cleanupDom = null;
@@ -508,4 +606,38 @@ describe("Agent interface status view", () => {
       expect(view.queryByTestId("agent-interface-status-view") === null).toBe(true)
     );
   });
+  test("the status bar names the running tool and its transcript peek opens and closes", async () => {
+    seedWorkspace("ws-bar-busy", { messages: MID_TURN, canInterrupt: true });
+    const view = render(<MainPane workspaceId="ws-bar-busy" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const bar = view.getByTestId("agent-interface-status-bar");
+    expect(within(bar).getByRole("status").textContent).toContain("Slow check");
+    // Start Here would rewrite the context under the running turn.
+    expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
+      true
+    );
+
+    const toggle = within(bar).getByRole("button", { name: "Show transcript" });
+    expect(toggle.getAttribute("aria-expanded")).toBe("false");
+    fireEvent.click(toggle);
+    const peek = view.getByTestId("agent-interface-transcript-peek");
+    expect(toggle.getAttribute("aria-controls")).toBe(peek.id);
+    expect(peek.textContent).toContain("Run the slow check");
+    expect(peek.textContent).toContain("Starting the check now.");
+    fireEvent.click(within(bar).getByRole("button", { name: "Hide transcript" }));
+    expect(view.queryByTestId("agent-interface-transcript-peek")).toBeNull();
+  });
+
+  test("Start here from the status bar opens the Start Here confirmation once the turn ends", async () => {
+    seedWorkspace("ws-bar-idle", { messages: MID_TURN.slice(0, 2) });
+    const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const startHere = within(view.getByTestId("agent-interface-status-bar")).getByRole("button", {
+      name: "Start here",
+    });
+    expect(startHere.hasAttribute("disabled")).toBe(false);
+    fireEvent.click(startHere);
+    const dialog = await within(document.body).findByRole("dialog");
+    expect(within(dialog).getByText("Start Here")).toBeTruthy();
+  });
 });
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 9f6a6b62b50..e07e1e62065 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -1,9 +1,25 @@
-import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
+import { CircleAlert, CircleDot, ListStart, Loader2 } from "lucide-react";
+import { TooltipIfPresent } from "@/browser/components/Tooltip/Tooltip";
 import { useAPI } from "@/browser/contexts/API";
+import { usePersistedState } from "@/browser/hooks/usePersistedState";
+import { useStartHere } from "@/browser/hooks/useStartHere";
+import { useWorkspaceStoreRaw, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
+import { formatRelativeTime } from "@/browser/utils/ui/dateTime";
+import { AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY } from "@/common/constants/storage";
+import { cn } from "@/common/lib/utils";
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
 import type { ArtifactReadResult } from "@/common/orpc/schemas/artifacts";
 import type { ChatInputAPI } from "@/browser/features/ChatInput/types";
 import { useUserPreferences } from "@/browser/stores/AppConfigStore";
+import {
+  deriveLastMessageReceipt,
+  deriveStatusActivity,
+  findStartHereSource,
+  recentTranscriptRows,
+  type LastMessageReceiptState,
+  type StatusActivity,
+} from "./agentInterfaceStatusBar";
 import {
   readStatusPage,
   recordStatusPageRead,
@@ -140,6 +156,198 @@ function askBeforeEverySend(
   return { ...handlers, requestSend: (text, data) => handlers.requestSend(text, data, "ask") };
 }
 
+/** How many transcript rows the peek lists. */
+const TRANSCRIPT_PEEK_ROWS = 8;
+
+const RECEIPT_CHIPS: Record<LastMessageReceiptState, { label: string; className: string }> = {
+  queued: { label: "Queued", className: "text-pending" },
+  held: { label: "Held, not sent", className: "text-error" },
+  sending: { label: "Sending…", className: "text-muted" },
+  "in-transcript": { label: "In transcript", className: "text-success" },
+};
+
+/**
+ * The workspace's state, or null while the store has not registered it (tests, teardown):
+ * the bar then shows nothing instead of throwing.
+ */
+function useRegisteredWorkspaceState(workspaceId: string): WorkspaceState | null {
+  const store = useWorkspaceStoreRaw();
+  return useSyncExternalStore(
+    (listener) => store.subscribeKey(workspaceId, listener),
+    () => (store.hasRegisteredWorkspace(workspaceId) ? store.getWorkspaceState(workspaceId) : null)
+  );
+}
+
+function ActivityIcon(props: { activity: StatusActivity }) {
+  const className = "h-3.5 w-3.5 shrink-0";
+  switch (props.activity.kind) {
+    case "idle":
+      return <CircleDot aria-hidden="true" className={cn(className, "text-muted")} />;
+    case "error":
+      return <CircleAlert aria-hidden="true" className={cn(className, "text-error")} />;
+    default:
+      return <Loader2 aria-hidden="true" className={cn(className, "text-muted animate-spin")} />;
+  }
+}
+
+/**
+ * The host's bar above the Agent interface status page: what the agent does right now, where the
+ * user's last message is, a peek at the transcript the page covers, and Start Here from the
+ * agent's last reply. A leaf that subscribes to the workspace itself, so stream deltas re-render
+ * only the bar, not the page's frame.
+ */
+function AgentInterfaceStatusBar(props: { workspaceId: string }) {
+  const state = useRegisteredWorkspaceState(props.workspaceId);
+  if (state == null) return null;
+  return <StatusBar workspaceId={props.workspaceId} state={state} />;
+}
+
+function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
+  const { state } = props;
+  const panelId = useId();
+  const [peekOpen, setPeekOpen] = usePersistedState(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, false);
+
+  const activity = deriveStatusActivity(state.messages, {
+    canInterrupt: state.canInterrupt,
+    isStreamStarting: state.isStreamStarting,
+    isCompacting: state.isCompacting,
+    awaitingUserQuestion: state.awaitingUserQuestion,
+    runtimeDetail: state.runtimeStatus?.detail,
+  });
+  const receipt = deriveLastMessageReceipt(state.messages, state.queuedMessage, state.heldInputs);
+  const source = findStartHereSource(state.messages);
+  const turnActive = state.canInterrupt || state.isStreamStarting || state.isCompacting;
+
+  // No eligible reply counts as compacted, which keeps the hook's modal from opening.
+  const startHere = useStartHere(props.workspaceId, source?.content ?? "", source == null, {
+    // Preserve legacy plan/exec markers so Start Here keeps plan→exec handoff for old history.
+    sourceAgentId: source?.agentId ?? source?.mode,
+  });
+  const startHereDisabled = startHere.disabled || turnActive;
+
+  return (
+    <>
+      <div
+        data-testid="agent-interface-status-bar"
+        className="border-border-light bg-surface-secondary shrink-0 border-b text-[11px]"
+      >
+        <div className="flex flex-wrap items-center gap-x-3 gap-y-1 px-3 py-1">
+          <div
+            role="status"
+            aria-live="polite"
+            data-testid="agent-interface-status-activity"
+            className="flex min-w-0 flex-[1_1_12rem] items-center gap-1.5"
+          >
+            <ActivityIcon activity={activity} />
+            <span className="min-w-0 truncate">
+              <span className="text-foreground font-medium">{activity.label}</span>
+              {activity.detail != null && (
+                <span className="text-muted">
+                  {" · "}
+                  {activity.detail}
+                </span>
+              )}
+            </span>
+          </div>
+          <div className="flex shrink-0 items-center gap-1">
+            <button
+              type="button"
+              aria-expanded={peekOpen}
+              aria-controls={panelId}
+              onClick={() => setPeekOpen(!peekOpen)}
+              className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent h-6 rounded px-1.5 focus-visible:ring-1"
+            >
+              {peekOpen ? "Hide transcript" : "Show transcript"}
+            </button>
+            <TooltipIfPresent
+              tooltip="Start a new context from the agent's last reply and keep earlier history"
+              side="bottom"
+              align="end"
+            >
+              <button
+                type="button"
+                disabled={startHereDisabled}
+                onClick={startHere.openModal}
+                className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex h-6 items-center gap-1 rounded px-1.5 focus-visible:ring-1 disabled:pointer-events-none disabled:opacity-50"
+              >
+                <ListStart aria-hidden="true" className="h-3.5 w-3.5 shrink-0" />
+                Start here
+              </button>
+            </TooltipIfPresent>
+          </div>
+        </div>
+        {receipt != null && (
+          <div
+            data-testid="agent-interface-status-receipt"
+            className="flex min-w-0 items-center gap-2 px-3 pb-1"
+          >
+            <span className="text-muted shrink-0">Last message</span>
+            <span className="min-w-0 flex-1 truncate">{receipt.preview}</span>
+            <span className={cn("shrink-0 font-medium", RECEIPT_CHIPS[receipt.state].className)}>
+              {RECEIPT_CHIPS[receipt.state].label}
+              {receipt.state === "in-transcript" && receipt.timestamp != null && (
+                <span className="text-muted counter-nums font-normal">
+                  {" · "}
+                  {formatRelativeTime(receipt.timestamp)}
+                </span>
+              )}
+            </span>
+          </div>
+        )}
+      </div>
+      {peekOpen && <TranscriptPeek id={panelId} messages={state.messages} />}
+      {startHere.modal}
+    </>
+  );
+}
+
+/**
+ * The transcript's newest rows, one line each. A sibling of the bar in the status section, so
+ * its 40% cap resolves against the section and the page keeps the rest. column-reverse anchors
+ * the scroll at the bottom: it follows new rows while the user is at the bottom, with no effect.
+ */
+function TranscriptPeek(props: { id: string; messages: WorkspaceState["messages"] }) {
+  const rows = recentTranscriptRows(props.messages, TRANSCRIPT_PEEK_ROWS);
+  return (
+    <div
+      id={props.id}
+      role="region"
+      aria-label="Recent transcript"
+      data-testid="agent-interface-transcript-peek"
+      className="border-border-light flex max-h-[40%] shrink-0 flex-col-reverse overflow-y-auto border-b text-[11px]"
+    >
+      {rows.length === 0 ? (
+        <div className="text-muted px-3 py-1.5">No messages yet</div>
+      ) : (
+        <ol className="flex flex-col py-1">
+          {rows.map((row) =>
+            row.kind === "boundary" ? (
+              <li
+                key={row.id}
+                className="text-muted flex items-center gap-2 px-3 py-0.5 before:h-px before:flex-1 before:bg-border-light after:h-px after:flex-1 after:bg-border-light"
+              >
+                {row.label}
+              </li>
+            ) : (
+              <li key={row.id} className="grid grid-cols-[auto_minmax(0,1fr)] gap-2 px-3 py-0.5">
+                <span
+                  className={cn(
+                    "max-w-[12rem] truncate font-medium",
+                    row.kind === "error" ? "text-error" : "text-muted"
+                  )}
+                >
+                  {row.label}
+                </span>
+                <span className="truncate">{row.preview}</span>
+              </li>
+            )
+          )}
+        </ol>
+      )}
+    </div>
+  );
+}
+
 function StatusPage(props: StatusViewProps) {
   const { workspaceId } = props;
   const read = useStatusArtifactRead(workspaceId);
@@ -168,6 +376,9 @@ function StatusPage(props: StatusViewProps) {
         interactions.handleKeyDown(e);
       }}
     >
+      {/* Host-rendered, outside the sandboxed page: live activity, the last send's state, a
+          transcript peek and Start Here, which the page covering the transcript would hide. */}
+      <AgentInterfaceStatusBar workspaceId={workspaceId} />
       {interactions.strip}
       <div className="min-h-0 flex-1 overflow-auto">
         {read == null ? (
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
new file mode 100644
index 00000000000..4873ec6b2f7
--- /dev/null
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -0,0 +1,237 @@
+import { describe, expect, test } from "bun:test";
+import type { HeldInput } from "@/common/orpc/types";
+import type { DisplayedMessage, DisplayedUserMessage } from "@/common/types/message";
+import {
+  deriveLastMessageReceipt,
+  deriveStatusActivity,
+  findStartHereSource,
+  recentTranscriptRows,
+  type StatusActivityFlags,
+} from "./agentInterfaceStatusBar";
+
+let sequence = 0;
+
+function user(content: string, extra: Partial<DisplayedUserMessage> = {}): DisplayedMessage {
+  sequence += 1;
+  return {
+    type: "user",
+    id: `u${sequence}`,
+    historyId: `u${sequence}`,
+    content,
+    historySequence: sequence,
+    ...extra,
+  };
+}
+
+type DisplayedAssistant = Extract<DisplayedMessage, { type: "assistant" }>;
+
+function assistant(content: string, extra: Partial<DisplayedAssistant> = {}): DisplayedAssistant {
+  sequence += 1;
+  return {
+    type: "assistant",
+    id: `a${sequence}`,
+    historyId: `a${sequence}`,
+    content,
+    historySequence: sequence,
+    isStreaming: false,
+    isPartial: false,
+    isCompacted: false,
+    isIdleCompacted: false,
+    ...extra,
+  };
+}
+
+function reasoning(isStreaming: boolean): DisplayedMessage {
+  sequence += 1;
+  return {
+    type: "reasoning",
+    id: `r${sequence}`,
+    historyId: `r${sequence}`,
+    content: "pondering",
+    historySequence: sequence,
+    isStreaming,
+    isPartial: false,
+  };
+}
+
+function tool(
+  toolName: string,
+  status: Extract<DisplayedMessage, { type: "tool" }>["status"],
+  args: unknown = {}
+): DisplayedMessage {
+  sequence += 1;
+  return {
+    type: "tool",
+    id: `t${sequence}`,
+    historyId: `t${sequence}`,
+    toolCallId: `call${sequence}`,
+    toolName,
+    args,
+    status,
+    isPartial: false,
+    historySequence: sequence,
+  };
+}
+
+const streaming: StatusActivityFlags = {
+  canInterrupt: true,
+  isStreamStarting: false,
+  isCompacting: false,
+  awaitingUserQuestion: false,
+};
+const idle: StatusActivityFlags = { ...streaming, canInterrupt: false };
+
+describe("deriveStatusActivity", () => {
+  test("a turn that is starting reports starting, with the runtime's breadcrumb when present", () => {
+    const flags = { ...streaming, isStreamStarting: true };
+    expect(deriveStatusActivity([tool("bash", "executing")], flags).kind).toBe("starting");
+    expect(
+      deriveStatusActivity([], { ...flags, runtimeDetail: "Waking the workspace" }).label
+    ).toBe("Waking the workspace");
+  });
+
+  test("a running tool beats streaming reasoning, which beats reply text", () => {
+    const running = tool("bash", "executing", { display_name: "Run tests" });
+    const turn = [user("go"), reasoning(true), running, assistant("so far", { isStreaming: true })];
+    expect(deriveStatusActivity(turn, streaming)).toMatchObject({
+      kind: "tool",
+      detail: "Run tests",
+    });
+
+    const thinking = [user("go"), reasoning(true), assistant("so far", { isStreaming: true })];
+    expect(deriveStatusActivity(thinking, streaming).kind).toBe("thinking");
+
+    const writing = [user("go"), reasoning(false), assistant("so far", { isStreaming: true })];
+    expect(deriveStatusActivity(writing, streaming).kind).toBe("writing");
+  });
+
+  test("a parallel call still running counts after a newer call completed", () => {
+    const turn = [
+      user("go"),
+      tool("file_read", "executing", { path: "src/a.ts" }),
+      tool("file_read", "completed", { path: "src/b.ts" }),
+    ];
+    expect(deriveStatusActivity(turn, streaming).detail).toBe("src/a.ts");
+  });
+
+  test("a tool still marked executing in an earlier turn does not count for the current one", () => {
+    const messages = [user("first"), tool("bash", "executing"), user("second")];
+    expect(deriveStatusActivity(messages, streaming).kind).toBe("working");
+  });
+
+  test("not streaming is idle, or stopped when the newest row is a stream error", () => {
+    expect(deriveStatusActivity([user("go"), assistant("done")], idle).kind).toBe("idle");
+    const errored: DisplayedMessage = {
+      type: "stream-error",
+      id: "e1",
+      historyId: "e1",
+      error: "overloaded",
+      errorType: "unknown",
+      historySequence: 99,
+    };
+    expect(deriveStatusActivity([user("go"), errored], idle).kind).toBe("error");
+  });
+});
+
+describe("deriveLastMessageReceipt", () => {
+  const held: HeldInput = {
+    id: "h1",
+    reason: "reported",
+    displayText: "held text",
+    attachmentCount: 0,
+    reviewCount: 0,
+  };
+
+  test("a queued message wins over held inputs and the newest transcript row", () => {
+    const receipt = deriveLastMessageReceipt(
+      [user("in history")],
+      { id: "q1", content: "queued text" },
+      [held]
+    );
+    expect(receipt).toMatchObject({ state: "queued", preview: "queued text" });
+  });
+
+  test("held inputs win over the newest transcript row", () => {
+    expect(deriveLastMessageReceipt([user("in history")], null, [held])).toMatchObject({
+      state: "held",
+      preview: "held text",
+    });
+  });
+
+  test("the newest human row is sending until it is backed by history", () => {
+    expect(
+      deriveLastMessageReceipt([user("first", { isPendingSend: true })], null, [])?.state
+    ).toBe("sending");
+    expect(deriveLastMessageReceipt([user("landed", { timestamp: 5 })], null, [])).toMatchObject({
+      state: "in-transcript",
+      preview: "landed",
+      timestamp: 5,
+    });
+  });
+
+  test("machine-authored user rows are not the user's last message", () => {
+    const messages = [
+      user("mine"),
+      user("continue the goal", { isSynthetic: true, isGoalContinuation: true }),
+      user("monitor fired", { bashMonitorWake: { records: [] } }),
+      user("peer says hi", { agentPeerMessageTrigger: true }),
+      user("context is filling up", {
+        contextBudgetWarning: { contextTokens: 1, maxTokens: 2, final: false, handoff: false },
+      }),
+    ];
+    expect(deriveLastMessageReceipt(messages, null, [])?.preview).toBe("mine");
+    expect(deriveLastMessageReceipt(messages.slice(1), null, [])).toBeNull();
+  });
+});
+
+describe("recentTranscriptRows", () => {
+  test("keeps the newest rows oldest first, skipping rows with nothing to read", () => {
+    const messages: DisplayedMessage[] = [
+      user("old"),
+      { type: "history-hidden", id: "hh", hiddenCount: 3, historySequence: 0 },
+      assistant("reply"),
+      {
+        type: "compaction-boundary",
+        id: "cb",
+        historySequence: 50,
+        position: "start",
+      },
+      tool("bash", "executing", { display_name: "Sleep" }),
+    ];
+    const rows = recentTranscriptRows(messages, 3);
+    expect(rows.map((row) => row.kind)).toEqual(["assistant", "boundary", "tool"]);
+    expect(rows.at(-1)?.preview).toBe("Sleep");
+    expect(recentTranscriptRows(messages, 10).map((row) => row.kind)).toEqual([
+      "user",
+      "assistant",
+      "boundary",
+      "tool",
+    ]);
+  });
+});
+
+describe("findStartHereSource", () => {
+  test("picks the newest settled reply, skipping streaming, empty and peer rows", () => {
+    const settled = assistant("the plan");
+    const messages = [
+      user("go"),
+      settled,
+      assistant("", {}),
+      assistant("from a peer", {
+        agentPeerMessage: { fromWorkspaceId: "w2", relationship: "descendant" },
+      }),
+      assistant("still typing", { isStreaming: true }),
+    ];
+    expect(findStartHereSource(messages)).toBe(settled);
+  });
+
+  test("offers nothing once the newest reply is compacted or before the latest boundary", () => {
+    expect(findStartHereSource([assistant("summary", { isCompacted: true })])).toBeNull();
+    expect(
+      findStartHereSource([
+        assistant("old reply", { isBeforeLatestContextBoundary: true }),
+        user("after the reset"),
+      ])
+    ).toBeNull();
+  });
+});
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
new file mode 100644
index 00000000000..3f0132969b0
--- /dev/null
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -0,0 +1,237 @@
+import type { HeldInput } from "@/common/orpc/types";
+import type { DisplayedMessage, DisplayedUserMessage, QueuedMessage } from "@/common/types/message";
+
+/** The longest preview kept per line; the bar truncates visually well before this. */
+const PREVIEW_MAX_CHARS = 160;
+
+/** Tool argument fields that name what a call works on, in order of preference. */
+const TOOL_DETAIL_KEYS = ["display_name", "title", "path", "file_path"] as const;
+
+/** Collapses a text to one plain line, cut at PREVIEW_MAX_CHARS. */
+function oneLine(text: string): string {
+  const line = text.replace(/\s+/g, " ").trim();
+  return line.length > PREVIEW_MAX_CHARS ? `${line.slice(0, PREVIEW_MAX_CHARS - 1)}…` : line;
+}
+
+/** A short plain-text name for what a tool call works on (bash display_name, file path, task title). */
+export function toolCallDetail(args: unknown): string | undefined {
+  if (args == null || typeof args !== "object") return undefined;
+  for (const key of TOOL_DETAIL_KEYS) {
+    const value: unknown = Reflect.get(args, key);
+    if (typeof value === "string" && value.trim() !== "") return oneLine(value);
+  }
+  return undefined;
+}
+
+export type StatusActivityKind =
+  | "starting"
+  | "compacting"
+  | "question"
+  | "tool"
+  | "thinking"
+  | "writing"
+  | "working"
+  | "idle"
+  | "error";
+
+export interface StatusActivity {
+  kind: StatusActivityKind;
+  label: string;
+  detail?: string;
+}
+
+export interface StatusActivityFlags {
+  canInterrupt: boolean;
+  isStreamStarting: boolean;
+  isCompacting: boolean;
+  awaitingUserQuestion: boolean;
+  /** The backend's startup breadcrumb (runtime readiness, tool loading), as StreamingBarrier shows it. */
+  runtimeDetail?: string | null;
+}
+
+/**
+ * What the agent is doing right now. While a turn streams, the current turn's rows (after the
+ * last user row) decide: a running tool call beats streaming reasoning, which beats reply text,
+ * so a turn that runs parallel tools keeps naming a tool while one still runs.
+ */
+export function deriveStatusActivity(
+  messages: readonly DisplayedMessage[],
+  flags: StatusActivityFlags
+): StatusActivity {
+  if (flags.isStreamStarting) {
+    return { kind: "starting", label: flags.runtimeDetail ?? "Starting…" };
+  }
+  if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
+  if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
+  if (!flags.canInterrupt) {
+    return messages.at(-1)?.type === "stream-error"
+      ? { kind: "error", label: "Stopped with an error" }
+      : { kind: "idle", label: "Idle" };
+  }
+
+  let thinking = false;
+  let writing = false;
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.type === "user") break;
+    if (
+      message.type === "tool" &&
+      (message.status === "pending" || message.status === "executing")
+    ) {
+      return {
+        kind: "tool",
+        label: `Running ${message.toolName}`,
+        detail: toolCallDetail(message.args),
+      };
+    }
+    if (message.type === "reasoning" && message.isStreaming) thinking = true;
+    if (message.type === "assistant" && message.isStreaming) writing = true;
+  }
+  if (thinking) return { kind: "thinking", label: "Thinking…" };
+  if (writing) return { kind: "writing", label: "Writing a reply…" };
+  return { kind: "working", label: "Working…" };
+}
+
+/** A user row the human typed, not a machine turn (wakes, continuations, peer triggers, warnings). */
+export function isHumanUserMessage(message: DisplayedMessage): message is DisplayedUserMessage {
+  return (
+    message.type === "user" &&
+    message.isSynthetic !== true &&
+    message.isGoalContinuation !== true &&
+    message.isBudgetLimitWrapup !== true &&
+    message.bashMonitorWake == null &&
+    message.agentPeerMessageTrigger == null &&
+    message.contextBudgetWarning == null
+  );
+}
+
+export type LastMessageReceiptState = "queued" | "held" | "sending" | "in-transcript";
+
+export interface LastMessageReceipt {
+  state: LastMessageReceiptState;
+  preview: string;
+  /** When the row landed in the transcript, for "in-transcript" rows that carry one. */
+  timestamp?: number;
+}
+
+function previewOrPlaceholder(text: string): string {
+  return oneLine(text) || "(no text)";
+}
+
+/**
+ * Where the user's latest message is. A queued or held message is always newer than every
+ * transcript row (neither is in history yet), so it wins over the newest human row.
+ */
+export function deriveLastMessageReceipt(
+  messages: readonly DisplayedMessage[],
+  queuedMessage: QueuedMessage | null,
+  heldInputs: readonly HeldInput[]
+): LastMessageReceipt | null {
+  if (queuedMessage != null) {
+    return { state: "queued", preview: previewOrPlaceholder(queuedMessage.content) };
+  }
+  const held = heldInputs.at(-1);
+  if (held != null) return { state: "held", preview: previewOrPlaceholder(held.displayText) };
+  const latest = messages.findLast(isHumanUserMessage);
+  if (latest == null) return null;
+  if (latest.isPendingSend === true) {
+    return { state: "sending", preview: previewOrPlaceholder(latest.content) };
+  }
+  return {
+    state: "in-transcript",
+    preview: previewOrPlaceholder(latest.content),
+    timestamp: latest.timestamp,
+  };
+}
+
+export type RecentTranscriptRowKind =
+  | "user"
+  | "assistant"
+  | "tool"
+  | "reasoning"
+  | "error"
+  | "plan"
+  | "boundary";
+
+export interface RecentTranscriptRow {
+  id: string;
+  kind: RecentTranscriptRowKind;
+  label: string;
+  preview: string;
+}
+
+function transcriptRow(message: DisplayedMessage): RecentTranscriptRow | null {
+  switch (message.type) {
+    case "user":
+      return {
+        id: message.id,
+        kind: "user",
+        // Machine-authored user rows (wakes, continuations) are Xum's, not the user's.
+        label: isHumanUserMessage(message) ? "You" : "Xum",
+        preview: oneLine(message.content),
+      };
+    case "assistant":
+      return {
+        id: message.id,
+        kind: "assistant",
+        label: "Agent",
+        preview: oneLine(message.content),
+      };
+    case "tool":
+      return {
+        id: message.id,
+        kind: "tool",
+        label: `${message.toolName} (${message.status})`,
+        preview: toolCallDetail(message.args) ?? "",
+      };
+    case "reasoning":
+      return {
+        id: message.id,
+        kind: "reasoning",
+        label: "Thinking",
+        preview: oneLine(message.content),
+      };
+    case "stream-error":
+      return { id: message.id, kind: "error", label: "Error", preview: oneLine(message.error) };
+    case "plan-display":
+      return { id: message.id, kind: "plan", label: "Plan", preview: oneLine(message.content) };
+    case "compaction-boundary":
+      return { id: message.id, kind: "boundary", label: "Context reset", preview: "" };
+    case "history-hidden":
+    case "workspace-init":
+      return null;
+  }
+}
+
+/** The newest `limit` transcript rows worth a line in the peek, oldest first. */
+export function recentTranscriptRows(
+  messages: readonly DisplayedMessage[],
+  limit: number
+): RecentTranscriptRow[] {
+  const rows: RecentTranscriptRow[] = [];
+  for (let index = messages.length - 1; index >= 0 && rows.length < limit; index--) {
+    const row = transcriptRow(messages[index]);
+    if (row != null) rows.push(row);
+  }
+  return rows.reverse();
+}
+
+/**
+ * The agent's last reply that Start Here can start from: the newest settled assistant row with
+ * text in the active context, the same rows AssistantMessage offers Start Here on. Peer message
+ * payloads are another agent's words, not this agent's reply.
+ */
+export function findStartHereSource(
+  messages: readonly DisplayedMessage[]
+): Extract<DisplayedMessage, { type: "assistant" }> | null {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message.type !== "assistant") continue;
+    if (message.isStreaming || message.agentPeerMessage != null) continue;
+    if (message.content.trim() === "") continue;
+    // Rows only get older from here: a compacted or pre-boundary row means no eligible reply.
+    if (message.isCompacted || message.isBeforeLatestContextBoundary === true) return null;
+    return message;
+  }
+  return null;
+}
diff --git a/src/browser/stories/App.agentInterface.stories.tsx b/src/browser/stories/App.agentInterface.stories.tsx
index f33f30618c8..d2295c1a73d 100644
--- a/src/browser/stories/App.agentInterface.stories.tsx
+++ b/src/browser/stories/App.agentInterface.stories.tsx
@@ -2,19 +2,25 @@
  * Agent interface view (artifacts-agent-interface): a workspace with a status page shows the
  * Status / Chat toggle in the menu bar. TouchToggle is play-only; on Chromium the test-runner
  * (.storybook/test-runner.ts) emulates a touch phone and checks the toggle's tap targets, because
- * Pixel and plays cannot emulate a coarse pointer.
+ * Pixel and plays cannot emulate a coarse pointer. StatusBarMidTurn and its phone variant show the
+ * host's status bar above the page during a turn that runs a tool, with the transcript peek open.
  */
 import { expect, waitFor, within } from "storybook/test";
 
 import { updatePersistedState } from "@/browser/hooks/usePersistedState";
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
 import { EXPERIMENT_IDS } from "@/common/constants/experiments";
-import { LEFT_SIDEBAR_COLLAPSED_KEY } from "@/common/constants/storage";
+import {
+  AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY,
+  LEFT_SIDEBAR_COLLAPSED_KEY,
+} from "@/common/constants/storage";
 import type { ArtifactReadResult } from "@/common/orpc/schemas/artifacts";
+import type { WorkspaceChatMessage } from "@/common/orpc/types";
 
 import { setupSimpleChatStory } from "./helpers/chatSetup";
 import { appMeta, AppWithMocks, PIXEL_DISABLED, type AppStory } from "./meta.js";
 import { createAssistantMessage, createUserMessage } from "./mocks/messages";
+import { STABLE_TIMESTAMP } from "./storyTime";
 
 export default {
   ...appMeta,
@@ -33,9 +39,14 @@ const STATUS_PAGE: ArtifactReadResult = {
   content: STATUS_HTML,
 };
 
-function setup() {
+function setup(
+  options: {
+    workspaceId?: string;
+    onChat?: (workspaceId: string, emit: (message: WorkspaceChatMessage) => void) => void;
+  } = {}
+) {
   const client = setupSimpleChatStory({
-    workspaceId: "ws-agent-interface",
+    workspaceId: options.workspaceId ?? "ws-agent-interface",
     workspaceName: "release",
     projectName: "xum",
     experiments: {
@@ -48,6 +59,7 @@ function setup() {
         historySequence: 2,
       }),
     ],
+    onChat: options.onChat,
   });
   // A collapsed left sidebar drops the header's left padding, so on a phone the actions row,
   // which the toggle starts, reaches the screen edge.
@@ -107,3 +119,86 @@ export const TouchToggle: AppStory = {
     );
   },
 };
+
+/** A turn in progress after the history replays: reply text so far, then a bash call still running. */
+function setupMidTurn(workspaceId: string) {
+  // The transcript peek opens from its persisted choice, as after a reload.
+  updatePersistedState(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, true);
+  return setup({
+    workspaceId,
+    onChat: (chatWorkspaceId, emit) => {
+      if (chatWorkspaceId !== workspaceId) return;
+      // After the static history and its caught-up (also a 50 ms timer, queued first).
+      setTimeout(() => {
+        const messageId = "a2-streaming";
+        emit({
+          type: "stream-start",
+          workspaceId,
+          messageId,
+          model: "anthropic:claude-sonnet-4-5",
+          historySequence: 3,
+          startTime: STABLE_TIMESTAMP,
+        });
+        emit({
+          type: "stream-delta",
+          workspaceId,
+          messageId,
+          delta: "Checking the canary's error rate before the next step.",
+          tokens: 10,
+          timestamp: STABLE_TIMESTAMP,
+        });
+        emit({
+          type: "tool-call-start",
+          workspaceId,
+          messageId,
+          toolCallId: "call-canary-check",
+          toolName: "bash",
+          args: { script: "sleep 20", display_name: "Canary error rate", timeout_secs: 30 },
+          tokens: 5,
+          timestamp: STABLE_TIMESTAMP,
+        });
+      }, 50);
+    },
+  });
+}
+
+async function waitForRunningTool(canvasElement: HTMLElement) {
+  await waitFor(
+    () => {
+      const activity = canvasElement.querySelector(
+        '[data-testid="agent-interface-status-activity"]'
+      );
+      if (!activity?.textContent?.includes("Canary error rate")) {
+        throw new Error("Status bar does not name the running tool yet");
+      }
+      if (canvasElement.querySelector('[data-testid="agent-interface-transcript-peek"]') == null) {
+        throw new Error("Transcript peek missing");
+      }
+    },
+    { timeout: 10000 }
+  );
+}
+
+export const StatusBarMidTurn: AppStory = {
+  render: () => <AppWithMocks setup={() => setupMidTurn("ws-agent-interface-mid-turn")} />,
+  parameters: {
+    ...appMeta.parameters,
+    pixel: { matrix: { themes: ["dark", "light"], viewports: ["laptop"] } },
+  },
+  play: async ({ canvasElement }) => {
+    await waitForRunningTool(canvasElement);
+  },
+};
+
+/** The same bar at phone width: the rows wrap and truncate instead of overflowing. */
+export const StatusBarMidTurnPhone: AppStory = {
+  globals: { viewport: { value: "mobile1", isRotated: false } },
+  render: () => <AppWithMocks setup={() => setupMidTurn("ws-agent-interface-mid-turn-phone")} />,
+  parameters: {
+    ...appMeta.parameters,
+    pixel: { matrix: { themes: ["dark"], viewports: ["phone"] } },
+  },
+  play: async ({ canvasElement }) => {
+    await waitForRunningTool(canvasElement);
+  },
+};
diff --git a/src/common/constants/storage.ts b/src/common/constants/storage.ts
index 53176691154..bfcea83e99f 100644
--- a/src/common/constants/storage.ts
+++ b/src/common/constants/storage.ts
@@ -611,6 +611,9 @@ export const AGENT_INTERFACE_VIEW_KEY = "artifacts:agentInterfaceView";
 export const AGENT_INTERFACE_VIEW_MAX_WORKSPACES = 64;
 export const AGENT_INTERFACE_VIEW_MAX_CHARS = 4096;
 
+/** Whether the Agent interface status bar's transcript peek is open (boolean, all workspaces). */
+export const AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY = "artifacts:agentInterfaceTranscriptPeek";
+
 /**
  * Get the localStorage key for terminal titles per workspace.
  * Maps sessionId -> title for persisting OSC-set terminal titles.
@@ -907,6 +910,7 @@ export const PERSISTED_KEY_REGISTRY: readonly PersistedKeyRegistration[] = [
   globalKey(ONBOARDING_VIEWED_KEY, "cache", 8),
   globalKey(ARTIFACTS_SELECTION_KEY, "ui", ARTIFACTS_SELECTION_MAX_CHARS),
   globalKey(AGENT_INTERFACE_VIEW_KEY, "ui", AGENT_INTERFACE_VIEW_MAX_CHARS),
+  globalKey(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, "ui", 8),
   globalKey(LAST_CUSTOM_MODEL_PROVIDER_KEY, "ui", 128),
   // { workspaceId } (older builds also stored paths; readers use only the id).
   globalKey(SELECTED_WORKSPACE_KEY, "ui", 256),
diff --git a/src/node/services/agentSkills/builtInSkillContent.generated.ts b/src/node/services/agentSkills/builtInSkillContent.generated.ts
index b16f95fe2ee..41b62e73259 100644
--- a/src/node/services/agentSkills/builtInSkillContent.generated.ts
+++ b/src/node/services/agentSkills/builtInSkillContent.generated.ts
@@ -10525,6 +10525,8 @@ export const BUILTIN_SKILL_FILES: Record<string, Record<string, string>> = {
       "- When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.",
       "- On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.",
       "",
+      "A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript** opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.",
+      "",
       "### Status page agent",
       "",
       "**Status page agent** is a sub-experiment of Artifacts that needs Agent interface view. Turn both on under the Artifacts row in **Settings > Experiments**: the **Status page agent** row shows there only while Agent interface view is on. When it is on, a separate status page agent keeps `status.html` current, so the main agent spends no time or tokens on the page.",

From 42f0f4723f51b5111b52077717d3e2efb26e52b3 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:16:39 +0000
Subject: [PATCH 02/18] fix(artifacts): satisfy lint in the status bar and its
 tests

---
 .../ArtifactsTab/AgentInterfaceStatusView.test.tsx           | 5 ++++-
 .../RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx   | 2 +-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index 3e9a80a86f1..44eb3d5acca 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -124,13 +124,16 @@ function Wrapper(props: { children: ReactNode }) {
   );
 }
 
+/** The real store getter, captured before any spy (not a hook: it only returns the singleton). */
+const readRealWorkspaceStore = WorkspaceStoreModule.useWorkspaceStoreRaw;
+
 /** Workspace states the status bar reads, for workspaces the real store never registered. */
 const seededStates = new Map<string, WorkspaceState>();
 const restoreSpies: Array<() => void> = [];
 
 function seedWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
   if (restoreSpies.length === 0) {
-    const realStore = WorkspaceStoreModule.useWorkspaceStoreRaw();
+    const realStore = readRealWorkspaceStore();
     const store = overlayWorkspaceStoreRaw(realStore, {
       hasRegisteredWorkspace: (id: string) =>
         seededStates.has(id) || realStore.hasRegisteredWorkspace(id),
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index e07e1e62065..18fbf3ecee7 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -324,7 +324,7 @@ function TranscriptPeek(props: { id: string; messages: WorkspaceState["messages"
             row.kind === "boundary" ? (
               <li
                 key={row.id}
-                className="text-muted flex items-center gap-2 px-3 py-0.5 before:h-px before:flex-1 before:bg-border-light after:h-px after:flex-1 after:bg-border-light"
+                className="text-muted before:bg-border-light after:bg-border-light flex items-center gap-2 px-3 py-0.5 before:h-px before:flex-1 after:h-px after:flex-1"
               >
                 {row.label}
               </li>

From 41c98c8c5ac5e94e30c7f3a2647a66c4a38b486e Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:18:13 +0000
Subject: [PATCH 03/18] refactor(artifacts): split the status bar into smaller
 parts

---
 .../ArtifactsTab/AgentInterfaceStatusView.tsx | 147 +++++++++-------
 .../ArtifactsTab/agentInterfaceStatusBar.ts   | 166 ++++++++++--------
 2 files changed, 184 insertions(+), 129 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 18fbf3ecee7..65631038dd9 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -16,7 +16,9 @@ import {
   deriveLastMessageReceipt,
   deriveStatusActivity,
   findStartHereSource,
+  isTurnActive,
   recentTranscriptRows,
+  type LastMessageReceipt,
   type LastMessageReceiptState,
   type StatusActivity,
 } from "./agentInterfaceStatusBar";
@@ -206,7 +208,6 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
   const { state } = props;
   const panelId = useId();
   const [peekOpen, setPeekOpen] = usePersistedState(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, false);
-
   const activity = deriveStatusActivity(state.messages, {
     canInterrupt: state.canInterrupt,
     isStreamStarting: state.isStreamStarting,
@@ -215,15 +216,6 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
     runtimeDetail: state.runtimeStatus?.detail,
   });
   const receipt = deriveLastMessageReceipt(state.messages, state.queuedMessage, state.heldInputs);
-  const source = findStartHereSource(state.messages);
-  const turnActive = state.canInterrupt || state.isStreamStarting || state.isCompacting;
-
-  // No eligible reply counts as compacted, which keeps the hook's modal from opening.
-  const startHere = useStartHere(props.workspaceId, source?.content ?? "", source == null, {
-    // Preserve legacy plan/exec markers so Start Here keeps plan→exec handoff for old history.
-    sourceAgentId: source?.agentId ?? source?.mode,
-  });
-  const startHereDisabled = startHere.disabled || turnActive;
 
   return (
     <>
@@ -232,23 +224,7 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
         className="border-border-light bg-surface-secondary shrink-0 border-b text-[11px]"
       >
         <div className="flex flex-wrap items-center gap-x-3 gap-y-1 px-3 py-1">
-          <div
-            role="status"
-            aria-live="polite"
-            data-testid="agent-interface-status-activity"
-            className="flex min-w-0 flex-[1_1_12rem] items-center gap-1.5"
-          >
-            <ActivityIcon activity={activity} />
-            <span className="min-w-0 truncate">
-              <span className="text-foreground font-medium">{activity.label}</span>
-              {activity.detail != null && (
-                <span className="text-muted">
-                  {" · "}
-                  {activity.detail}
-                </span>
-              )}
-            </span>
-          </div>
+          <ActivityLine activity={activity} />
           <div className="flex shrink-0 items-center gap-1">
             <button
               type="button"
@@ -259,48 +235,99 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
             >
               {peekOpen ? "Hide transcript" : "Show transcript"}
             </button>
-            <TooltipIfPresent
-              tooltip="Start a new context from the agent's last reply and keep earlier history"
-              side="bottom"
-              align="end"
-            >
-              <button
-                type="button"
-                disabled={startHereDisabled}
-                onClick={startHere.openModal}
-                className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex h-6 items-center gap-1 rounded px-1.5 focus-visible:ring-1 disabled:pointer-events-none disabled:opacity-50"
-              >
-                <ListStart aria-hidden="true" className="h-3.5 w-3.5 shrink-0" />
-                Start here
-              </button>
-            </TooltipIfPresent>
+            <StartHereButton
+              workspaceId={props.workspaceId}
+              messages={state.messages}
+              turnActive={isTurnActive(activity)}
+            />
           </div>
         </div>
-        {receipt != null && (
-          <div
-            data-testid="agent-interface-status-receipt"
-            className="flex min-w-0 items-center gap-2 px-3 pb-1"
-          >
-            <span className="text-muted shrink-0">Last message</span>
-            <span className="min-w-0 flex-1 truncate">{receipt.preview}</span>
-            <span className={cn("shrink-0 font-medium", RECEIPT_CHIPS[receipt.state].className)}>
-              {RECEIPT_CHIPS[receipt.state].label}
-              {receipt.state === "in-transcript" && receipt.timestamp != null && (
-                <span className="text-muted counter-nums font-normal">
-                  {" · "}
-                  {formatRelativeTime(receipt.timestamp)}
-                </span>
-              )}
-            </span>
-          </div>
-        )}
+        {receipt != null && <ReceiptRow receipt={receipt} />}
       </div>
       {peekOpen && <TranscriptPeek id={panelId} messages={state.messages} />}
+    </>
+  );
+}
+
+function ActivityLine(props: { activity: StatusActivity }) {
+  return (
+    <div
+      role="status"
+      aria-live="polite"
+      data-testid="agent-interface-status-activity"
+      className="flex min-w-0 flex-[1_1_12rem] items-center gap-1.5"
+    >
+      <ActivityIcon activity={props.activity} />
+      <span className="min-w-0 truncate">
+        <span className="text-foreground font-medium">{props.activity.label}</span>
+        {props.activity.detail != null && (
+          <span className="text-muted">
+            {" · "}
+            {props.activity.detail}
+          </span>
+        )}
+      </span>
+    </div>
+  );
+}
+
+/** Start Here from the agent's last reply, as on the reply in the chat; off while a turn runs. */
+function StartHereButton(props: {
+  workspaceId: string;
+  messages: WorkspaceState["messages"];
+  turnActive: boolean;
+}) {
+  const source = findStartHereSource(props.messages);
+  // No eligible reply counts as compacted, which keeps the hook's modal from opening.
+  const startHere = useStartHere(props.workspaceId, source?.content ?? "", source == null, {
+    // Preserve legacy plan/exec markers so Start Here keeps plan→exec handoff for old history.
+    sourceAgentId: source?.agentId ?? source?.mode,
+  });
+  return (
+    <>
+      <TooltipIfPresent
+        tooltip="Start a new context from the agent's last reply and keep earlier history"
+        side="bottom"
+        align="end"
+      >
+        <button
+          type="button"
+          disabled={startHere.disabled || props.turnActive}
+          onClick={startHere.openModal}
+          className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex h-6 items-center gap-1 rounded px-1.5 focus-visible:ring-1 disabled:pointer-events-none disabled:opacity-50"
+        >
+          <ListStart aria-hidden="true" className="h-3.5 w-3.5 shrink-0" />
+          Start here
+        </button>
+      </TooltipIfPresent>
       {startHere.modal}
     </>
   );
 }
 
+function ReceiptRow(props: { receipt: LastMessageReceipt }) {
+  const { receipt } = props;
+  const chip = RECEIPT_CHIPS[receipt.state];
+  return (
+    <div
+      data-testid="agent-interface-status-receipt"
+      className="flex min-w-0 items-center gap-2 px-3 pb-1"
+    >
+      <span className="text-muted shrink-0">Last message</span>
+      <span className="min-w-0 flex-1 truncate">{receipt.preview}</span>
+      <span className={cn("shrink-0 font-medium", chip.className)}>
+        {chip.label}
+        {receipt.state === "in-transcript" && receipt.timestamp != null && (
+          <span className="text-muted counter-nums font-normal">
+            {" · "}
+            {formatRelativeTime(receipt.timestamp)}
+          </span>
+        )}
+      </span>
+    </div>
+  );
+}
+
 /**
  * The transcript's newest rows, one line each. A sibling of the bar in the status section, so
  * its 40% cap resolves against the section and the page keeps the rest. column-reverse anchors
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index 3f0132969b0..b0da9f9aaa3 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -49,11 +49,39 @@ export interface StatusActivityFlags {
   runtimeDetail?: string | null;
 }
 
+type DisplayedTool = Extract<DisplayedMessage, { type: "tool" }>;
+
+function isRunningTool(message: DisplayedMessage): message is DisplayedTool {
+  return (
+    message.type === "tool" && (message.status === "pending" || message.status === "executing")
+  );
+}
+
+function isStreamingRow(message: DisplayedMessage, type: "reasoning" | "assistant"): boolean {
+  return message.type === type && message.isStreaming;
+}
+
 /**
- * What the agent is doing right now. While a turn streams, the current turn's rows (after the
- * last user row) decide: a running tool call beats streaming reasoning, which beats reply text,
- * so a turn that runs parallel tools keeps naming a tool while one still runs.
+ * The streaming turn's rows (after the last user row) decide: a running tool call beats
+ * streaming reasoning, which beats reply text, so a turn that runs parallel tools keeps naming a
+ * tool while one still runs.
  */
+function streamingActivity(messages: readonly DisplayedMessage[]): StatusActivity {
+  const turn = messages.slice(messages.findLastIndex((message) => message.type === "user") + 1);
+  const tool = turn.findLast(isRunningTool);
+  if (tool != null) {
+    return { kind: "tool", label: `Running ${tool.toolName}`, detail: toolCallDetail(tool.args) };
+  }
+  if (turn.some((message) => isStreamingRow(message, "reasoning"))) {
+    return { kind: "thinking", label: "Thinking…" };
+  }
+  if (turn.some((message) => isStreamingRow(message, "assistant"))) {
+    return { kind: "writing", label: "Writing a reply…" };
+  }
+  return { kind: "working", label: "Working…" };
+}
+
+/** What the agent is doing right now. */
 export function deriveStatusActivity(
   messages: readonly DisplayedMessage[],
   flags: StatusActivityFlags
@@ -63,33 +91,15 @@ export function deriveStatusActivity(
   }
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
-  if (!flags.canInterrupt) {
-    return messages.at(-1)?.type === "stream-error"
-      ? { kind: "error", label: "Stopped with an error" }
-      : { kind: "idle", label: "Idle" };
-  }
+  if (flags.canInterrupt) return streamingActivity(messages);
+  return messages.at(-1)?.type === "stream-error"
+    ? { kind: "error", label: "Stopped with an error" }
+    : { kind: "idle", label: "Idle" };
+}
 
-  let thinking = false;
-  let writing = false;
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const message = messages[index];
-    if (message.type === "user") break;
-    if (
-      message.type === "tool" &&
-      (message.status === "pending" || message.status === "executing")
-    ) {
-      return {
-        kind: "tool",
-        label: `Running ${message.toolName}`,
-        detail: toolCallDetail(message.args),
-      };
-    }
-    if (message.type === "reasoning" && message.isStreaming) thinking = true;
-    if (message.type === "assistant" && message.isStreaming) writing = true;
-  }
-  if (thinking) return { kind: "thinking", label: "Thinking…" };
-  if (writing) return { kind: "writing", label: "Writing a reply…" };
-  return { kind: "working", label: "Working…" };
+/** Whether a turn is still running: every activity but idle and a stopped stream. */
+export function isTurnActive(activity: StatusActivity): boolean {
+  return activity.kind !== "idle" && activity.kind !== "error";
 }
 
 /** A user row the human typed, not a machine turn (wakes, continuations, peer triggers, warnings). */
@@ -160,47 +170,65 @@ export interface RecentTranscriptRow {
   preview: string;
 }
 
+type RowBuilders = {
+  [Type in DisplayedMessage["type"]]: (
+    message: Extract<DisplayedMessage, { type: Type }>
+  ) => RecentTranscriptRow | null;
+};
+
+/** One line per row type; rows with nothing to read (hidden counts, init logs) get none. */
+const ROW_BUILDERS: RowBuilders = {
+  user: (message) => ({
+    id: message.id,
+    kind: "user",
+    // Machine-authored user rows (wakes, continuations) are Xum's, not the user's.
+    label: isHumanUserMessage(message) ? "You" : "Xum",
+    preview: oneLine(message.content),
+  }),
+  assistant: (message) => ({
+    id: message.id,
+    kind: "assistant",
+    label: "Agent",
+    preview: oneLine(message.content),
+  }),
+  tool: (message) => ({
+    id: message.id,
+    kind: "tool",
+    label: `${message.toolName} (${message.status})`,
+    preview: toolCallDetail(message.args) ?? "",
+  }),
+  reasoning: (message) => ({
+    id: message.id,
+    kind: "reasoning",
+    label: "Thinking",
+    preview: oneLine(message.content),
+  }),
+  "stream-error": (message) => ({
+    id: message.id,
+    kind: "error",
+    label: "Error",
+    preview: oneLine(message.error),
+  }),
+  "plan-display": (message) => ({
+    id: message.id,
+    kind: "plan",
+    label: "Plan",
+    preview: oneLine(message.content),
+  }),
+  "compaction-boundary": (message) => ({
+    id: message.id,
+    kind: "boundary",
+    label: "Context reset",
+    preview: "",
+  }),
+  "history-hidden": () => null,
+  "workspace-init": () => null,
+};
+
 function transcriptRow(message: DisplayedMessage): RecentTranscriptRow | null {
-  switch (message.type) {
-    case "user":
-      return {
-        id: message.id,
-        kind: "user",
-        // Machine-authored user rows (wakes, continuations) are Xum's, not the user's.
-        label: isHumanUserMessage(message) ? "You" : "Xum",
-        preview: oneLine(message.content),
-      };
-    case "assistant":
-      return {
-        id: message.id,
-        kind: "assistant",
-        label: "Agent",
-        preview: oneLine(message.content),
-      };
-    case "tool":
-      return {
-        id: message.id,
-        kind: "tool",
-        label: `${message.toolName} (${message.status})`,
-        preview: toolCallDetail(message.args) ?? "",
-      };
-    case "reasoning":
-      return {
-        id: message.id,
-        kind: "reasoning",
-        label: "Thinking",
-        preview: oneLine(message.content),
-      };
-    case "stream-error":
-      return { id: message.id, kind: "error", label: "Error", preview: oneLine(message.error) };
-    case "plan-display":
-      return { id: message.id, kind: "plan", label: "Plan", preview: oneLine(message.content) };
-    case "compaction-boundary":
-      return { id: message.id, kind: "boundary", label: "Context reset", preview: "" };
-    case "history-hidden":
-    case "workspace-init":
-      return null;
-  }
+  // TypeScript cannot pair a union-keyed builder with its own variant; the mapped type does.
+  const build = ROW_BUILDERS[message.type] as (row: DisplayedMessage) => RecentTranscriptRow | null;
+  return build(message);
 }
 
 /** The newest `limit` transcript rows worth a line in the peek, oldest first. */

From 85a5c3f8237dc7a438f9c630b6018874a880740c Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:20:46 +0000
Subject: [PATCH 04/18] test(artifacts): cover the status bar's receipt, empty
 state and previews

---
 .../AgentInterfaceStatusView.test.tsx         | 29 ++++++++++--
 .../agentInterfaceStatusBar.test.ts           | 47 ++++++++++++++++---
 .../ArtifactsTab/agentInterfaceStatusBar.ts   |  1 +
 3 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index 44eb3d5acca..5c76e34f64d 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -610,11 +610,20 @@ describe("Agent interface status view", () => {
     );
   });
   test("the status bar names the running tool and its transcript peek opens and closes", async () => {
-    seedWorkspace("ws-bar-busy", { messages: MID_TURN, canInterrupt: true });
+    seedWorkspace("ws-bar-busy", {
+      messages: MID_TURN,
+      canInterrupt: true,
+      queuedMessage: { id: "q1", content: "Then roll to 50%" },
+    });
     const view = render(<MainPane workspaceId="ws-bar-busy" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
     const bar = view.getByTestId("agent-interface-status-bar");
     expect(within(bar).getByRole("status").textContent).toContain("Slow check");
+    // The send made during the turn is the user's last message, still waiting in the queue.
+    const receipt = within(bar).getByTestId("agent-interface-status-receipt");
+    expect(receipt.textContent).toContain("Then roll to 50%");
+    expect(receipt.textContent).toContain("Queued");
+    expect(receipt.textContent).not.toMatch(/ago|just now/);
     // Start Here would rewrite the context under the running turn.
     expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
       true
@@ -635,12 +644,24 @@ describe("Agent interface status view", () => {
     seedWorkspace("ws-bar-idle", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
-    const startHere = within(view.getByTestId("agent-interface-status-bar")).getByRole("button", {
-      name: "Start here",
-    });
+    const bar = view.getByTestId("agent-interface-status-bar");
+    expect(within(bar).getByTestId("agent-interface-status-receipt").textContent).toContain(
+      "In transcript · just now"
+    );
+    const startHere = within(bar).getByRole("button", { name: "Start here" });
     expect(startHere.hasAttribute("disabled")).toBe(false);
     fireEvent.click(startHere);
     const dialog = await within(document.body).findByRole("dialog");
     expect(within(dialog).getByText("Start Here")).toBeTruthy();
   });
+  test("before the first message the bar shows no receipt and Start here stays off", async () => {
+    seedWorkspace("ws-bar-empty", {});
+    const view = render(<MainPane workspaceId="ws-bar-empty" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const bar = view.getByTestId("agent-interface-status-bar");
+    expect(within(bar).queryByTestId("agent-interface-status-receipt")).toBeNull();
+    expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
+      true
+    );
+  });
 });
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index 4873ec6b2f7..b6599f74a1c 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -5,6 +5,7 @@ import {
   deriveLastMessageReceipt,
   deriveStatusActivity,
   findStartHereSource,
+  isTurnActive,
   recentTranscriptRows,
   type StatusActivityFlags,
 } from "./agentInterfaceStatusBar";
@@ -120,7 +121,7 @@ describe("deriveStatusActivity", () => {
   });
 
   test("not streaming is idle, or stopped when the newest row is a stream error", () => {
-    expect(deriveStatusActivity([user("go"), assistant("done")], idle).kind).toBe("idle");
+    expect(deriveStatusActivity([], idle).kind).toBe("idle");
     const errored: DisplayedMessage = {
       type: "stream-error",
       id: "e1",
@@ -129,7 +130,25 @@ describe("deriveStatusActivity", () => {
       errorType: "unknown",
       historySequence: 99,
     };
-    expect(deriveStatusActivity([user("go"), errored], idle).kind).toBe("error");
+    expect(deriveStatusActivity([user("go"), assistant("partial"), errored], idle).kind).toBe(
+      "error"
+    );
+    // A retry that answered after the error leaves the turn settled, not stopped.
+    expect(deriveStatusActivity([user("go"), errored, assistant("done")], idle).kind).toBe("idle");
+  });
+
+  test("a turn counts as running in every phase but idle and a stopped stream", () => {
+    const phases: Array<[StatusActivityFlags, DisplayedMessage[], boolean]> = [
+      [{ ...idle, isStreamStarting: true }, [], true],
+      [{ ...streaming, isCompacting: true }, [], true],
+      [{ ...streaming, awaitingUserQuestion: true }, [], true],
+      [streaming, [user("go"), tool("bash", "executing")], true],
+      [idle, [user("go"), assistant("done")], false],
+    ];
+    for (const [flags, messages, active] of phases) {
+      expect(isTurnActive(deriveStatusActivity(messages, flags))).toBe(active);
+    }
+    expect(isTurnActive({ kind: "error", label: "Stopped" })).toBe(false);
   });
 });
 
@@ -151,10 +170,11 @@ describe("deriveLastMessageReceipt", () => {
     expect(receipt).toMatchObject({ state: "queued", preview: "queued text" });
   });
 
-  test("held inputs win over the newest transcript row", () => {
-    expect(deriveLastMessageReceipt([user("in history")], null, [held])).toMatchObject({
+  test("held inputs win over the newest transcript row, the newest held input first", () => {
+    const newer: HeldInput = { ...held, id: "h2", displayText: "newer held text" };
+    expect(deriveLastMessageReceipt([user("in history")], null, [held, newer])).toMatchObject({
       state: "held",
-      preview: "held text",
+      preview: "newer held text",
     });
   });
 
@@ -172,7 +192,9 @@ describe("deriveLastMessageReceipt", () => {
   test("machine-authored user rows are not the user's last message", () => {
     const messages = [
       user("mine"),
-      user("continue the goal", { isSynthetic: true, isGoalContinuation: true }),
+      user("synthetic row", { isSynthetic: true }),
+      user("continue the goal", { isGoalContinuation: true }),
+      user("wrap up the goal", { isBudgetLimitWrapup: true }),
       user("monitor fired", { bashMonitorWake: { records: [] } }),
       user("peer says hi", { agentPeerMessageTrigger: true }),
       user("context is filling up", {
@@ -208,6 +230,18 @@ describe("recentTranscriptRows", () => {
       "tool",
     ]);
   });
+
+  test("previews are one bounded line, and malformed tool arguments show none", () => {
+    const long = `First line\n\n${"word ".repeat(100)}`;
+    const [row] = recentTranscriptRows([user(long)], 1);
+    expect(row.preview.startsWith("First line word")).toBe(true);
+    expect(row.preview).not.toContain("\n");
+    expect(row.preview.length).toBeLessThan(long.length);
+    expect(row.preview.length).toBeLessThanOrEqual(160);
+    expect(recentTranscriptRows([tool("bash", "executing", "not an object")], 1)[0].preview).toBe(
+      ""
+    );
+  });
 });
 
 describe("findStartHereSource", () => {
@@ -223,6 +257,7 @@ describe("findStartHereSource", () => {
       assistant("still typing", { isStreaming: true }),
     ];
     expect(findStartHereSource(messages)).toBe(settled);
+    expect(findStartHereSource([settled])).toBe(settled);
   });
 
   test("offers nothing once the newest reply is compacted or before the latest boundary", () => {
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index b0da9f9aaa3..ae5b2e2977f 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -67,6 +67,7 @@ function isStreamingRow(message: DisplayedMessage, type: "reasoning" | "assistan
  * tool while one still runs.
  */
 function streamingActivity(messages: readonly DisplayedMessage[]): StatusActivity {
+  // mutation-equivalent: the user row itself is neither a tool nor a streaming row
   const turn = messages.slice(messages.findLastIndex((message) => message.type === "user") + 1);
   const tool = turn.findLast(isRunningTool);
   if (tool != null) {

From 0cd7f73e1b6a62ca9e65a65067244c9b21c3a3ae Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:22:23 +0000
Subject: [PATCH 05/18] test(artifacts): close status bar mutation gaps

---
 .../ArtifactsTab/AgentInterfaceStatusView.test.tsx        | 4 ++++
 .../ArtifactsTab/AgentInterfaceStatusView.tsx             | 2 ++
 .../ArtifactsTab/agentInterfaceStatusBar.test.ts          | 8 ++++++--
 .../RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts  | 3 ++-
 4 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index 5c76e34f64d..eb2e3b52b2c 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -660,6 +660,10 @@ describe("Agent interface status view", () => {
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
     const bar = view.getByTestId("agent-interface-status-bar");
     expect(within(bar).queryByTestId("agent-interface-status-receipt")).toBeNull();
+    fireEvent.click(within(bar).getByRole("button", { name: "Show transcript" }));
+    expect(view.getByTestId("agent-interface-transcript-peek").textContent).toContain(
+      "No messages yet"
+    );
     expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
       true
     );
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 65631038dd9..4944e9b0b4a 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -279,8 +279,10 @@ function StartHereButton(props: {
 }) {
   const source = findStartHereSource(props.messages);
   // No eligible reply counts as compacted, which keeps the hook's modal from opening.
+  // mutation-equivalent: an eligible reply always has text, so ?? and || agree
   const startHere = useStartHere(props.workspaceId, source?.content ?? "", source == null, {
     // Preserve legacy plan/exec markers so Start Here keeps plan→exec handoff for old history.
+    // mutation-equivalent: agent ids are never empty strings, so ?? and || agree
     sourceAgentId: source?.agentId ?? source?.mode,
   });
   return (
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index b6599f74a1c..0b2633bbdb1 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -89,6 +89,7 @@ describe("deriveStatusActivity", () => {
     expect(
       deriveStatusActivity([], { ...flags, runtimeDetail: "Waking the workspace" }).label
     ).toBe("Waking the workspace");
+    expect(deriveStatusActivity([], { ...flags, runtimeDetail: "" }).label).not.toBe("");
   });
 
   test("a running tool beats streaming reasoning, which beats reply text", () => {
@@ -171,8 +172,11 @@ describe("deriveLastMessageReceipt", () => {
   });
 
   test("held inputs win over the newest transcript row, the newest held input first", () => {
-    const newer: HeldInput = { ...held, id: "h2", displayText: "newer held text" };
-    expect(deriveLastMessageReceipt([user("in history")], null, [held, newer])).toMatchObject({
+    const middle: HeldInput = { ...held, id: "h2", displayText: "middle held text" };
+    const newer: HeldInput = { ...held, id: "h3", displayText: "newer held text" };
+    expect(
+      deriveLastMessageReceipt([user("in history")], null, [held, middle, newer])
+    ).toMatchObject({
       state: "held",
       preview: "newer held text",
     });
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index ae5b2e2977f..00be9079c8d 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -88,7 +88,8 @@ export function deriveStatusActivity(
   flags: StatusActivityFlags
 ): StatusActivity {
   if (flags.isStreamStarting) {
-    return { kind: "starting", label: flags.runtimeDetail ?? "Starting…" };
+    // || so an empty breadcrumb cannot blank the line.
+    return { kind: "starting", label: flags.runtimeDetail || "Starting…" };
   }
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };

From 122168c960a735396ae0325adc713294b2ad07bb Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 00:30:53 +0000
Subject: [PATCH 06/18] fix(artifacts): keep ?? for the startup breadcrumb, as
 the lint rule asks

---
 .../RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts  | 1 -
 .../RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts       | 3 +--
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index 0b2633bbdb1..f0770419233 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -89,7 +89,6 @@ describe("deriveStatusActivity", () => {
     expect(
       deriveStatusActivity([], { ...flags, runtimeDetail: "Waking the workspace" }).label
     ).toBe("Waking the workspace");
-    expect(deriveStatusActivity([], { ...flags, runtimeDetail: "" }).label).not.toBe("");
   });
 
   test("a running tool beats streaming reasoning, which beats reply text", () => {
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index 00be9079c8d..ae5b2e2977f 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -88,8 +88,7 @@ export function deriveStatusActivity(
   flags: StatusActivityFlags
 ): StatusActivity {
   if (flags.isStreamStarting) {
-    // || so an empty breadcrumb cannot blank the line.
-    return { kind: "starting", label: flags.runtimeDetail || "Starting…" };
+    return { kind: "starting", label: flags.runtimeDetail ?? "Starting…" };
   }
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };

From 098f477675af24323000ff69c796518e61fc22f2 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:34:24 +0000
Subject: [PATCH 07/18] chore(artifacts): drop a status bar comment its
 docstring already covers

---
 .../RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx      | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 4944e9b0b4a..150867d0ab5 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -405,8 +405,6 @@ function StatusPage(props: StatusViewProps) {
         interactions.handleKeyDown(e);
       }}
     >
-      {/* Host-rendered, outside the sandboxed page: live activity, the last send's state, a
-          transcript peek and Start Here, which the page covering the transcript would hide. */}
       <AgentInterfaceStatusBar workspaceId={workspaceId} />
       {interactions.strip}
       <div className="min-h-0 flex-1 overflow-auto">

From 5195e3c86fced1b5cd77657760dd96b0a2829f13 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 01:52:48 +0000
Subject: [PATCH 08/18] test(artifacts): cover compacting and question phases
 over a running tool

---
 .../ArtifactsTab/agentInterfaceStatusBar.test.ts       | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index f0770419233..b2f1e5c64f6 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -91,6 +91,16 @@ describe("deriveStatusActivity", () => {
     ).toBe("Waking the workspace");
   });
 
+  test("compacting and a pending question name their phase over the turn's running tool", () => {
+    const turn = [user("go"), tool("ask_user_question", "executing")];
+    expect(deriveStatusActivity(turn, { ...streaming, isCompacting: true }).kind).toBe(
+      "compacting"
+    );
+    expect(deriveStatusActivity(turn, { ...streaming, awaitingUserQuestion: true }).kind).toBe(
+      "question"
+    );
+  });
+
   test("a running tool beats streaming reasoning, which beats reply text", () => {
     const running = tool("bash", "executing", { display_name: "Run tests" });
     const turn = [user("go"), reasoning(true), running, assistant("so far", { isStreaming: true })];

From b96a26890cf2ff2bb06e710b8164c78b74c32d4b Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:07:25 +0000
Subject: [PATCH 09/18] fix(artifacts): show the receipt's clock time and drop
 a dangling aria-controls

UAT round 1 minors: the relative time read "just now" for good while the
workspace was idle (nothing re-renders the bar), and the transcript toggle
named the peek's id while the peek was unmounted.
---
 .../ArtifactsTab/AgentInterfaceStatusView.test.tsx    |  8 +++++---
 .../ArtifactsTab/AgentInterfaceStatusView.tsx         | 11 +++++++----
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index eb2e3b52b2c..f5712003a45 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -623,7 +623,7 @@ describe("Agent interface status view", () => {
     const receipt = within(bar).getByTestId("agent-interface-status-receipt");
     expect(receipt.textContent).toContain("Then roll to 50%");
     expect(receipt.textContent).toContain("Queued");
-    expect(receipt.textContent).not.toMatch(/ago|just now/);
+    expect(receipt.textContent).not.toMatch(/\d:\d\d/);
     // Start Here would rewrite the context under the running turn.
     expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
       true
@@ -631,6 +631,7 @@ describe("Agent interface status view", () => {
 
     const toggle = within(bar).getByRole("button", { name: "Show transcript" });
     expect(toggle.getAttribute("aria-expanded")).toBe("false");
+    expect(toggle.hasAttribute("aria-controls")).toBe(false);
     fireEvent.click(toggle);
     const peek = view.getByTestId("agent-interface-transcript-peek");
     expect(toggle.getAttribute("aria-controls")).toBe(peek.id);
@@ -645,8 +646,9 @@ describe("Agent interface status view", () => {
     const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
     const bar = view.getByTestId("agent-interface-status-bar");
-    expect(within(bar).getByTestId("agent-interface-status-receipt").textContent).toContain(
-      "In transcript · just now"
+    // The row's clock time, as the transcript shows it, not a relative time that goes stale.
+    expect(within(bar).getByTestId("agent-interface-status-receipt").textContent).toMatch(
+      /In transcript · \d{1,2}:\d\d\s[AP]M$/
     );
     const startHere = within(bar).getByRole("button", { name: "Start here" });
     expect(startHere.hasAttribute("disabled")).toBe(false);
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 150867d0ab5..1550801f53d 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -5,7 +5,7 @@ import { useAPI } from "@/browser/contexts/API";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { useStartHere } from "@/browser/hooks/useStartHere";
 import { useWorkspaceStoreRaw, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
-import { formatRelativeTime } from "@/browser/utils/ui/dateTime";
+import { formatTimestamp } from "@/browser/utils/ui/dateTime";
 import { AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY } from "@/common/constants/storage";
 import { cn } from "@/common/lib/utils";
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
@@ -229,7 +229,8 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
             <button
               type="button"
               aria-expanded={peekOpen}
-              aria-controls={panelId}
+              // The peek is unmounted while closed, and aria-controls must name an element that exists.
+              aria-controls={peekOpen ? panelId : undefined}
               onClick={() => setPeekOpen(!peekOpen)}
               className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent h-6 rounded px-1.5 focus-visible:ring-1"
             >
@@ -319,10 +320,12 @@ function ReceiptRow(props: { receipt: LastMessageReceipt }) {
       <span className="min-w-0 flex-1 truncate">{receipt.preview}</span>
       <span className={cn("shrink-0 font-medium", chip.className)}>
         {chip.label}
+        {/* The time the transcript shows on the row. A relative time would go stale: nothing
+            re-renders the bar while the workspace is idle, so it would read "just now" for good. */}
         {receipt.state === "in-transcript" && receipt.timestamp != null && (
-          <span className="text-muted counter-nums font-normal">
+          <span className="text-muted font-normal">
             {" · "}
-            {formatRelativeTime(receipt.timestamp)}
+            {formatTimestamp(receipt.timestamp)}
           </span>
         )}
       </span>

From 51718050284e280f80b90f9a993aa3cb0a49c915 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:18:45 +0000
Subject: [PATCH 10/18] fix(artifacts): address Codex review of the status bar
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- armed bash monitors read as waiting, not idle
- blank or non-startup runtime details fall back to Starting…
- serialized parallel calls name the one that started
- an old held input no longer stands in for a newer landed message
- peer messages in the peek name their sender and show their text
- Start here stays off in its confirmation once a turn starts
- Ctrl+Alt+Shift+P shows or hides the transcript peek
---
 .../ArtifactsTab/AgentInterfaceStatusView.tsx |  61 +++++++--
 .../agentInterfaceStatusBar.test.ts           |  91 ++++++++++++--
 .../ArtifactsTab/agentInterfaceStatusBar.ts   | 116 ++++++++++++++----
 .../ArtifactsTab/agentInterfaceView.ts        |   2 +-
 .../Settings/Sections/KeybindsSection.tsx     |   2 +
 src/browser/hooks/useStartHere.ts             |  24 +++-
 src/browser/utils/ui/keybinds.ts              |   3 +
 7 files changed, 246 insertions(+), 53 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 1550801f53d..d16be61a309 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -1,11 +1,12 @@
 import { useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
-import { CircleAlert, CircleDot, ListStart, Loader2 } from "lucide-react";
+import { CircleAlert, CircleDot, Hourglass, ListStart, Loader2 } from "lucide-react";
 import { TooltipIfPresent } from "@/browser/components/Tooltip/Tooltip";
 import { useAPI } from "@/browser/contexts/API";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { useStartHere } from "@/browser/hooks/useStartHere";
 import { useWorkspaceStoreRaw, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
 import { formatTimestamp } from "@/browser/utils/ui/dateTime";
+import { formatKeybind, KEYBINDS, matchesKeybind } from "@/browser/utils/ui/keybinds";
 import { AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY } from "@/common/constants/storage";
 import { cn } from "@/common/lib/utils";
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
@@ -23,6 +24,7 @@ import {
   type StatusActivity,
 } from "./agentInterfaceStatusBar";
 import {
+  isShortcutOwnedElsewhere,
   readStatusPage,
   recordStatusPageRead,
   subscribeStatusListings,
@@ -187,6 +189,8 @@ function ActivityIcon(props: { activity: StatusActivity }) {
       return <CircleDot aria-hidden="true" className={cn(className, "text-muted")} />;
     case "error":
       return <CircleAlert aria-hidden="true" className={cn(className, "text-error")} />;
+    case "monitor":
+      return <Hourglass aria-hidden="true" className={cn(className, "text-muted")} />;
     default:
       return <Loader2 aria-hidden="true" className={cn(className, "text-muted animate-spin")} />;
   }
@@ -204,16 +208,39 @@ function AgentInterfaceStatusBar(props: { workspaceId: string }) {
   return <StatusBar workspaceId={props.workspaceId} state={state} />;
 }
 
+/**
+ * The peek's shortcut. The bar is mounted only while the status page shows, so the chord does
+ * nothing in the chat view. Keys typed in the page's frame stay in the frame.
+ */
+function usePeekShortcut(togglePeek: () => void) {
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if (!matchesKeybind(e, KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK) || isShortcutOwnedElsewhere(e)) {
+        return;
+      }
+      e.preventDefault();
+      // A held chord would flip the peek on every key repeat.
+      if (e.repeat) return;
+      togglePeek();
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [togglePeek]);
+}
+
 function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
   const { state } = props;
   const panelId = useId();
   const [peekOpen, setPeekOpen] = usePersistedState(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, false);
+  const togglePeek = () => setPeekOpen((open) => !open);
+  usePeekShortcut(togglePeek);
   const activity = deriveStatusActivity(state.messages, {
     canInterrupt: state.canInterrupt,
     isStreamStarting: state.isStreamStarting,
     isCompacting: state.isCompacting,
     awaitingUserQuestion: state.awaitingUserQuestion,
-    runtimeDetail: state.runtimeStatus?.detail,
+    activeBashMonitorCount: state.activeBashMonitorCount,
+    runtimeStatus: state.runtimeStatus,
   });
   const receipt = deriveLastMessageReceipt(state.messages, state.queuedMessage, state.heldInputs);
 
@@ -226,16 +253,21 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
         <div className="flex flex-wrap items-center gap-x-3 gap-y-1 px-3 py-1">
           <ActivityLine activity={activity} />
           <div className="flex shrink-0 items-center gap-1">
-            <button
-              type="button"
-              aria-expanded={peekOpen}
-              // The peek is unmounted while closed, and aria-controls must name an element that exists.
-              aria-controls={peekOpen ? panelId : undefined}
-              onClick={() => setPeekOpen(!peekOpen)}
-              className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent h-6 rounded px-1.5 focus-visible:ring-1"
+            <TooltipIfPresent
+              tooltip={`${peekOpen ? "Hide" : "Show"} the newest transcript rows (${formatKeybind(KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK)})`}
+              side="bottom"
             >
-              {peekOpen ? "Hide transcript" : "Show transcript"}
-            </button>
+              <button
+                type="button"
+                aria-expanded={peekOpen}
+                // The peek is unmounted while closed, and aria-controls must name an element that exists.
+                aria-controls={peekOpen ? panelId : undefined}
+                onClick={togglePeek}
+                className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent h-6 rounded px-1.5 focus-visible:ring-1"
+              >
+                {peekOpen ? "Hide transcript" : "Show transcript"}
+              </button>
+            </TooltipIfPresent>
             <StartHereButton
               workspaceId={props.workspaceId}
               messages={state.messages}
@@ -285,6 +317,8 @@ function StartHereButton(props: {
     // Preserve legacy plan/exec markers so Start Here keeps plan→exec handoff for old history.
     // mutation-equivalent: agent ids are never empty strings, so ?? and || agree
     sourceAgentId: source?.agentId ?? source?.mode,
+    // Off while a turn runs, in the confirmation too: it may have opened before the turn started.
+    turnActive: props.turnActive,
   });
   return (
     <>
@@ -295,7 +329,7 @@ function StartHereButton(props: {
       >
         <button
           type="button"
-          disabled={startHere.disabled || props.turnActive}
+          disabled={startHere.disabled}
           onClick={startHere.openModal}
           className="text-muted hover:bg-hover hover:text-foreground focus-visible:ring-accent flex h-6 items-center gap-1 rounded px-1.5 focus-visible:ring-1 disabled:pointer-events-none disabled:opacity-50"
         >
@@ -329,6 +363,9 @@ function ReceiptRow(props: { receipt: LastMessageReceipt }) {
           </span>
         )}
       </span>
+      {receipt.otherHeldCount > 0 && (
+        <span className="text-error shrink-0 font-medium">+{receipt.otherHeldCount} held</span>
+      )}
     </div>
   );
 }
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index b2f1e5c64f6..3af71fa26d5 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import type { HeldInput } from "@/common/orpc/types";
 import type { DisplayedMessage, DisplayedUserMessage } from "@/common/types/message";
+import { formatAgentMessageEnvelope } from "@/common/utils/agentMessageEnvelope";
 import {
   deriveLastMessageReceipt,
   deriveStatusActivity,
@@ -55,10 +56,13 @@ function reasoning(isStreaming: boolean): DisplayedMessage {
   };
 }
 
+type DisplayedTool = Extract<DisplayedMessage, { type: "tool" }>;
+
 function tool(
   toolName: string,
-  status: Extract<DisplayedMessage, { type: "tool" }>["status"],
-  args: unknown = {}
+  status: DisplayedTool["status"],
+  args: unknown = {},
+  extra: Partial<DisplayedTool> = {}
 ): DisplayedMessage {
   sequence += 1;
   return {
@@ -71,6 +75,7 @@ function tool(
     status,
     isPartial: false,
     historySequence: sequence,
+    ...extra,
   };
 }
 
@@ -79,6 +84,7 @@ const streaming: StatusActivityFlags = {
   isStreamStarting: false,
   isCompacting: false,
   awaitingUserQuestion: false,
+  activeBashMonitorCount: 0,
 };
 const idle: StatusActivityFlags = { ...streaming, canInterrupt: false };
 
@@ -86,9 +92,19 @@ describe("deriveStatusActivity", () => {
   test("a turn that is starting reports starting, with the runtime's breadcrumb when present", () => {
     const flags = { ...streaming, isStreamStarting: true };
     expect(deriveStatusActivity([tool("bash", "executing")], flags).kind).toBe("starting");
-    expect(
-      deriveStatusActivity([], { ...flags, runtimeDetail: "Waking the workspace" }).label
-    ).toBe("Waking the workspace");
+    const startingWith = (runtimeStatus: StatusActivityFlags["runtimeStatus"]) =>
+      deriveStatusActivity([], { ...flags, runtimeStatus }).label;
+    expect(startingWith({ phase: "starting", detail: "Waking the workspace" })).toBe(
+      "Waking the workspace"
+    );
+    expect(startingWith({ phase: "waiting", detail: "Waiting for the runtime" })).toBe(
+      "Waiting for the runtime"
+    );
+    // A blank breadcrumb, or one from a phase that is not starting up, names no step.
+    const fallback = startingWith(null);
+    expect(fallback).not.toBe("");
+    expect(startingWith({ phase: "starting", detail: "  " })).toBe(fallback);
+    expect(startingWith({ phase: "error", detail: "Runtime failed earlier" })).toBe(fallback);
   });
 
   test("compacting and a pending question name their phase over the turn's running tool", () => {
@@ -116,6 +132,18 @@ describe("deriveStatusActivity", () => {
     expect(deriveStatusActivity(writing, streaming).kind).toBe("writing");
   });
 
+  test("of serialized calls, the one whose execution began is named, not a queued sibling", () => {
+    const turn = [
+      user("go"),
+      tool("bash", "executing", { display_name: "Build" }, { executionStartedAt: 10 }),
+      tool("bash", "executing", { display_name: "Test" }),
+    ];
+    expect(deriveStatusActivity(turn, streaming).detail).toBe("Build");
+    // Provider-executed calls never report a start, so the newest running call stands.
+    const provider = [user("go"), tool("web_search", "executing", { title: "Search" })];
+    expect(deriveStatusActivity(provider, streaming).detail).toBe("Search");
+  });
+
   test("a parallel call still running counts after a newer call completed", () => {
     const turn = [
       user("go"),
@@ -147,13 +175,25 @@ describe("deriveStatusActivity", () => {
     expect(deriveStatusActivity([user("go"), errored, assistant("done")], idle).kind).toBe("idle");
   });
 
-  test("a turn counts as running in every phase but idle and a stopped stream", () => {
+  test("after the turn, an armed bash monitor is waited on, not idle", () => {
+    const settled = [user("go"), assistant("watching the logs")];
+    expect(deriveStatusActivity(settled, { ...idle, activeBashMonitorCount: 2 }).kind).toBe(
+      "monitor"
+    );
+    // A running turn still names its own phase.
+    expect(deriveStatusActivity(settled, { ...streaming, activeBashMonitorCount: 2 }).kind).toBe(
+      "working"
+    );
+  });
+
+  test("a turn counts as running in every phase but idle, a stopped stream and a monitor wait", () => {
     const phases: Array<[StatusActivityFlags, DisplayedMessage[], boolean]> = [
       [{ ...idle, isStreamStarting: true }, [], true],
       [{ ...streaming, isCompacting: true }, [], true],
       [{ ...streaming, awaitingUserQuestion: true }, [], true],
       [streaming, [user("go"), tool("bash", "executing")], true],
       [idle, [user("go"), assistant("done")], false],
+      [{ ...idle, activeBashMonitorCount: 1 }, [user("go"), assistant("watching")], false],
     ];
     for (const [flags, messages, active] of phases) {
       expect(isTurnActive(deriveStatusActivity(messages, flags))).toBe(active);
@@ -180,14 +220,23 @@ describe("deriveLastMessageReceipt", () => {
     expect(receipt).toMatchObject({ state: "queued", preview: "queued text" });
   });
 
-  test("held inputs win over the newest transcript row, the newest held input first", () => {
+  test("a held input does not stand in for a message that landed; it is counted", () => {
+    // Held inputs carry no time: one left from earlier must not hide a newer message's arrival.
+    expect(deriveLastMessageReceipt([user("in history")], null, [held])).toMatchObject({
+      state: "in-transcript",
+      preview: "in history",
+      otherHeldCount: 1,
+    });
+    expect(deriveLastMessageReceipt([user("in history")], null, [])?.otherHeldCount).toBe(0);
+  });
+
+  test("with nothing sent to show, the newest held input is the receipt and the rest count", () => {
     const middle: HeldInput = { ...held, id: "h2", displayText: "middle held text" };
     const newer: HeldInput = { ...held, id: "h3", displayText: "newer held text" };
-    expect(
-      deriveLastMessageReceipt([user("in history")], null, [held, middle, newer])
-    ).toMatchObject({
+    expect(deriveLastMessageReceipt([], null, [held, middle, newer])).toMatchObject({
       state: "held",
       preview: "newer held text",
+      otherHeldCount: 2,
     });
   });
 
@@ -244,6 +293,28 @@ describe("recentTranscriptRows", () => {
     ]);
   });
 
+  test("another agent's message names its sender and shows its text, not the envelope", () => {
+    const peerMessage = assistant(
+      formatAgentMessageEnvelope({
+        from: "ws-reviewer",
+        fromTitle: "Reviewer",
+        relationship: "sibling",
+        message: "Looks good to me",
+      }),
+      {
+        agentPeerMessage: {
+          fromWorkspaceId: "ws-reviewer",
+          fromTitle: "Reviewer",
+          relationship: "sibling",
+        },
+      }
+    );
+    const [row] = recentTranscriptRows([peerMessage], 1);
+    expect(row.label).toContain("Reviewer");
+    expect(row.label).not.toBe(recentTranscriptRows([assistant("mine")], 1)[0].label);
+    expect(row.preview).toBe("Looks good to me");
+  });
+
   test("previews are one bounded line, and malformed tool arguments show none", () => {
     const long = `First line\n\n${"word ".repeat(100)}`;
     const [row] = recentTranscriptRows([user(long)], 1);
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index ae5b2e2977f..1758e1ffa2c 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -1,5 +1,7 @@
 import type { HeldInput } from "@/common/orpc/types";
 import type { DisplayedMessage, DisplayedUserMessage, QueuedMessage } from "@/common/types/message";
+import type { RuntimeStatusEvent } from "@/common/types/stream";
+import { parseAgentMessageEnvelope } from "@/common/utils/agentMessageEnvelope";
 
 /** The longest preview kept per line; the bar truncates visually well before this. */
 const PREVIEW_MAX_CHARS = 160;
@@ -31,6 +33,7 @@ export type StatusActivityKind =
   | "thinking"
   | "writing"
   | "working"
+  | "monitor"
   | "idle"
   | "error";
 
@@ -45,8 +48,10 @@ export interface StatusActivityFlags {
   isStreamStarting: boolean;
   isCompacting: boolean;
   awaitingUserQuestion: boolean;
+  /** Armed background bash monitors, which wake the agent on matching output after its turn. */
+  activeBashMonitorCount: number;
   /** The backend's startup breadcrumb (runtime readiness, tool loading), as StreamingBarrier shows it. */
-  runtimeDetail?: string | null;
+  runtimeStatus?: Pick<RuntimeStatusEvent, "phase" | "detail"> | null;
 }
 
 type DisplayedTool = Extract<DisplayedMessage, { type: "tool" }>;
@@ -69,7 +74,11 @@ function isStreamingRow(message: DisplayedMessage, type: "reasoning" | "assistan
 function streamingActivity(messages: readonly DisplayedMessage[]): StatusActivity {
   // mutation-equivalent: the user row itself is neither a tool nor a streaming row
   const turn = messages.slice(messages.findLastIndex((message) => message.type === "user") + 1);
-  const tool = turn.findLast(isRunningTool);
+  const running = turn.filter(isRunningTool);
+  // The backend runs parallel calls one at a time, and the queued ones show as executing too:
+  // only the call whose execute() began has executionStartedAt. Provider-executed tools never get
+  // one, so without a started call the newest running call stands.
+  const tool = running.findLast((call) => call.executionStartedAt != null) ?? running.at(-1);
   if (tool != null) {
     return { kind: "tool", label: `Running ${tool.toolName}`, detail: toolCallDetail(tool.args) };
   }
@@ -82,25 +91,51 @@ function streamingActivity(messages: readonly DisplayedMessage[]): StatusActivit
   return { kind: "working", label: "Working…" };
 }
 
+/**
+ * The runtime's startup breadcrumb while it starts or waits, as StreamingBarrier shows it. A blank
+ * detail (which the backend may send) reads as none, so the line never shows a bare spinner.
+ */
+function startingLabel(runtimeStatus: StatusActivityFlags["runtimeStatus"]): string {
+  const phase = runtimeStatus?.phase;
+  const detail = phase === "starting" || phase === "waiting" ? runtimeStatus?.detail?.trim() : "";
+  return detail != null && detail !== "" ? detail : "Starting…";
+}
+
+/** After the turn: an armed monitor wakes the agent on matching output, so it is not idle. */
+function settledActivity(
+  messages: readonly DisplayedMessage[],
+  activeBashMonitorCount: number
+): StatusActivity {
+  if (activeBashMonitorCount > 0) {
+    const monitors =
+      activeBashMonitorCount === 1
+        ? "a background monitor"
+        : `${activeBashMonitorCount} background monitors`;
+    return { kind: "monitor", label: `Waiting on ${monitors}` };
+  }
+  return messages.at(-1)?.type === "stream-error"
+    ? { kind: "error", label: "Stopped with an error" }
+    : { kind: "idle", label: "Idle" };
+}
+
 /** What the agent is doing right now. */
 export function deriveStatusActivity(
   messages: readonly DisplayedMessage[],
   flags: StatusActivityFlags
 ): StatusActivity {
-  if (flags.isStreamStarting) {
-    return { kind: "starting", label: flags.runtimeDetail ?? "Starting…" };
-  }
+  if (flags.isStreamStarting) return { kind: "starting", label: startingLabel(flags.runtimeStatus) };
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
   if (flags.canInterrupt) return streamingActivity(messages);
-  return messages.at(-1)?.type === "stream-error"
-    ? { kind: "error", label: "Stopped with an error" }
-    : { kind: "idle", label: "Idle" };
+  return settledActivity(messages, flags.activeBashMonitorCount);
 }
 
-/** Whether a turn is still running: every activity but idle and a stopped stream. */
+/** Activities with no turn running: the agent is idle, stopped, or waits for a monitor's match. */
+const SETTLED_KINDS: ReadonlySet<StatusActivityKind> = new Set(["idle", "error", "monitor"]);
+
+/** Whether a turn is still running. */
 export function isTurnActive(activity: StatusActivity): boolean {
-  return activity.kind !== "idle" && activity.kind !== "error";
+  return !SETTLED_KINDS.has(activity.kind);
 }
 
 /** A user row the human typed, not a machine turn (wakes, continuations, peer triggers, warnings). */
@@ -123,26 +158,25 @@ export interface LastMessageReceipt {
   preview: string;
   /** When the row landed in the transcript, for "in-transcript" rows that carry one. */
   timestamp?: number;
+  /**
+   * Held inputs the receipt does not show. They carry no time, so the bar cannot tell whether one
+   * is newer than the message it shows, and counts them instead (the dock lists each one).
+   */
+  otherHeldCount: number;
 }
 
 function previewOrPlaceholder(text: string): string {
   return oneLine(text) || "(no text)";
 }
 
-/**
- * Where the user's latest message is. A queued or held message is always newer than every
- * transcript row (neither is in history yet), so it wins over the newest human row.
- */
-export function deriveLastMessageReceipt(
+/** The queued message (newer than every row: it is not in history yet), else the newest human row. */
+function sentMessageReceipt(
   messages: readonly DisplayedMessage[],
-  queuedMessage: QueuedMessage | null,
-  heldInputs: readonly HeldInput[]
-): LastMessageReceipt | null {
+  queuedMessage: QueuedMessage | null
+): Omit<LastMessageReceipt, "otherHeldCount"> | null {
   if (queuedMessage != null) {
     return { state: "queued", preview: previewOrPlaceholder(queuedMessage.content) };
   }
-  const held = heldInputs.at(-1);
-  if (held != null) return { state: "held", preview: previewOrPlaceholder(held.displayText) };
   const latest = messages.findLast(isHumanUserMessage);
   if (latest == null) return null;
   if (latest.isPendingSend === true) {
@@ -155,6 +189,27 @@ export function deriveLastMessageReceipt(
   };
 }
 
+/**
+ * Where the user's latest message is. Held inputs stay until the user resends or discards them,
+ * so an old one must not stand in for a newer message that landed: the receipt shows a held input
+ * only when there is nothing else to show, and counts the rest.
+ */
+export function deriveLastMessageReceipt(
+  messages: readonly DisplayedMessage[],
+  queuedMessage: QueuedMessage | null,
+  heldInputs: readonly HeldInput[]
+): LastMessageReceipt | null {
+  const sent = sentMessageReceipt(messages, queuedMessage);
+  if (sent != null) return { ...sent, otherHeldCount: heldInputs.length };
+  const held = heldInputs.at(-1);
+  if (held == null) return null;
+  return {
+    state: "held",
+    preview: previewOrPlaceholder(held.displayText),
+    otherHeldCount: heldInputs.length - 1,
+  };
+}
+
 export type RecentTranscriptRowKind =
   | "user"
   | "assistant"
@@ -186,12 +241,21 @@ const ROW_BUILDERS: RowBuilders = {
     label: isHumanUserMessage(message) ? "You" : "Xum",
     preview: oneLine(message.content),
   }),
-  assistant: (message) => ({
-    id: message.id,
-    kind: "assistant",
-    label: "Agent",
-    preview: oneLine(message.content),
-  }),
+  assistant: (message) => {
+    // Another agent's message: name its sender and show its text, as the transcript's card does,
+    // not this agent and the model-facing envelope.
+    const peer = message.agentPeerMessage;
+    if (peer != null) {
+      const envelope = parseAgentMessageEnvelope(message.content);
+      return {
+        id: message.id,
+        kind: "assistant",
+        label: `From ${peer.fromTitle ?? peer.fromWorkspaceId}`,
+        preview: oneLine(envelope?.message ?? message.content),
+      };
+    }
+    return { id: message.id, kind: "assistant", label: "Agent", preview: oneLine(message.content) };
+  },
   tool: (message) => ({
     id: message.id,
     kind: "tool",
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
index 5f63ae07a5c..6d1df2d985f 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
@@ -375,6 +375,6 @@ export function useMainPaneAgentInterfaceView(workspaceId: string): AgentInterfa
 }
 
 /** Dialogs, terminals and remote desktops keep their keystrokes, as for the Artifacts chord. */
-function isShortcutOwnedElsewhere(e: KeyboardEvent): boolean {
+export function isShortcutOwnedElsewhere(e: KeyboardEvent): boolean {
   return isDialogOpen() || isTerminalFocused(e.target) || isDesktopViewportFocused(e.target);
 }
diff --git a/src/browser/features/Settings/Sections/KeybindsSection.tsx b/src/browser/features/Settings/Sections/KeybindsSection.tsx
index 5954df48369..ade5d0d2a38 100644
--- a/src/browser/features/Settings/Sections/KeybindsSection.tsx
+++ b/src/browser/features/Settings/Sections/KeybindsSection.tsx
@@ -69,6 +69,7 @@ const KEYBIND_LABELS: Record<keyof typeof KEYBINDS, string> = {
   OPEN_STATS_DIALOG: "Open Stats tab (small viewports)",
   OPEN_ARTIFACTS_TAB: "Focus Artifacts tab, or hide the sidebar when focused",
   TOGGLE_AGENT_INTERFACE_VIEW: "Switch between status page and chat (Agent interface view)",
+  TOGGLE_STATUS_TRANSCRIPT_PEEK: "Show or hide the transcript on the status page",
   TOGGLE_ARTIFACT_FULLSCREEN: "Toggle artifact fullscreen (Artifacts tab)",
   NEXT_ARTIFACT: "Next artifact (Artifacts tab)",
   PREV_ARTIFACT: "Previous artifact (Artifacts tab)",
@@ -267,6 +268,7 @@ const KEYBIND_GROUPS: Array<{
     keys: [
       "OPEN_ARTIFACTS_TAB",
       "TOGGLE_AGENT_INTERFACE_VIEW",
+      "TOGGLE_STATUS_TRANSCRIPT_PEEK",
       "TOGGLE_ARTIFACT_FULLSCREEN",
       "NEXT_ARTIFACT",
       "PREV_ARTIFACT",
diff --git a/src/browser/hooks/useStartHere.ts b/src/browser/hooks/useStartHere.ts
index d7df41d19c5..b3bd61e18fd 100644
--- a/src/browser/hooks/useStartHere.ts
+++ b/src/browser/hooks/useStartHere.ts
@@ -9,6 +9,8 @@ import {
 } from "@/browser/utils/transcriptBarrier";
 import { TRANSCRIPT_NOT_CAUGHT_UP_MESSAGE } from "@/constants/transcriptBarrier";
 
+const START_HERE_TURN_ACTIVE_MESSAGE = "A turn is running. Start Here once it ends.";
+
 /**
  * Hook for managing Start Here button state and modal.
  * Returns a button config and modal state management.
@@ -22,7 +24,16 @@ export function useStartHere(
   workspaceId: string | undefined,
   content: string,
   isCompacted = false,
-  options?: { deletePlanFile?: boolean; sourceAgentId?: string }
+  options?: {
+    deletePlanFile?: boolean;
+    sourceAgentId?: string;
+    /**
+     * A turn is running. The backend does not refuse Start Here then (compaction replaces run
+     * inside turns), so a caller that knows the turn state passes it to keep the boundary from
+     * landing under the running turn, also from a confirmation opened before the turn started.
+     */
+    turnActive?: boolean;
+  }
 ) {
   const { api } = useAPI();
   const [isModalOpen, setIsModalOpen] = useState(false);
@@ -30,10 +41,11 @@ export function useStartHere(
   // Rendered disabled state follows the barrier, so the button never offers a click that
   // `openModal`/`executeStartHere` would refuse.
   const transcriptMutationAllowed = useTranscriptMutationAllowed(workspaceId);
+  const turnActive = options?.turnActive === true;
 
   // Opens the confirmation modal
   const openModal = () => {
-    if (!workspaceId || isCompacted) return;
+    if (!workspaceId || isCompacted || turnActive) return;
     // Start Here rewrites the request window around a row the user sees; refuse while the
     // transcript is not yet a verified copy of history (same barrier as sends and edits).
     if (!isTranscriptMutationAllowed(workspaceId)) return;
@@ -53,6 +65,9 @@ export function useStartHere(
     if (!isTranscriptMutationAllowed(workspaceId)) {
       throw new Error(TRANSCRIPT_NOT_CAUGHT_UP_MESSAGE);
     }
+    if (turnActive) {
+      throw new Error(START_HERE_TURN_ACTIVE_MESSAGE);
+    }
 
     setIsStartingHere(true);
     try {
@@ -93,14 +108,15 @@ export function useStartHere(
     onConfirm: executeStartHere,
     // The open dialog follows the barrier too: a replay that drops out after it opened
     // disables OK rather than letting a click resolve to nothing.
-    confirmDisabled: !transcriptMutationAllowed,
+    confirmDisabled: !transcriptMutationAllowed || turnActive,
   });
 
   return {
     openModal,
     isStartingHere,
     buttonLabel: `Start Here`,
-    disabled: !workspaceId || isStartingHere || isCompacted || !transcriptMutationAllowed,
+    disabled:
+      !workspaceId || isStartingHere || isCompacted || !transcriptMutationAllowed || turnActive,
     modal, // Pre-configured modal to render
   };
 }
diff --git a/src/browser/utils/ui/keybinds.ts b/src/browser/utils/ui/keybinds.ts
index 42706761d2a..1f4e7dd7a53 100644
--- a/src/browser/utils/ui/keybinds.ts
+++ b/src/browser/utils/ui/keybinds.ts
@@ -612,6 +612,9 @@ export const KEYBINDS = {
   /** Agent interface view: switch the main pane between the agent's status page and the chat */
   TOGGLE_AGENT_INTERFACE_VIEW: { key: "S", ctrl: true, shift: true },
 
+  /** Agent interface view: show or hide the transcript peek under the status page's bar */
+  TOGGLE_STATUS_TRANSCRIPT_PEEK: { key: "p", code: "KeyP", ctrl: true, alt: true, shift: true },
+
   // Artifacts tab shortcuts: only handled while focus is inside the Artifacts panel,
   // like the Review panel's single-key hunk navigation.
   /** Toggle fullscreen for the selected artifact */

From 09c88c46f0fa4c8f6e308d09785739072d81fd82 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:39:18 +0000
Subject: [PATCH 11/18] refactor(artifacts): gate Start Here on one blocked
 flag

The turn guard in openModal and executeStartHere read the same rendered
prop as disabled and confirmDisabled, so they added nothing. Moving the
history write into appendStartHereBoundary keeps useStartHere under the
CRAP floor (CC 15 -> 14).
---
 .../ArtifactsTab/AgentInterfaceStatusView.tsx |   5 +-
 .../ArtifactsTab/agentInterfaceStatusBar.ts   |   4 +-
 src/browser/hooks/useStartHere.ts             | 103 ++++++++++--------
 3 files changed, 63 insertions(+), 49 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index d16be61a309..a059687d375 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -215,7 +215,10 @@ function AgentInterfaceStatusBar(props: { workspaceId: string }) {
 function usePeekShortcut(togglePeek: () => void) {
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
-      if (!matchesKeybind(e, KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK) || isShortcutOwnedElsewhere(e)) {
+      if (
+        !matchesKeybind(e, KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK) ||
+        isShortcutOwnedElsewhere(e)
+      ) {
         return;
       }
       e.preventDefault();
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index 1758e1ffa2c..b02097e914c 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -123,7 +123,9 @@ export function deriveStatusActivity(
   messages: readonly DisplayedMessage[],
   flags: StatusActivityFlags
 ): StatusActivity {
-  if (flags.isStreamStarting) return { kind: "starting", label: startingLabel(flags.runtimeStatus) };
+  if (flags.isStreamStarting) {
+    return { kind: "starting", label: startingLabel(flags.runtimeStatus) };
+  }
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
   if (flags.canInterrupt) return streamingActivity(messages);
diff --git a/src/browser/hooks/useStartHere.ts b/src/browser/hooks/useStartHere.ts
index b3bd61e18fd..cee009ebe21 100644
--- a/src/browser/hooks/useStartHere.ts
+++ b/src/browser/hooks/useStartHere.ts
@@ -2,14 +2,59 @@ import { useState } from "react";
 import React from "react";
 import { StartHereModal } from "@/browser/components/StartHereModal/StartHereModal";
 import { createMuxMessage } from "@/common/types/message";
-import { useAPI } from "@/browser/contexts/API";
+import { useAPI, type APIClient } from "@/browser/contexts/API";
 import {
   isTranscriptMutationAllowed,
   useTranscriptMutationAllowed,
 } from "@/browser/utils/transcriptBarrier";
 import { TRANSCRIPT_NOT_CAUGHT_UP_MESSAGE } from "@/constants/transcriptBarrier";
 
-const START_HERE_TURN_ACTIVE_MESSAGE = "A turn is running. Start Here once it ends.";
+interface StartHereOptions {
+  deletePlanFile?: boolean;
+  sourceAgentId?: string;
+  /**
+   * A turn is running. The backend does not refuse Start Here then (compaction replaces run
+   * inside turns), so a caller that knows the turn state passes it to keep the boundary from
+   * landing under the running turn, also from a confirmation opened before the turn started.
+   */
+  turnActive?: boolean;
+}
+
+/**
+ * Appends the Start Here boundary, with `content` as the summary that requests start from.
+ * Throws the backend's refusal instead of logging it: the modal keeps itself open and shows the
+ * reason (for example a workspace replaying a session tape refuses history changes).
+ */
+async function appendStartHereBoundary(
+  api: APIClient,
+  workspaceId: string,
+  content: string,
+  options: StartHereOptions | undefined
+): Promise<void> {
+  const summaryMessage = createMuxMessage(
+    `start-here-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+    "assistant",
+    content,
+    {
+      timestamp: Date.now(),
+      compacted: "user",
+      agentId: options?.sourceAgentId,
+    }
+  );
+
+  const result = await api.workspace.replaceChatHistory({
+    workspaceId,
+    summaryMessage,
+    // Start Here should create a durable boundary so older turns remain recoverable
+    // while request payloads begin at this point.
+    mode: "append-compaction-boundary",
+    deletePlanFile: options?.deletePlanFile,
+  });
+
+  if (!result.success) {
+    throw new Error(String(result.error));
+  }
+}
 
 /**
  * Hook for managing Start Here button state and modal.
@@ -24,16 +69,7 @@ export function useStartHere(
   workspaceId: string | undefined,
   content: string,
   isCompacted = false,
-  options?: {
-    deletePlanFile?: boolean;
-    sourceAgentId?: string;
-    /**
-     * A turn is running. The backend does not refuse Start Here then (compaction replaces run
-     * inside turns), so a caller that knows the turn state passes it to keep the boundary from
-     * landing under the running turn, also from a confirmation opened before the turn started.
-     */
-    turnActive?: boolean;
-  }
+  options?: StartHereOptions
 ) {
   const { api } = useAPI();
   const [isModalOpen, setIsModalOpen] = useState(false);
@@ -41,11 +77,14 @@ export function useStartHere(
   // Rendered disabled state follows the barrier, so the button never offers a click that
   // `openModal`/`executeStartHere` would refuse.
   const transcriptMutationAllowed = useTranscriptMutationAllowed(workspaceId);
-  const turnActive = options?.turnActive === true;
+  // The open dialog follows it too, and the turn state: a replay that drops out, or a turn that
+  // starts, after it opened disables OK (its click and its keybind) rather than letting a confirm
+  // resolve to nothing or land under the turn.
+  const blocked = !transcriptMutationAllowed || options?.turnActive === true;
 
   // Opens the confirmation modal
   const openModal = () => {
-    if (!workspaceId || isCompacted || turnActive) return;
+    if (!workspaceId || isCompacted) return;
     // Start Here rewrites the request window around a row the user sees; refuse while the
     // transcript is not yet a verified copy of history (same barrier as sends and edits).
     if (!isTranscriptMutationAllowed(workspaceId)) return;
@@ -65,37 +104,10 @@ export function useStartHere(
     if (!isTranscriptMutationAllowed(workspaceId)) {
       throw new Error(TRANSCRIPT_NOT_CAUGHT_UP_MESSAGE);
     }
-    if (turnActive) {
-      throw new Error(START_HERE_TURN_ACTIVE_MESSAGE);
-    }
 
     setIsStartingHere(true);
     try {
-      const summaryMessage = createMuxMessage(
-        `start-here-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
-        "assistant",
-        content,
-        {
-          timestamp: Date.now(),
-          compacted: "user",
-          agentId: options?.sourceAgentId,
-        }
-      );
-
-      const result = await api.workspace.replaceChatHistory({
-        workspaceId,
-        summaryMessage,
-        // Start Here should create a durable boundary so older turns remain recoverable
-        // while request payloads begin at this point.
-        mode: "append-compaction-boundary",
-        deletePlanFile: options?.deletePlanFile,
-      });
-
-      // Thrown, not logged: the modal keeps itself open and shows the reason (for example a
-      // workspace replaying a session tape refuses history changes).
-      if (!result.success) {
-        throw new Error(String(result.error));
-      }
+      await appendStartHereBoundary(api, workspaceId, content, options);
     } finally {
       setIsStartingHere(false);
     }
@@ -106,17 +118,14 @@ export function useStartHere(
     isOpen: isModalOpen,
     onClose: closeModal,
     onConfirm: executeStartHere,
-    // The open dialog follows the barrier too: a replay that drops out after it opened
-    // disables OK rather than letting a click resolve to nothing.
-    confirmDisabled: !transcriptMutationAllowed || turnActive,
+    confirmDisabled: blocked,
   });
 
   return {
     openModal,
     isStartingHere,
     buttonLabel: `Start Here`,
-    disabled:
-      !workspaceId || isStartingHere || isCompacted || !transcriptMutationAllowed || turnActive,
+    disabled: !workspaceId || isStartingHere || isCompacted || blocked,
     modal, // Pre-configured modal to render
   };
 }

From 5838e3bf47c25412cf7f4210708eb0377141bd84 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:39:18 +0000
Subject: [PATCH 12/18] test(artifacts): cover the Start Here race, the peek
 chord and held inputs

Also documents the transcript peek shortcut.
---
 docs/workspaces/artifacts.mdx                 |  2 +-
 .../AgentInterfaceStatusView.test.tsx         | 47 ++++++++++++++++++-
 .../builtInSkillContent.generated.ts          |  2 +-
 3 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/docs/workspaces/artifacts.mdx b/docs/workspaces/artifacts.mdx
index 10929bd3350..c87812d79b3 100644
--- a/docs/workspaces/artifacts.mdx
+++ b/docs/workspaces/artifacts.mdx
@@ -161,7 +161,7 @@ When the workspace has an active goal, Xum keeps `goal.status.html` up to date i
 - When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.
 - On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.
 
-A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript** opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.
+A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.
 
 ### Status page agent
 
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index f5712003a45..ea95780b2ba 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -186,6 +186,14 @@ function seedWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
   });
 }
 
+/** Changes a seeded workspace's state and notifies its subscribers, as a stream event does. */
+function updateSeededWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
+  const state = seededStates.get(workspaceId);
+  if (state == null) throw new Error(`${workspaceId} was not seeded`);
+  seededStates.set(workspaceId, { ...state, ...patch });
+  act(() => readRealWorkspaceStore().bumpState(workspaceId));
+}
+
 /** A turn mid-way: the user's prompt, the agent's reply so far, and a bash call still running. */
 const MID_TURN: DisplayedMessage[] = [
   {
@@ -614,15 +622,27 @@ describe("Agent interface status view", () => {
       messages: MID_TURN,
       canInterrupt: true,
       queuedMessage: { id: "q1", content: "Then roll to 50%" },
+      heldInputs: [
+        {
+          id: "h1",
+          reason: "reported",
+          displayText: "An older send that failed",
+          attachmentCount: 0,
+          reviewCount: 0,
+        },
+      ],
     });
     const view = render(<MainPane workspaceId="ws-bar-busy" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
     const bar = view.getByTestId("agent-interface-status-bar");
     expect(within(bar).getByRole("status").textContent).toContain("Slow check");
-    // The send made during the turn is the user's last message, still waiting in the queue.
+    // The send made during the turn is the user's last message, still waiting in the queue; the
+    // held input is counted, not shown in its place.
     const receipt = within(bar).getByTestId("agent-interface-status-receipt");
     expect(receipt.textContent).toContain("Then roll to 50%");
     expect(receipt.textContent).toContain("Queued");
+    expect(receipt.textContent).toContain("+1 held");
+    expect(receipt.textContent).not.toContain("An older send that failed");
     expect(receipt.textContent).not.toMatch(/\d:\d\d/);
     // Start Here would rewrite the context under the running turn.
     expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
@@ -641,7 +661,7 @@ describe("Agent interface status view", () => {
     expect(view.queryByTestId("agent-interface-transcript-peek")).toBeNull();
   });
 
-  test("Start here from the status bar opens the Start Here confirmation once the turn ends", async () => {
+  test("Start here from the status bar opens the confirmation once the turn ends, and a turn that starts under it turns OK off", async () => {
     seedWorkspace("ws-bar-idle", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
@@ -655,6 +675,29 @@ describe("Agent interface status view", () => {
     fireEvent.click(startHere);
     const dialog = await within(document.body).findByRole("dialog");
     expect(within(dialog).getByText("Start Here")).toBeTruthy();
+    const ok = within(dialog).getByRole("button", { name: "OK" });
+    expect(ok.hasAttribute("disabled")).toBe(false);
+
+    // A queued send starts the next turn while the dialog is open: the boundary must not land
+    // under it.
+    updateSeededWorkspace("ws-bar-idle", { messages: MID_TURN, canInterrupt: true });
+    expect(ok.hasAttribute("disabled")).toBe(true);
+  });
+
+  test("the transcript peek's shortcut opens and closes it, and a held chord does not flip it", async () => {
+    seedWorkspace("ws-bar-chord", { messages: MID_TURN.slice(0, 2) });
+    const view = render(<MainPane workspaceId="ws-bar-chord" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const peekShown = () => view.queryByTestId("agent-interface-transcript-peek") != null;
+    const { key, code } = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
+    const chord = { key, code, ctrlKey: true, altKey: true, shiftKey: true };
+
+    fireEvent.keyDown(window, chord);
+    expect(peekShown()).toBe(true);
+    fireEvent.keyDown(window, { ...chord, repeat: true });
+    expect(peekShown()).toBe(true);
+    fireEvent.keyDown(window, chord);
+    expect(peekShown()).toBe(false);
   });
   test("before the first message the bar shows no receipt and Start here stays off", async () => {
     seedWorkspace("ws-bar-empty", {});
diff --git a/src/node/services/agentSkills/builtInSkillContent.generated.ts b/src/node/services/agentSkills/builtInSkillContent.generated.ts
index 41b62e73259..897e8a84754 100644
--- a/src/node/services/agentSkills/builtInSkillContent.generated.ts
+++ b/src/node/services/agentSkills/builtInSkillContent.generated.ts
@@ -10525,7 +10525,7 @@ export const BUILTIN_SKILL_FILES: Record<string, Record<string, string>> = {
       "- When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.",
       "- On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.",
       "",
-      "A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript** opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.",
+      "A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.",
       "",
       "### Status page agent",
       "",

From 7699c788cc08e8b835756c31043e46c7563f9ffa Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 02:57:18 +0000
Subject: [PATCH 13/18] test(artifacts): cover the peek chord under a dialog
 and the newest provider call

The peek shortcut test now opens the Start Here dialog and checks that the
chord leaves the peek alone (it passed with isShortcutOwnedElsewhere removed).
The serialized-calls test runs two unstarted provider calls, so picking the
oldest instead of the newest fails. The busy bar test drops a no-clock-time
check that no single change could fail: queued receipts carry no timestamp.
---
 .../ArtifactsTab/AgentInterfaceStatusView.test.tsx       | 9 +++++++--
 .../ArtifactsTab/agentInterfaceStatusBar.test.ts         | 6 +++++-
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index ea95780b2ba..f622c314294 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -643,7 +643,6 @@ describe("Agent interface status view", () => {
     expect(receipt.textContent).toContain("Queued");
     expect(receipt.textContent).toContain("+1 held");
     expect(receipt.textContent).not.toContain("An older send that failed");
-    expect(receipt.textContent).not.toMatch(/\d:\d\d/);
     // Start Here would rewrite the context under the running turn.
     expect(within(bar).getByRole("button", { name: "Start here" }).hasAttribute("disabled")).toBe(
       true
@@ -684,7 +683,7 @@ describe("Agent interface status view", () => {
     expect(ok.hasAttribute("disabled")).toBe(true);
   });
 
-  test("the transcript peek's shortcut opens and closes it, and a held chord does not flip it", async () => {
+  test("the transcript peek's shortcut opens and closes it, but not on a held chord or under a dialog", async () => {
     seedWorkspace("ws-bar-chord", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-chord" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
@@ -698,6 +697,12 @@ describe("Agent interface status view", () => {
     expect(peekShown()).toBe(true);
     fireEvent.keyDown(window, chord);
     expect(peekShown()).toBe(false);
+
+    // An open dialog keeps its keystrokes.
+    fireEvent.click(view.getByRole("button", { name: "Start here" }));
+    await within(document.body).findByRole("dialog");
+    fireEvent.keyDown(window, chord);
+    expect(peekShown()).toBe(false);
   });
   test("before the first message the bar shows no receipt and Start here stays off", async () => {
     seedWorkspace("ws-bar-empty", {});
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index 3af71fa26d5..ef9607a58ee 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -140,7 +140,11 @@ describe("deriveStatusActivity", () => {
     ];
     expect(deriveStatusActivity(turn, streaming).detail).toBe("Build");
     // Provider-executed calls never report a start, so the newest running call stands.
-    const provider = [user("go"), tool("web_search", "executing", { title: "Search" })];
+    const provider = [
+      user("go"),
+      tool("web_search", "executing", { title: "Older search" }),
+      tool("web_search", "executing", { title: "Search" }),
+    ];
     expect(deriveStatusActivity(provider, streaming).detail).toBe("Search");
   });
 

From 13e2e951ba56b58cfd3bc0968ee452c1643cbdf4 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:38:43 +0000
Subject: [PATCH 14/18] fix(artifacts): forward the peek chord from the status
 page and add Start here's shortcut
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- The command palette keeps the bar's chords and the view switch, like a dialog
  (isShortcutOwnedElsewhere checks isCommandPaletteTarget). UAT round 2, S1.
- The status bar shows Interrupting… while a Stop is pending, with
  StreamingBarrier's precedence (Codex P2).
- KEYBINDS.STATUS_START_HERE (Ctrl+Alt+Shift+H) opens Start here from the bar.
  The frame does not forward it: a page script could open the confirmation
  under the user's typing, where Y confirms (Codex P1).
- The status page's bridge forwards the transcript peek chord: Alt chords match
  the physical key, AltGr stays the page's text, and the host replays code and
  Alt (Codex P1). The bar's chords also skip AltGr on the host.
---
 docs/workspaces/artifacts.mdx                 |   2 +-
 .../AgentInterfaceStatusView.test.tsx         | 142 ++++++++++++++++--
 .../ArtifactsTab/AgentInterfaceStatusView.tsx |  49 ++++--
 .../ArtifactsTab/ArtifactViewer.test.tsx      |   5 +-
 .../ArtifactsTab/SandboxedArtifactFrame.tsx   |  22 ++-
 .../agentInterfaceStatusBar.test.ts           |  19 +++
 .../ArtifactsTab/agentInterfaceStatusBar.ts   |   7 +
 .../ArtifactsTab/agentInterfaceView.ts        |  13 +-
 .../ArtifactsTab/artifactBridge.test.ts       |  56 +++++--
 .../ArtifactsTab/artifactBridge.ts            |  82 ++++++----
 .../Settings/Sections/KeybindsSection.tsx     |   2 +
 src/browser/utils/ui/keybinds.test.ts         |   2 +
 src/browser/utils/ui/keybinds.ts              |   3 +
 .../builtInSkillContent.generated.ts          |   2 +-
 14 files changed, 327 insertions(+), 79 deletions(-)

diff --git a/docs/workspaces/artifacts.mdx b/docs/workspaces/artifacts.mdx
index c87812d79b3..056d3ba5544 100644
--- a/docs/workspaces/artifacts.mdx
+++ b/docs/workspaces/artifacts.mdx
@@ -161,7 +161,7 @@ When the workspace has an active goal, Xum keeps `goal.status.html` up to date i
 - When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.
 - On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.
 
-A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.
+A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here**, or `Ctrl+Alt+Shift+H` (`Cmd+Option+Shift+H` on macOS), starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs. Its shortcut does nothing while focus is in the page, so the page's script cannot open the confirmation while you type in the page.
 
 ### Status page agent
 
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index f622c314294..69f6402d956 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -10,7 +10,7 @@ import { ThemeProvider } from "@/browser/contexts/ThemeContext";
 import * as WorkspaceStoreModule from "@/browser/stores/WorkspaceStore";
 import { workspaceStore, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
 import { overlayWorkspaceStoreRaw } from "@/browser/stores/workspaceStoreTestOverlay";
-import { KEYBINDS } from "@/browser/utils/ui/keybinds";
+import { KEYBINDS, type Keybind } from "@/browser/utils/ui/keybinds";
 import {
   createTestApiClient,
   resetTestExperiments,
@@ -129,6 +129,8 @@ const readRealWorkspaceStore = WorkspaceStoreModule.useWorkspaceStoreRaw;
 
 /** Workspace states the status bar reads, for workspaces the real store never registered. */
 const seededStates = new Map<string, WorkspaceState>();
+/** Seeded workspaces whose aggregator reports a stop in progress (WorkspaceStore.setInterrupting). */
+const interruptingWorkspaces = new Set<string>();
 const restoreSpies: Array<() => void> = [];
 
 function seedWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
@@ -138,6 +140,10 @@ function seedWorkspace(workspaceId: string, patch: Partial<WorkspaceState>) {
       hasRegisteredWorkspace: (id: string) =>
         seededStates.has(id) || realStore.hasRegisteredWorkspace(id),
       getWorkspaceState: (id: string) => seededStates.get(id) ?? realStore.getWorkspaceState(id),
+      getAggregator: (id: string) =>
+        interruptingWorkspaces.has(id)
+          ? { hasInterruptingStream: (): boolean => true }
+          : realStore.getAggregator(id),
     });
     const storeSpy = spyOn(WorkspaceStoreModule, "useWorkspaceStoreRaw").mockReturnValue(store);
     // Start Here's transcript barrier: a seeded workspace has a complete replay.
@@ -263,6 +269,31 @@ function shownPage(view: ReturnType<typeof render>): string {
   return within(statusView).queryByTestId("artifact-frame")?.getAttribute("srcdoc") ?? "";
 }
 
+/**
+ * A press of `keybind`'s physical Ctrl+Alt+Shift chord at `target`, or AltGr's (`altGraph`):
+ * happy-dom infers AltGraph from any Ctrl+Alt event, so the event states which it is.
+ */
+function pressAltChord(
+  target: Element | Window,
+  keybind: Keybind,
+  extra: { repeat?: boolean; altGraph?: boolean } = {}
+) {
+  const event = new window.KeyboardEvent("keydown", {
+    key: keybind.key,
+    code: keybind.code,
+    ctrlKey: true,
+    altKey: true,
+    shiftKey: true,
+    repeat: extra.repeat ?? false,
+    bubbles: true,
+    cancelable: true,
+  });
+  Object.defineProperty(event, "getModifierState", {
+    value: (modifier: string) => modifier === "AltGraph" && extra.altGraph === true,
+  });
+  fireEvent(target, event);
+}
+
 /**
  * Runs the bridge shim from `frame`'s srcdoc against a stand-in window whose posts reach the host
  * as the frame's messages; returns a trusted key press inside the frame.
@@ -297,16 +328,22 @@ function runFrameShim(frame: HTMLIFrameElement) {
     customEvent: unknown
   ) => void;
   run(frameWindow, frameDocument, class {});
-  return (key: string, modifiers: { ctrlKey?: boolean; shiftKey?: boolean }) => {
+  return (
+    key: string,
+    modifiers: { ctrlKey?: boolean; shiftKey?: boolean; altKey?: boolean; code?: string }
+  ) => {
     const event = {
       key,
+      code: modifiers.code ?? "",
       target: { nodeType: 1, tagName: "DIV", isContentEditable: false },
       isTrusted: true,
       repeat: false,
       ctrlKey: modifiers.ctrlKey ?? false,
       shiftKey: modifiers.shiftKey ?? false,
       metaKey: false,
-      altKey: false,
+      altKey: modifiers.altKey ?? false,
+      // Physical Ctrl+Alt, not AltGr.
+      getModifierState: () => false,
       defaultPrevented: false,
       preventDefault: () => undefined,
     };
@@ -338,6 +375,7 @@ describe("Agent interface status view", () => {
     cleanup();
     for (const restore of restoreSpies.splice(0)) restore();
     seededStates.clear();
+    interruptingWorkspaces.clear();
     resetTestExperiments();
     cleanupDom?.();
     cleanupDom = null;
@@ -472,6 +510,41 @@ describe("Agent interface status view", () => {
     }
   });
 
+  test("the transcript peek's chord pressed in the page opens and closes it", async () => {
+    Object.defineProperty(window.navigator, "userActivation", {
+      configurable: true,
+      get: () => ({ isActive: true }),
+    });
+    // The host builds the replayed event with the global constructor, which the DOM harness
+    // lacks. Chrome's constructed events report no AltGraph unless built with it; happy-dom's
+    // infer it from Ctrl+Alt.
+    const globalKeyboardEvent = globalThis.KeyboardEvent;
+    globalThis.KeyboardEvent = class extends window.KeyboardEvent {
+      override getModifierState(modifier: string): boolean {
+        return modifier !== "AltGraph" && super.getModifierState(modifier);
+      }
+    };
+    try {
+      seedWorkspace("ws-peek-frame", { messages: MID_TURN.slice(0, 2) });
+      const view = render(<MainPane workspaceId="ws-peek-frame" />, { wrapper: Wrapper });
+      await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+      const frame = view.getByTestId("artifact-frame") as HTMLIFrameElement;
+      act(() => frame.focus());
+      // Through the shim this frame's srcdoc carries, as for the view switch chord.
+      const pressInFrame = runFrameShim(frame);
+      const peekShown = () => view.queryByTestId("agent-interface-transcript-peek") != null;
+      const { key, code } = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
+      const chord = { ctrlKey: true, altKey: true, shiftKey: true, code };
+      act(() => pressInFrame(key, chord));
+      expect(peekShown()).toBe(true);
+      act(() => pressInFrame(key, chord));
+      expect(peekShown()).toBe(false);
+    } finally {
+      globalThis.KeyboardEvent = globalKeyboardEvent;
+      Reflect.deleteProperty(window.navigator, "userActivation");
+    }
+  });
+
   test("a send from the page asks in the confirm strip, also during the user's gesture", async () => {
     // Focus on the frame and live activation: what the Artifacts tab takes as a click in the page.
     Object.defineProperty(window.navigator, "userActivation", {
@@ -660,6 +733,19 @@ describe("Agent interface status view", () => {
     expect(view.queryByTestId("agent-interface-transcript-peek")).toBeNull();
   });
 
+  test("after Stop, the status bar shows the stop in progress, not the tool the turn ran", async () => {
+    seedWorkspace("ws-bar-stopping", { messages: MID_TURN, canInterrupt: true });
+    const view = render(<MainPane workspaceId="ws-bar-stopping" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const activity = within(view.getByTestId("agent-interface-status-bar")).getByRole("status");
+    expect(activity.textContent).toContain("Slow check");
+    // Stop marks the stream on the aggregator and bumps the state, as setInterrupting does.
+    interruptingWorkspaces.add("ws-bar-stopping");
+    updateSeededWorkspace("ws-bar-stopping", {});
+    expect(activity.textContent).toContain("Interrupting");
+    expect(activity.textContent).not.toContain("Slow check");
+  });
+
   test("Start here from the status bar opens the confirmation once the turn ends, and a turn that starts under it turns OK off", async () => {
     seedWorkspace("ws-bar-idle", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
@@ -683,27 +769,63 @@ describe("Agent interface status view", () => {
     expect(ok.hasAttribute("disabled")).toBe(true);
   });
 
-  test("the transcript peek's shortcut opens and closes it, but not on a held chord or under a dialog", async () => {
+  test("the transcript peek's shortcut opens and closes it, but not on a held chord, AltGr, from the command palette or under a dialog", async () => {
     seedWorkspace("ws-bar-chord", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-chord" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
     const peekShown = () => view.queryByTestId("agent-interface-transcript-peek") != null;
-    const { key, code } = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
-    const chord = { key, code, ctrlKey: true, altKey: true, shiftKey: true };
+    const peek = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
 
-    fireEvent.keyDown(window, chord);
+    pressAltChord(window, peek);
     expect(peekShown()).toBe(true);
-    fireEvent.keyDown(window, { ...chord, repeat: true });
+    pressAltChord(window, peek, { repeat: true });
     expect(peekShown()).toBe(true);
-    fireEvent.keyDown(window, chord);
+    pressAltChord(window, peek);
+    expect(peekShown()).toBe(false);
+    // AltGr reads as Ctrl+Alt but types text (Shift+AltGr+P types Ö on US-International).
+    pressAltChord(window, peek, { altGraph: true });
     expect(peekShown()).toBe(false);
 
+    // The command palette keeps its keystrokes too, though it renders no modal dialog.
+    const palette = document.createElement("div");
+    palette.setAttribute("cmdk-root", "");
+    const paletteInput = document.createElement("input");
+    palette.append(paletteInput);
+    document.body.append(palette);
+    pressAltChord(paletteInput, peek);
+    expect(peekShown()).toBe(false);
+    palette.remove();
+
     // An open dialog keeps its keystrokes.
     fireEvent.click(view.getByRole("button", { name: "Start here" }));
     await within(document.body).findByRole("dialog");
-    fireEvent.keyDown(window, chord);
+    pressAltChord(window, peek);
     expect(peekShown()).toBe(false);
   });
+
+  test("Start here's shortcut opens the confirmation, but not on a held chord or mid-turn", async () => {
+    seedWorkspace("ws-bar-start-chord", { messages: MID_TURN.slice(0, 2) });
+    const view = render(<MainPane workspaceId="ws-bar-start-chord" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const dialogShown = () => within(document.body).queryByRole("dialog") != null;
+    const startHere = KEYBINDS.STATUS_START_HERE;
+
+    pressAltChord(window, startHere, { repeat: true });
+    expect(dialogShown()).toBe(false);
+    // Off while a turn runs, as the button is.
+    updateSeededWorkspace("ws-bar-start-chord", { messages: MID_TURN, canInterrupt: true });
+    pressAltChord(window, startHere);
+    expect(dialogShown()).toBe(false);
+
+    updateSeededWorkspace("ws-bar-start-chord", {
+      messages: MID_TURN.slice(0, 2),
+      canInterrupt: false,
+    });
+    pressAltChord(window, startHere);
+    const dialog = await within(document.body).findByRole("dialog");
+    expect(within(dialog).getByText("Start Here")).toBeTruthy();
+  });
+
   test("before the first message the bar shows no receipt and Start here stays off", async () => {
     seedWorkspace("ws-bar-empty", {});
     const view = render(<MainPane workspaceId="ws-bar-empty" />, { wrapper: Wrapper });
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index a059687d375..6419ba766c0 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -4,9 +4,19 @@ import { TooltipIfPresent } from "@/browser/components/Tooltip/Tooltip";
 import { useAPI } from "@/browser/contexts/API";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { useStartHere } from "@/browser/hooks/useStartHere";
-import { useWorkspaceStoreRaw, type WorkspaceState } from "@/browser/stores/WorkspaceStore";
+import {
+  useWorkspaceAggregator,
+  useWorkspaceStoreRaw,
+  type WorkspaceState,
+} from "@/browser/stores/WorkspaceStore";
 import { formatTimestamp } from "@/browser/utils/ui/dateTime";
-import { formatKeybind, KEYBINDS, matchesKeybind } from "@/browser/utils/ui/keybinds";
+import {
+  formatKeybind,
+  isAltGraphPressed,
+  KEYBINDS,
+  matchesKeybind,
+  type Keybind,
+} from "@/browser/utils/ui/keybinds";
 import { AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY } from "@/common/constants/storage";
 import { cn } from "@/common/lib/utils";
 import { AGENT_INTERFACE_STATUS_ARTIFACT } from "@/common/constants/artifacts";
@@ -209,26 +219,26 @@ function AgentInterfaceStatusBar(props: { workspaceId: string }) {
 }
 
 /**
- * The peek's shortcut. The bar is mounted only while the status page shows, so the chord does
- * nothing in the chat view. Keys typed in the page's frame stay in the frame.
+ * A chord of the bar, on the app's window. The bar is mounted only while the status page shows,
+ * so its chords do nothing in the chat view. `run` is null while the action is off: the chord is
+ * still claimed. Keys typed in the page's frame reach this listener only when its bridge
+ * forwards them (ARTIFACT_FRAME_CHORDS).
  */
-function usePeekShortcut(togglePeek: () => void) {
+function useBarShortcut(keybind: Keybind, run: (() => void) | null) {
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
-      if (
-        !matchesKeybind(e, KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK) ||
-        isShortcutOwnedElsewhere(e)
-      ) {
+      // AltGr reads as Ctrl+Alt and types text, which stays the focused field's.
+      if (!matchesKeybind(e, keybind) || isAltGraphPressed(e) || isShortcutOwnedElsewhere(e)) {
         return;
       }
       e.preventDefault();
-      // A held chord would flip the peek on every key repeat.
-      if (e.repeat) return;
-      togglePeek();
+      // A held chord would act on every key repeat.
+      if (e.repeat || run == null) return;
+      run();
     };
     window.addEventListener("keydown", handler);
     return () => window.removeEventListener("keydown", handler);
-  }, [togglePeek]);
+  }, [keybind, run]);
 }
 
 function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
@@ -236,9 +246,13 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
   const panelId = useId();
   const [peekOpen, setPeekOpen] = usePersistedState(AGENT_INTERFACE_TRANSCRIPT_PEEK_KEY, false);
   const togglePeek = () => setPeekOpen((open) => !open);
-  usePeekShortcut(togglePeek);
+  useBarShortcut(KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK, togglePeek);
+  // Not in WorkspaceState, as for StreamingBarrier: setInterrupting bumps the state, and that
+  // re-renders the bar.
+  const aggregator = useWorkspaceAggregator(props.workspaceId);
   const activity = deriveStatusActivity(state.messages, {
     canInterrupt: state.canInterrupt,
+    isInterrupting: aggregator?.hasInterruptingStream() ?? false,
     isStreamStarting: state.isStreamStarting,
     isCompacting: state.isCompacting,
     awaitingUserQuestion: state.awaitingUserQuestion,
@@ -323,10 +337,15 @@ function StartHereButton(props: {
     // Off while a turn runs, in the confirmation too: it may have opened before the turn started.
     turnActive: props.turnActive,
   });
+  // SECURITY AUDIT: unlike the peek's chord, the status page's frame does not forward this one.
+  // The host honours a forwarded chord during any live gesture in the frame, so the page's
+  // script could open the confirmation while the user types in the page, and their next key
+  // would land in the dialog, where Y confirms.
+  useBarShortcut(KEYBINDS.STATUS_START_HERE, startHere.disabled ? null : startHere.openModal);
   return (
     <>
       <TooltipIfPresent
-        tooltip="Start a new context from the agent's last reply and keep earlier history"
+        tooltip={`Start a new context from the agent's last reply and keep earlier history (${formatKeybind(KEYBINDS.STATUS_START_HERE)})`}
         side="bottom"
         align="end"
       >
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/ArtifactViewer.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/ArtifactViewer.test.tsx
index b471212276c..d54224bf55e 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/ArtifactViewer.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/ArtifactViewer.test.tsx
@@ -464,7 +464,7 @@ describe("ArtifactViewer renderers", () => {
     const globalKeyboardEvent = globalThis.KeyboardEvent;
     globalThis.KeyboardEvent = window.KeyboardEvent;
     try {
-      const postChord = (chord: "sidebar" | "agentInterface") =>
+      const postChord = (chord: "sidebar" | "agentInterface" | "peek") =>
         act(() => {
           const event = new window.Event("message");
           Object.defineProperty(event, "data", {
@@ -483,8 +483,9 @@ describe("ArtifactViewer renderers", () => {
       activation = { isActive: true };
       postChord("sidebar");
       expect(replayed).toEqual([sidebarKey]);
-      // Only the main pane's status page forwards the view switch: here the page's script posted it.
+      // Only the main pane's status page forwards its chords: here the page's script posted them.
       postChord("agentInterface");
+      postChord("peek");
       expect(replayed).toEqual([sidebarKey]);
 
       // A frame that stopped rendering keeps focus in the browser; that focus does not count.
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/SandboxedArtifactFrame.tsx b/src/browser/features/RightSidebar/ArtifactsTab/SandboxedArtifactFrame.tsx
index da23895f905..6c0df38f70d 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/SandboxedArtifactFrame.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/SandboxedArtifactFrame.tsx
@@ -25,6 +25,7 @@ import {
   createBridgeRateLimiter,
   postArtifactAnnotateMode,
   postArtifactTheme,
+  STATUS_PAGE_FRAME_CHORDS,
   type ArtifactAppearance,
   type ArtifactFrameChord,
   type ArtifactFrameInterruptKey,
@@ -99,10 +100,11 @@ function hasLiveUserGesture(frame: HTMLIFrameElement | null): boolean {
 /**
  * Replays a chord pressed inside `frame` as a keydown on the frame element, so the app's one
  * handler for it applies its own rules: WorkspaceShell's useRightSidebarToggleKey for
- * TOGGLE_RIGHT_SIDEBAR, useArtifactsTabKey for OPEN_ARTIFACTS_TAB, the main pane's Agent interface
- * view handler for TOGGLE_AGENT_INTERFACE_VIEW (from the main pane's status page only, the one
- * frame that forwards it). All keep the dialog block (Artifacts fullscreen is a modal dialog); the
- * sidebar ones also move focus to the toggle after a collapse.
+ * TOGGLE_RIGHT_SIDEBAR, useArtifactsTabKey for OPEN_ARTIFACTS_TAB, and from the main pane's status
+ * page only (the one frame that forwards them), the main pane's Agent interface view handler for
+ * TOGGLE_AGENT_INTERFACE_VIEW and the status bar's for TOGGLE_STATUS_TRANSCRIPT_PEEK. All keep the
+ * dialog block (Artifacts fullscreen is a modal dialog); the sidebar ones also move focus to the
+ * toggle after a collapse.
  *
  * SECURITY AUDIT: the artifact's script can post the message without a key press, and can move
  * focus into its own frame with window.focus(). The host honours it only during the user's own
@@ -154,6 +156,9 @@ function replayKeybindOnFrame(
   if (!hasLiveUserGesture(frame) || frame == null) return;
   const event = new KeyboardEvent("keydown", {
     key: keybind.key,
+    // matchesKeybind compares the physical key when the keybind names one.
+    code: keybind.code,
+    altKey: keybind.alt === true,
     ...modifiers,
     bubbles: true,
     cancelable: true,
@@ -196,8 +201,13 @@ function handleFrameKeyMessage(
   }
 ): void {
   if (message.type === "sidebarKey") {
-    // Any other frame's shim never forwards the view switch: its page's own script posted it.
-    if (message.chord === "agentInterface" && handlers.mainPaneInterruptKey === undefined) return;
+    // Any other frame's shim never forwards these: its page's own script posted it.
+    if (
+      STATUS_PAGE_FRAME_CHORDS.has(message.chord) &&
+      handlers.mainPaneInterruptKey === undefined
+    ) {
+      return;
+    }
     replayFrameSidebarKey(frame, message);
     return;
   }
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index ef9607a58ee..ee7ec14810b 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -81,6 +81,7 @@ function tool(
 
 const streaming: StatusActivityFlags = {
   canInterrupt: true,
+  isInterrupting: false,
   isStreamStarting: false,
   isCompacting: false,
   awaitingUserQuestion: false,
@@ -107,6 +108,24 @@ describe("deriveStatusActivity", () => {
     expect(startingWith({ phase: "error", detail: "Runtime failed earlier" })).toBe(fallback);
   });
 
+  test("a stop the backend has not finished shows over the turn's phase until the stream ends", () => {
+    const turn = [user("go"), tool("bash", "executing", { display_name: "Run tests" })];
+    const stopping = { ...streaming, isInterrupting: true };
+    for (const flags of [
+      stopping,
+      { ...stopping, isCompacting: true },
+      { ...stopping, awaitingUserQuestion: true },
+    ]) {
+      expect(deriveStatusActivity(turn, flags).kind).toBe("interrupting");
+    }
+    expect(isTurnActive(deriveStatusActivity(turn, stopping))).toBe(true);
+    // A turn still starting shows its startup, and an ended stream leaves no stop to wait for.
+    expect(deriveStatusActivity(turn, { ...stopping, isStreamStarting: true }).kind).toBe(
+      "starting"
+    );
+    expect(deriveStatusActivity(turn, { ...stopping, canInterrupt: false }).kind).toBe("idle");
+  });
+
   test("compacting and a pending question name their phase over the turn's running tool", () => {
     const turn = [user("go"), tool("ask_user_question", "executing")];
     expect(deriveStatusActivity(turn, { ...streaming, isCompacting: true }).kind).toBe(
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index b02097e914c..77a426df595 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -27,6 +27,7 @@ export function toolCallDetail(args: unknown): string | undefined {
 
 export type StatusActivityKind =
   | "starting"
+  | "interrupting"
   | "compacting"
   | "question"
   | "tool"
@@ -45,6 +46,8 @@ export interface StatusActivity {
 
 export interface StatusActivityFlags {
   canInterrupt: boolean;
+  /** The user stopped the turn and the backend has not ended the stream yet. */
+  isInterrupting: boolean;
   isStreamStarting: boolean;
   isCompacting: boolean;
   awaitingUserQuestion: boolean;
@@ -126,6 +129,10 @@ export function deriveStatusActivity(
   if (flags.isStreamStarting) {
     return { kind: "starting", label: startingLabel(flags.runtimeStatus) };
   }
+  // As in StreamingBarrier: once the user stops the turn, the tool or phase it was in is stale.
+  if (flags.canInterrupt && flags.isInterrupting) {
+    return { kind: "interrupting", label: "Interrupting…" };
+  }
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
   if (flags.canInterrupt) return streamingActivity(messages);
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
index 6d1df2d985f..c791339e026 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceView.ts
@@ -4,6 +4,7 @@ import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { workspaceStore } from "@/browser/stores/WorkspaceStore";
 import { isAbortError } from "@/browser/utils/isAbortError";
 import {
+  isCommandPaletteTarget,
   isDesktopViewportFocused,
   isDialogOpen,
   isTerminalFocused,
@@ -374,7 +375,15 @@ export function useMainPaneAgentInterfaceView(workspaceId: string): AgentInterfa
   return available ? view : null;
 }
 
-/** Dialogs, terminals and remote desktops keep their keystrokes, as for the Artifacts chord. */
+/**
+ * Dialogs, the command palette, terminals and remote desktops keep their keystrokes, as for the
+ * Artifacts chord. isDialogOpen() does not see the palette: cmdk renders no modal overlay.
+ */
 export function isShortcutOwnedElsewhere(e: KeyboardEvent): boolean {
-  return isDialogOpen() || isTerminalFocused(e.target) || isDesktopViewportFocused(e.target);
+  return (
+    isDialogOpen() ||
+    isCommandPaletteTarget(e.target) ||
+    isTerminalFocused(e.target) ||
+    isDesktopViewportFocused(e.target)
+  );
 }
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.test.ts
index d83d0645861..6a3cb0fe09a 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.test.ts
@@ -124,6 +124,10 @@ function runBridgeScript(
       ctrlKey?: boolean;
       metaKey?: boolean;
       altKey?: boolean;
+      /** The physical key, KeyboardEvent.code. */
+      code?: string;
+      /** AltGr is down: getModifierState("AltGraph"). */
+      altGraph?: boolean;
       repeat?: boolean;
       defaultPrevented?: boolean;
       composedPath?: unknown[];
@@ -146,6 +150,8 @@ function runBridgeScript(
       repeat: extra.repeat ?? false,
       metaKey: extra.metaKey ?? false,
       altKey: extra.altKey ?? false,
+      code: extra.code ?? "",
+      getModifierState: (modifier: string) => modifier === "AltGraph" && extra.altGraph === true,
       defaultPrevented: false,
       preventDefault: () => {
         prevented += 1;
@@ -262,27 +268,48 @@ describe("bridge script keys", () => {
     expect(bridge.prevented()).toBe(1);
   });
 
-  test("only the main pane's status page claims the view switch chord", () => {
+  test("only the main pane's status page claims the view switch and transcript peek chords", () => {
     const key = KEYBINDS.TOGGLE_AGENT_INTERFACE_VIEW.key;
-    // Any other frame may show while no switch exists: the chord stays the artifact's.
+    const peek = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
+    const pressPeek = (bridge: ReturnType<typeof runBridgeScript>) =>
+      bridge.keydown(peek.key, div, true, { ctrlKey: true, altKey: true, code: peek.code });
+    // Any other frame may show while no switch exists: the chords stay the artifact's.
     const elsewhere = runBridgeScript();
     elsewhere.keydown(key, div, true, { ctrlKey: true });
+    pressPeek(elsewhere);
     expect(elsewhere.posted).toEqual([]);
     expect(elsewhere.prevented()).toBe(0);
 
     // The status page shows only while the switch exists: it must work after a click in it.
     const statusPage = runBridgeScript({ forwardsViewSwitch: true });
     statusPage.keydown(key, div, true, { ctrlKey: true });
+    pressPeek(statusPage);
+    const posted = { xumArtifact: 1, type: "sidebarKey", ctrlKey: true, metaKey: false };
     expect(statusPage.posted).toEqual([
-      {
-        xumArtifact: 1,
-        type: "sidebarKey",
-        chord: "agentInterface",
-        ctrlKey: true,
-        metaKey: false,
-      },
+      { ...posted, chord: "agentInterface" },
+      { ...posted, chord: "peek" },
+    ]);
+    expect(statusPage.prevented()).toBe(2);
+  });
+
+  test("the peek chord matches the physical key, and AltGr and Start here stay the page's", () => {
+    const peek = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK;
+    const statusPage = runBridgeScript({ forwardsViewSwitch: true });
+    const chord = { ctrlKey: true, altKey: true, code: peek.code };
+    // Shift+AltGr+P types Ö on US-International: AltGr reads as Ctrl+Alt.
+    statusPage.keydown("Ö", input, true, { ...chord, altGraph: true });
+    // Without Alt it is the command palette's chord, which no frame forwards.
+    statusPage.keydown(peek.key, div, true, { ctrlKey: true, code: peek.code });
+    // Start here would open its confirmation under the user's typing in the page.
+    const startHere = KEYBINDS.STATUS_START_HERE;
+    statusPage.keydown(startHere.key, div, true, { ...chord, code: startHere.code });
+    expect(statusPage.posted).toEqual([]);
+    expect(statusPage.prevented()).toBe(0);
+    // Whatever character the layout gives the key.
+    statusPage.keydown("π", div, true, chord);
+    expect(statusPage.posted).toEqual([
+      { xumArtifact: 1, type: "sidebarKey", chord: "peek", ctrlKey: true, metaKey: false },
     ]);
-    expect(statusPage.prevented()).toBe(1);
   });
 
   test("on macOS the right-sidebar chord is Cmd, and Ctrl stays the artifact's", () => {
@@ -306,6 +333,13 @@ describe("bridge script keys", () => {
         { xumArtifact: 1, type: "sidebarKey", chord: "artifacts", ctrlKey: false, metaKey: true },
       ]);
       expect(bridge.prevented()).toBe(2);
+      // Option changes the key (Option+Shift+P types ∏): the peek chord matches the physical key.
+      const statusPage = runBridgeScript({ forwardsViewSwitch: true });
+      const peekCode = KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK.code;
+      statusPage.keydown("∏", div, true, { metaKey: true, altKey: true, code: peekCode });
+      expect(statusPage.posted).toEqual([
+        { xumArtifact: 1, type: "sidebarKey", chord: "peek", ctrlKey: false, metaKey: true },
+      ]);
     } finally {
       global.window = saved;
     }
@@ -531,7 +565,7 @@ describe("sidebarKey messages", () => {
       metaKey: false,
     } as const;
     expect(accept(sidebarKey)).toEqual(sidebarKey);
-    for (const chord of ["artifacts", "agentInterface"] as const) {
+    for (const chord of ["artifacts", "agentInterface", "peek"] as const) {
       expect(accept({ ...sidebarKey, chord })).toEqual({ ...sidebarKey, chord });
     }
     for (const data of [
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.ts b/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.ts
index 157eb88acbc..89264ecc437 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/artifactBridge.ts
@@ -29,9 +29,10 @@ import {
  *   frame (focus then sits in it) made unreachable from the keyboard. It can turn annotate mode
  *   on, so the host honours it only during a live user gesture in this frame
  *   (hasLiveUserGesture, SandboxedArtifactFrame.tsx).
- * - Frame -> host: `{ type: "sidebarKey", chord, ctrlKey, metaKey }`, a right-sidebar chord
+ * - Frame -> host: `{ type: "sidebarKey", chord, ctrlKey, metaKey }`, an app chord
  *   (ARTIFACT_FRAME_CHORDS: KEYBINDS.TOGGLE_RIGHT_SIDEBAR or KEYBINDS.OPEN_ARTIFACTS_TAB, and from
- *   the main pane's status page only, KEYBINDS.TOGGLE_AGENT_INTERFACE_VIEW), which a click into
+ *   the main pane's status page only, KEYBINDS.TOGGLE_AGENT_INTERFACE_VIEW and
+ *   KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK), which a click into
  *   the frame also made unreachable: keys in the frame never reach the app's window listener.
  *   The host honours it only while the frame holds focus (SandboxedArtifactFrame.tsx).
  * - Frame -> host: `{ type: "interruptKey", keybind }`, a stream-interrupt key pressed in the
@@ -152,17 +153,26 @@ const ArtifactAnnotateMessageSchema = z
  * only holds focus while the Artifacts tab shows (user request: that key toggles the tab, from
  * anywhere in it). TOGGLE_AGENT_INTERFACE_VIEW switches the main pane between the status page
  * (a frame too) and the chat, so the advertised chord also leaves the page after a click in it;
- * from a frame it only ever switches to the chat (useMainPaneAgentInterfaceView). Only the status
- * page claims it (`forwardsViewSwitch`): it shows only while the switch exists, and in any other
- * frame a claimed chord could do nothing yet still keep the key from the page.
+ * from a frame it only ever switches to the chat (useMainPaneAgentInterfaceView).
+ * TOGGLE_STATUS_TRANSCRIPT_PEEK shows or hides the transcript rows under the status page's bar,
+ * which the page cannot read. Only the status page claims those two (STATUS_PAGE_FRAME_CHORDS,
+ * `forwardsViewSwitch`): it shows only while they work, and in any other frame a claimed chord
+ * could do nothing yet still keep the key from the page.
  */
 export const ARTIFACT_FRAME_CHORDS = {
   sidebar: KEYBINDS.TOGGLE_RIGHT_SIDEBAR,
   artifacts: KEYBINDS.OPEN_ARTIFACTS_TAB,
   agentInterface: KEYBINDS.TOGGLE_AGENT_INTERFACE_VIEW,
+  peek: KEYBINDS.TOGGLE_STATUS_TRANSCRIPT_PEEK,
 } as const satisfies Record<string, Keybind>;
 export type ArtifactFrameChord = keyof typeof ARTIFACT_FRAME_CHORDS;
 
+/** The chords only the main pane's status page forwards, and the host takes from it only. */
+export const STATUS_PAGE_FRAME_CHORDS: ReadonlySet<ArtifactFrameChord> = new Set([
+  "agentInterface",
+  "peek",
+]);
+
 /**
  * A right-sidebar chord (ARTIFACT_FRAME_CHORDS) pressed inside the frame, with the modifiers the
  * host needs to match the keybind exactly (matchesKeybind). See the host side in
@@ -173,7 +183,7 @@ const ArtifactSidebarKeyMessageSchema = z
     ...bridgeEnvelope,
     type: z.literal("sidebarKey"),
     // The host indexes ARTIFACT_FRAME_CHORDS with it, so a name without a keybind fails typecheck.
-    chord: z.enum(["sidebar", "artifacts", "agentInterface"]),
+    chord: z.enum(["sidebar", "artifacts", "agentInterface", "peek"]),
     ctrlKey: z.boolean(),
     metaKey: z.boolean(),
   })
@@ -672,41 +682,47 @@ const INTERRUPT_KEY_LISTENER = `
     }, 0);
   });`;
 
-/**
- * A forwarded chord's key, lowercased. The shim checks only a Ctrl (Cmd on macOS) plus Shift chord
- * of one key, so another keybind shape turns forwarding off (null), like plainSingleKey. The shim
- * tests send the keybind's key.
- */
-function ctrlShiftKey(keybind: Keybind): string | null {
-  const chord =
-    keybind.key.length === 1 &&
-    keybind.code == null &&
+/** The modifiers the shim checks: Ctrl (Cmd on macOS) plus Shift, with or without Alt. */
+function hasFrameChordModifiers(keybind: Keybind): boolean {
+  return (
     keybind.ctrl === true &&
     keybind.shift === true &&
-    keybind.macCtrlBehavior !== "control" &&
-    !keybind.alt &&
-    !keybind.meta;
-  return chord ? keybind.key.toLowerCase() : null;
+    keybind.meta !== true &&
+    keybind.macCtrlBehavior !== "control"
+  );
 }
 
-/** Lowercased key -> chord name, for the chords this frame forwards. */
+/**
+ * A forwarded chord's id in the shim: its one key, lowercased, or with Alt its physical key
+ * ("Alt+KeyP"), since Option changes the key on macOS (Option+Shift+P types ∏). Another keybind
+ * shape turns forwarding off (null), like plainSingleKey. The shim tests send the keybind's key
+ * and code.
+ */
+function frameChordId(keybind: Keybind): string | null {
+  if (!hasFrameChordModifiers(keybind)) return null;
+  if (keybind.alt === true) return keybind.code == null ? null : `Alt+${keybind.code}`;
+  return keybind.key.length === 1 && keybind.code == null ? keybind.key.toLowerCase() : null;
+}
+
+/** Chord id (frameChordId) -> chord name, for the chords this frame forwards. */
 function frameChordKeys(forwardsViewSwitch: boolean): Record<string, ArtifactFrameChord> {
   const keys: Record<string, ArtifactFrameChord> = {};
   for (const chord of Object.keys(ARTIFACT_FRAME_CHORDS) as ArtifactFrameChord[]) {
-    if (chord === "agentInterface" && !forwardsViewSwitch) continue;
-    const key = ctrlShiftKey(ARTIFACT_FRAME_CHORDS[chord]);
-    if (key != null) keys[key] = chord;
+    if (STATUS_PAGE_FRAME_CHORDS.has(chord) && !forwardsViewSwitch) continue;
+    const id = frameChordId(ARTIFACT_FRAME_CHORDS[chord]);
+    if (id != null) keys[id] = chord;
   }
   return keys;
 }
 
 /**
- * The right-sidebar chords, with this platform's modifier as matchesKeybind reads the keybind: on
+ * The forwarded chords, with this platform's modifier as matchesKeybind reads the keybind: on
  * macOS only Cmd (Ctrl may be held too), elsewhere only Ctrl. A keybind that also takes Ctrl on
  * macOS (OPEN_ARTIFACTS_TAB) is forwarded in its Cmd form only. The shim claims nothing else, so
  * the other form of each chord stays the artifact's. The host matches the keybind again (it
  * decides). No editable exclusion: the chords type nothing, and the host's own handlers work from
- * the chat input too. Built per frame: isMac() needs the window.
+ * the chat input too. AltGr reads as Ctrl+Alt and types text, so it stays the page's (as
+ * isAltGraphPressed keeps it out of the host's chords). Built per frame: isMac() needs the window.
  */
 function sidebarKeyListener(forwardsViewSwitch: boolean): string {
   const chordKeys = frameChordKeys(forwardsViewSwitch);
@@ -714,16 +730,20 @@ function sidebarKeyListener(forwardsViewSwitch: boolean): string {
   const modifier = isMac() ? "event.metaKey" : "event.ctrlKey && !event.metaKey";
   return `
   var chordKeys = ${JSON.stringify(chordKeys)};
+  function chordId(event) {
+    if (!event.altKey) return typeof event.key === "string" ? event.key.toLowerCase() : null;
+    if (typeof event.getModifierState === "function" && event.getModifierState("AltGraph")) return null;
+    return typeof event.code === "string" ? "Alt+" + event.code : null;
+  }
   window.addEventListener("keydown", function (event) {
     // A held key would flip the sidebar on every repeat and spend the frame's message budget.
-    if (event.repeat || event.altKey || !event.shiftKey || !(${modifier})) return;
-    if (typeof event.key !== "string") return;
-    var key = event.key.toLowerCase();
+    if (event.repeat || !event.shiftKey || !(${modifier})) return;
+    var id = chordId(event);
     // Own keys only: "constructor" and the like are on every object's prototype.
-    if (!Object.prototype.hasOwnProperty.call(chordKeys, key)) return;
+    if (id === null || !Object.prototype.hasOwnProperty.call(chordKeys, id)) return;
     // Claimed like the host claims it: in a browser, Chrome binds Ctrl+Shift+B to its bookmarks bar.
     event.preventDefault();
-    host.postMessage({ xumArtifact: ${ARTIFACT_BRIDGE_VERSION}, type: "sidebarKey", chord: chordKeys[key], ctrlKey: event.ctrlKey, metaKey: event.metaKey }, "*");
+    host.postMessage({ xumArtifact: ${ARTIFACT_BRIDGE_VERSION}, type: "sidebarKey", chord: chordKeys[id], ctrlKey: event.ctrlKey, metaKey: event.metaKey }, "*");
   }, true);`;
 }
 
@@ -733,7 +753,7 @@ export function buildArtifactBridgeScript(
   initialAppearance: ArtifactAppearance | null = null,
   /** The page has no styles of its own (isUnstyledHtmlDocument): it takes the theme's scheme. */
   followColorScheme = false,
-  /** The main pane's status page: it also forwards the view switch (ARTIFACT_FRAME_CHORDS). */
+  /** The main pane's status page: it also forwards its own chords (STATUS_PAGE_FRAME_CHORDS). */
   forwardsViewSwitch = false
 ): string {
   return `(function () {
diff --git a/src/browser/features/Settings/Sections/KeybindsSection.tsx b/src/browser/features/Settings/Sections/KeybindsSection.tsx
index ade5d0d2a38..2a167e299b4 100644
--- a/src/browser/features/Settings/Sections/KeybindsSection.tsx
+++ b/src/browser/features/Settings/Sections/KeybindsSection.tsx
@@ -70,6 +70,7 @@ const KEYBIND_LABELS: Record<keyof typeof KEYBINDS, string> = {
   OPEN_ARTIFACTS_TAB: "Focus Artifacts tab, or hide the sidebar when focused",
   TOGGLE_AGENT_INTERFACE_VIEW: "Switch between status page and chat (Agent interface view)",
   TOGGLE_STATUS_TRANSCRIPT_PEEK: "Show or hide the transcript on the status page",
+  STATUS_START_HERE: "Start here from the agent's last reply (status page)",
   TOGGLE_ARTIFACT_FULLSCREEN: "Toggle artifact fullscreen (Artifacts tab)",
   NEXT_ARTIFACT: "Next artifact (Artifacts tab)",
   PREV_ARTIFACT: "Previous artifact (Artifacts tab)",
@@ -269,6 +270,7 @@ const KEYBIND_GROUPS: Array<{
       "OPEN_ARTIFACTS_TAB",
       "TOGGLE_AGENT_INTERFACE_VIEW",
       "TOGGLE_STATUS_TRANSCRIPT_PEEK",
+      "STATUS_START_HERE",
       "TOGGLE_ARTIFACT_FULLSCREEN",
       "NEXT_ARTIFACT",
       "PREV_ARTIFACT",
diff --git a/src/browser/utils/ui/keybinds.test.ts b/src/browser/utils/ui/keybinds.test.ts
index b4a5b0edc46..f623c10d631 100644
--- a/src/browser/utils/ui/keybinds.test.ts
+++ b/src/browser/utils/ui/keybinds.test.ts
@@ -447,6 +447,8 @@ describe("global keybind collisions", () => {
     "OPEN_STATS_DIALOG",
     "OPEN_ARTIFACTS_TAB",
     "TOGGLE_AGENT_INTERFACE_VIEW",
+    "TOGGLE_STATUS_TRANSCRIPT_PEEK",
+    "STATUS_START_HERE",
     "SIDEBAR_TAB_1",
     "SIDEBAR_TAB_2",
     "SIDEBAR_TAB_3",
diff --git a/src/browser/utils/ui/keybinds.ts b/src/browser/utils/ui/keybinds.ts
index 1f4e7dd7a53..a0de6b0104b 100644
--- a/src/browser/utils/ui/keybinds.ts
+++ b/src/browser/utils/ui/keybinds.ts
@@ -615,6 +615,9 @@ export const KEYBINDS = {
   /** Agent interface view: show or hide the transcript peek under the status page's bar */
   TOGGLE_STATUS_TRANSCRIPT_PEEK: { key: "p", code: "KeyP", ctrl: true, alt: true, shift: true },
 
+  /** Agent interface view: open Start Here from the agent's last reply, from the status page's bar */
+  STATUS_START_HERE: { key: "h", code: "KeyH", ctrl: true, alt: true, shift: true },
+
   // Artifacts tab shortcuts: only handled while focus is inside the Artifacts panel,
   // like the Review panel's single-key hunk navigation.
   /** Toggle fullscreen for the selected artifact */
diff --git a/src/node/services/agentSkills/builtInSkillContent.generated.ts b/src/node/services/agentSkills/builtInSkillContent.generated.ts
index 897e8a84754..9190ebd351b 100644
--- a/src/node/services/agentSkills/builtInSkillContent.generated.ts
+++ b/src/node/services/agentSkills/builtInSkillContent.generated.ts
@@ -10525,7 +10525,7 @@ export const BUILTIN_SKILL_FILES: Record<string, Record<string, string>> = {
       "- When the workspace has no status page, or the page is empty or cannot be shown (for example a binary file), the main pane shows the chat transcript.",
       "- On the status page, every `window.xum.send` asks first, also from a click: Xum shows the text above the page with **Send** and **Dismiss**. The page shows without you opening it, so its script could otherwise take a click elsewhere in Xum for a click in the page.",
       "",
-      "A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here** starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs.",
+      "A bar above the status page, drawn by Xum and not by the page, shows what the agent is doing now (for example the tool it runs, or **Idle**) and where your last message is: **Queued**, **Held, not sent**, **Sending…**, or **In transcript**. **Show transcript**, or `Ctrl+Alt+Shift+P` (`Cmd+Option+Shift+P` on macOS), opens the newest transcript rows below the bar, and Xum remembers whether it is open. **Start here**, or `Ctrl+Alt+Shift+H` (`Cmd+Option+Shift+H` on macOS), starts a new context from the agent's last reply and keeps earlier history, like **Start Here** on a reply in the chat. It is off while a turn runs. Its shortcut does nothing while focus is in the page, so the page's script cannot open the confirmation while you type in the page.",
       "",
       "### Status page agent",
       "",

From 704f64e40bf30d359bae19f5e60248891d0e1ac4 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:45:38 +0000
Subject: [PATCH 15/18] test(artifacts): check interrupting in the turn-active
 table

Moves the isTurnActive check for a stop in progress from the precedence test
into the table that owns isTurnActive for every phase.
---
 .../RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index ee7ec14810b..aa86fefb242 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -118,7 +118,6 @@ describe("deriveStatusActivity", () => {
     ]) {
       expect(deriveStatusActivity(turn, flags).kind).toBe("interrupting");
     }
-    expect(isTurnActive(deriveStatusActivity(turn, stopping))).toBe(true);
     // A turn still starting shows its startup, and an ended stream leaves no stop to wait for.
     expect(deriveStatusActivity(turn, { ...stopping, isStreamStarting: true }).kind).toBe(
       "starting"
@@ -216,6 +215,7 @@ describe("deriveStatusActivity", () => {
       [{ ...streaming, awaitingUserQuestion: true }, [], true],
       [streaming, [user("go"), tool("bash", "executing")], true],
       [idle, [user("go"), assistant("done")], false],
+      [{ ...streaming, isInterrupting: true }, [user("go"), tool("bash", "executing")], true],
       [{ ...idle, activeBashMonitorCount: 1 }, [user("go"), assistant("watching")], false],
     ];
     for (const [flags, messages, active] of phases) {

From bfcbc5bde1719f3c9651d37ec720a66822b51c3e Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 03:49:28 +0000
Subject: [PATCH 16/18] test(artifacts): check that a held or disabled Start
 here chord is still claimed

The bar claims its chord even when it does nothing, as useBarShortcut's comment
says; no test pinned it, so returning before preventDefault passed.
---
 .../ArtifactsTab/AgentInterfaceStatusView.test.tsx          | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index 69f6402d956..e399de41bf6 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -292,6 +292,7 @@ function pressAltChord(
     value: (modifier: string) => modifier === "AltGraph" && extra.altGraph === true,
   });
   fireEvent(target, event);
+  return event;
 }
 
 /**
@@ -810,11 +811,12 @@ describe("Agent interface status view", () => {
     const dialogShown = () => within(document.body).queryByRole("dialog") != null;
     const startHere = KEYBINDS.STATUS_START_HERE;
 
-    pressAltChord(window, startHere, { repeat: true });
+    // A held chord and the chord mid-turn open nothing, but the bar still claims them.
+    expect(pressAltChord(window, startHere, { repeat: true }).defaultPrevented).toBe(true);
     expect(dialogShown()).toBe(false);
     // Off while a turn runs, as the button is.
     updateSeededWorkspace("ws-bar-start-chord", { messages: MID_TURN, canInterrupt: true });
-    pressAltChord(window, startHere);
+    expect(pressAltChord(window, startHere).defaultPrevented).toBe(true);
     expect(dialogShown()).toBe(false);
 
     updateSeededWorkspace("ws-bar-start-chord", {

From 31248d901f11c408bf007d1cd0b7c244ba4cac6c Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 04:30:29 +0000
Subject: [PATCH 17/18] test(stories): make the status bar mid-turn snapshot
 deterministic

Pixel's flake check saw two renders of StatusBarMidTurn: the chat's streaming
token count read ~15 or ~10. The store refreshes that count on deltas but not
on tool-call-start, so the tool call's tokens showed only when no render ran
between the two events. The tool call now carries no tokens.
---
 src/browser/stories/App.agentInterface.stories.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/browser/stories/App.agentInterface.stories.tsx b/src/browser/stories/App.agentInterface.stories.tsx
index d2295c1a73d..fc8da43d425 100644
--- a/src/browser/stories/App.agentInterface.stories.tsx
+++ b/src/browser/stories/App.agentInterface.stories.tsx
@@ -154,7 +154,9 @@ function setupMidTurn(workspaceId: string) {
           toolCallId: "call-canary-check",
           toolName: "bash",
           args: { script: "sleep 20", display_name: "Canary error rate", timeout_secs: 30 },
-          tokens: 5,
+          // No tokens: the chat's streaming token count refreshes on deltas, not on tool-call-start,
+          // so tokens here showed only when no render ran between the two events (a flaky snapshot).
+          tokens: 0,
           timestamp: STABLE_TIMESTAMP,
         });
       }, 50);

From 2b9b6061783f0cbff0ae11459af9ce7222019168 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Tue, 27 Oct 2026 05:33:46 +0000
Subject: [PATCH 18/18] fix(artifacts): keep Start here on the reply it opened
 for, and off during an armed retry
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The status bar's Start here confirmation now turns OK off when a newer
reply replaces the one it opened for; reopening it confirms the newer
reply. An armed or starting auto-retry shows "Retrying…" and counts as a
running turn, so Start here stays off until the retry is abandoned.
---
 .../AgentInterfaceStatusView.test.tsx         | 62 ++++++++++++++++++-
 .../ArtifactsTab/AgentInterfaceStatusView.tsx |  3 +
 .../agentInterfaceStatusBar.test.ts           | 33 +++++++---
 .../ArtifactsTab/agentInterfaceStatusBar.ts   | 10 +++
 src/browser/hooks/useStartHere.ts             | 37 ++++++++---
 5 files changed, 127 insertions(+), 18 deletions(-)

diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
index e399de41bf6..dbf035bfdfb 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.test.tsx
@@ -234,6 +234,24 @@ const MID_TURN: DisplayedMessage[] = [
   },
 ];
 
+/** MID_TURN once its bash call finished, with no newer reply. */
+const MID_TURN_DONE: DisplayedMessage[] = MID_TURN.map((row) =>
+  row.type === "tool" ? { ...row, status: "completed" } : row
+);
+
+/** The reply a later turn adds after MID_TURN_DONE. */
+const NEWER_REPLY: DisplayedMessage = {
+  type: "assistant",
+  id: "a2",
+  historyId: "a2",
+  content: "The check passed.",
+  historySequence: 4,
+  isStreaming: false,
+  isPartial: false,
+  isCompacted: false,
+  isIdleCompacted: false,
+};
+
 /** The main pane's wiring: the poll and shortcut hook, then the status view it selects. */
 function MainPane(props: { workspaceId: string }) {
   const view = useMainPaneAgentInterfaceView(props.workspaceId);
@@ -747,7 +765,7 @@ describe("Agent interface status view", () => {
     expect(activity.textContent).not.toContain("Slow check");
   });
 
-  test("Start here from the status bar opens the confirmation once the turn ends, and a turn that starts under it turns OK off", async () => {
+  test("Start here from the status bar opens the confirmation once the turn ends, and a turn that starts under it or a newer reply turns OK off", async () => {
     seedWorkspace("ws-bar-idle", { messages: MID_TURN.slice(0, 2) });
     const view = render(<MainPane workspaceId="ws-bar-idle" />, { wrapper: Wrapper });
     await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
@@ -768,6 +786,48 @@ describe("Agent interface status view", () => {
     // under it.
     updateSeededWorkspace("ws-bar-idle", { messages: MID_TURN, canInterrupt: true });
     expect(ok.hasAttribute("disabled")).toBe(true);
+    // OK is back once the turn ends, but not once it leaves a newer reply: the dialog opened for
+    // the older one. Reopened, it is for the newer one.
+    updateSeededWorkspace("ws-bar-idle", { messages: MID_TURN_DONE, canInterrupt: false });
+    expect(ok.hasAttribute("disabled")).toBe(false);
+    updateSeededWorkspace("ws-bar-idle", { messages: [...MID_TURN_DONE, NEWER_REPLY] });
+    expect(ok.hasAttribute("disabled")).toBe(true);
+    fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));
+    fireEvent.click(startHere);
+    const reopened = await within(document.body).findByRole("dialog");
+    expect(within(reopened).getByRole("button", { name: "OK" }).hasAttribute("disabled")).toBe(
+      false
+    );
+  });
+
+  test("an armed auto-retry shows in the status bar and keeps Start here off until it is abandoned", async () => {
+    const failed: DisplayedMessage = {
+      type: "stream-error",
+      id: "e1",
+      historyId: "e1",
+      error: "overloaded",
+      errorType: "unknown",
+      historySequence: 3,
+    };
+    seedWorkspace("ws-bar-retry", {
+      messages: [...MID_TURN.slice(0, 2), failed],
+      autoRetryStatus: {
+        type: "auto-retry-scheduled",
+        attempt: 1,
+        delayMs: 5_000,
+        scheduledAt: Date.now(),
+      },
+    });
+    const view = render(<MainPane workspaceId="ws-bar-retry" />, { wrapper: Wrapper });
+    await waitFor(() => expect(shownPage(view)).toContain("<p>AAAA</p>"));
+    const bar = view.getByTestId("agent-interface-status-bar");
+    expect(within(bar).getByRole("status").textContent).toContain("Retrying");
+    const startHere = within(bar).getByRole("button", { name: "Start here" });
+    expect(startHere.hasAttribute("disabled")).toBe(true);
+    updateSeededWorkspace("ws-bar-retry", {
+      autoRetryStatus: { type: "auto-retry-abandoned", reason: "Stopped" },
+    });
+    expect(startHere.hasAttribute("disabled")).toBe(false);
   });
 
   test("the transcript peek's shortcut opens and closes it, but not on a held chord, AltGr, from the command palette or under a dialog", async () => {
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
index 6419ba766c0..f169dce324f 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
+++ b/src/browser/features/RightSidebar/ArtifactsTab/AgentInterfaceStatusView.tsx
@@ -258,6 +258,7 @@ function StatusBar(props: { workspaceId: string; state: WorkspaceState }) {
     awaitingUserQuestion: state.awaitingUserQuestion,
     activeBashMonitorCount: state.activeBashMonitorCount,
     runtimeStatus: state.runtimeStatus,
+    autoRetryStatus: state.autoRetryStatus,
   });
   const receipt = deriveLastMessageReceipt(state.messages, state.queuedMessage, state.heldInputs);
 
@@ -336,6 +337,8 @@ function StartHereButton(props: {
     sourceAgentId: source?.agentId ?? source?.mode,
     // Off while a turn runs, in the confirmation too: it may have opened before the turn started.
     turnActive: props.turnActive,
+    // The last reply can change under the open confirmation (a monitor wakes the agent).
+    sourceKey: source?.id,
   });
   // SECURITY AUDIT: unlike the peek's chord, the status page's frame does not forward this one.
   // The host honours a forwarded chord during any live gesture in the frame, so the page's
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
index aa86fefb242..d6a2996cbd1 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.test.ts
@@ -86,9 +86,19 @@ const streaming: StatusActivityFlags = {
   isCompacting: false,
   awaitingUserQuestion: false,
   activeBashMonitorCount: 0,
+  autoRetryStatus: null,
 };
 const idle: StatusActivityFlags = { ...streaming, canInterrupt: false };
 
+const errored: DisplayedMessage = {
+  type: "stream-error",
+  id: "e1",
+  historyId: "e1",
+  error: "overloaded",
+  errorType: "unknown",
+  historySequence: 99,
+};
+
 describe("deriveStatusActivity", () => {
   test("a turn that is starting reports starting, with the runtime's breadcrumb when present", () => {
     const flags = { ...streaming, isStreamStarting: true };
@@ -182,14 +192,6 @@ describe("deriveStatusActivity", () => {
 
   test("not streaming is idle, or stopped when the newest row is a stream error", () => {
     expect(deriveStatusActivity([], idle).kind).toBe("idle");
-    const errored: DisplayedMessage = {
-      type: "stream-error",
-      id: "e1",
-      historyId: "e1",
-      error: "overloaded",
-      errorType: "unknown",
-      historySequence: 99,
-    };
     expect(deriveStatusActivity([user("go"), assistant("partial"), errored], idle).kind).toBe(
       "error"
     );
@@ -197,6 +199,16 @@ describe("deriveStatusActivity", () => {
     expect(deriveStatusActivity([user("go"), errored, assistant("done")], idle).kind).toBe("idle");
   });
 
+  test("an armed or starting auto-retry keeps the failed turn running until it is abandoned", () => {
+    const withRetry = (autoRetryStatus: StatusActivityFlags["autoRetryStatus"]) =>
+      deriveStatusActivity([user("go"), errored], { ...idle, autoRetryStatus }).kind;
+    expect(
+      withRetry({ type: "auto-retry-scheduled", attempt: 1, delayMs: 2_000, scheduledAt: 0 })
+    ).toBe("retrying");
+    expect(withRetry({ type: "auto-retry-starting", attempt: 1 })).toBe("retrying");
+    expect(withRetry({ type: "auto-retry-abandoned", reason: "Stopped" })).toBe("error");
+  });
+
   test("after the turn, an armed bash monitor is waited on, not idle", () => {
     const settled = [user("go"), assistant("watching the logs")];
     expect(deriveStatusActivity(settled, { ...idle, activeBashMonitorCount: 2 }).kind).toBe(
@@ -217,6 +229,11 @@ describe("deriveStatusActivity", () => {
       [idle, [user("go"), assistant("done")], false],
       [{ ...streaming, isInterrupting: true }, [user("go"), tool("bash", "executing")], true],
       [{ ...idle, activeBashMonitorCount: 1 }, [user("go"), assistant("watching")], false],
+      [
+        { ...idle, autoRetryStatus: { type: "auto-retry-starting", attempt: 1 } },
+        [user("go"), errored],
+        true,
+      ],
     ];
     for (const [flags, messages, active] of phases) {
       expect(isTurnActive(deriveStatusActivity(messages, flags))).toBe(active);
diff --git a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
index 77a426df595..2ff19fa4e81 100644
--- a/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
+++ b/src/browser/features/RightSidebar/ArtifactsTab/agentInterfaceStatusBar.ts
@@ -1,3 +1,4 @@
+import type { AutoRetryStatus } from "@/browser/utils/messages/autoRetryStatus";
 import type { HeldInput } from "@/common/orpc/types";
 import type { DisplayedMessage, DisplayedUserMessage, QueuedMessage } from "@/common/types/message";
 import type { RuntimeStatusEvent } from "@/common/types/stream";
@@ -34,6 +35,7 @@ export type StatusActivityKind =
   | "thinking"
   | "writing"
   | "working"
+  | "retrying"
   | "monitor"
   | "idle"
   | "error";
@@ -55,6 +57,8 @@ export interface StatusActivityFlags {
   activeBashMonitorCount: number;
   /** The backend's startup breadcrumb (runtime readiness, tool loading), as StreamingBarrier shows it. */
   runtimeStatus?: Pick<RuntimeStatusEvent, "phase" | "detail"> | null;
+  /** The latest auto-retry event after a failed stream, as RetryBarrier shows it. */
+  autoRetryStatus: AutoRetryStatus | null;
 }
 
 type DisplayedTool = Extract<DisplayedMessage, { type: "tool" }>;
@@ -104,6 +108,11 @@ function startingLabel(runtimeStatus: StatusActivityFlags["runtimeStatus"]): str
   return detail != null && detail !== "" ? detail : "Starting…";
 }
 
+/** A retry that is armed or starting resumes the failed turn, as RetryBarrier counts it. */
+function isRetryPending(status: AutoRetryStatus | null): boolean {
+  return status?.type === "auto-retry-scheduled" || status?.type === "auto-retry-starting";
+}
+
 /** After the turn: an armed monitor wakes the agent on matching output, so it is not idle. */
 function settledActivity(
   messages: readonly DisplayedMessage[],
@@ -136,6 +145,7 @@ export function deriveStatusActivity(
   if (flags.isCompacting) return { kind: "compacting", label: "Compacting context…" };
   if (flags.awaitingUserQuestion) return { kind: "question", label: "Waiting for your answer" };
   if (flags.canInterrupt) return streamingActivity(messages);
+  if (isRetryPending(flags.autoRetryStatus)) return { kind: "retrying", label: "Retrying…" };
   return settledActivity(messages, flags.activeBashMonitorCount);
 }
 
diff --git a/src/browser/hooks/useStartHere.ts b/src/browser/hooks/useStartHere.ts
index cee009ebe21..88afd02b7f1 100644
--- a/src/browser/hooks/useStartHere.ts
+++ b/src/browser/hooks/useStartHere.ts
@@ -18,6 +18,12 @@ interface StartHereOptions {
    * landing under the running turn, also from a confirmation opened before the turn started.
    */
   turnActive?: boolean;
+  /**
+   * The row `content` comes from, for a caller whose content can move to a newer row while the
+   * confirmation is open. OK turns off once it moves, so a confirm never starts from a reply the
+   * user did not open it for.
+   */
+  sourceKey?: string;
 }
 
 /**
@@ -56,6 +62,24 @@ async function appendStartHereBoundary(
   }
 }
 
+/** When the button and the open confirmation's OK may start here. */
+function useStartHereGate(workspaceId: string | undefined, options: StartHereOptions | undefined) {
+  // The row the open confirmation is for (StartHereOptions.sourceKey).
+  const [openedSourceKey, setOpenedSourceKey] = useState<string>();
+  // Rendered disabled state follows the barrier, so the button never offers a click that
+  // `openModal`/`executeStartHere` would refuse.
+  const transcriptMutationAllowed = useTranscriptMutationAllowed(workspaceId);
+  // The open dialog follows it too, and the turn state: a replay that drops out, or a turn that
+  // starts, after it opened disables OK (its click and its keybind) rather than letting a confirm
+  // resolve to nothing or land under the turn.
+  const blocked = !transcriptMutationAllowed || options?.turnActive === true;
+  return {
+    blocked,
+    confirmDisabled: blocked || options?.sourceKey !== openedSourceKey,
+    rememberSource: () => setOpenedSourceKey(options?.sourceKey),
+  };
+}
+
 /**
  * Hook for managing Start Here button state and modal.
  * Returns a button config and modal state management.
@@ -74,13 +98,7 @@ export function useStartHere(
   const { api } = useAPI();
   const [isModalOpen, setIsModalOpen] = useState(false);
   const [isStartingHere, setIsStartingHere] = useState(false);
-  // Rendered disabled state follows the barrier, so the button never offers a click that
-  // `openModal`/`executeStartHere` would refuse.
-  const transcriptMutationAllowed = useTranscriptMutationAllowed(workspaceId);
-  // The open dialog follows it too, and the turn state: a replay that drops out, or a turn that
-  // starts, after it opened disables OK (its click and its keybind) rather than letting a confirm
-  // resolve to nothing or land under the turn.
-  const blocked = !transcriptMutationAllowed || options?.turnActive === true;
+  const gate = useStartHereGate(workspaceId, options);
 
   // Opens the confirmation modal
   const openModal = () => {
@@ -88,6 +106,7 @@ export function useStartHere(
     // Start Here rewrites the request window around a row the user sees; refuse while the
     // transcript is not yet a verified copy of history (same barrier as sends and edits).
     if (!isTranscriptMutationAllowed(workspaceId)) return;
+    gate.rememberSource();
     setIsModalOpen(true);
   };
 
@@ -118,14 +137,14 @@ export function useStartHere(
     isOpen: isModalOpen,
     onClose: closeModal,
     onConfirm: executeStartHere,
-    confirmDisabled: blocked,
+    confirmDisabled: gate.confirmDisabled,
   });
 
   return {
     openModal,
     isStartingHere,
     buttonLabel: `Start Here`,
-    disabled: !workspaceId || isStartingHere || isCompacted || blocked,
+    disabled: !workspaceId || isStartingHere || isCompacted || gate.blocked,
     modal, // Pre-configured modal to render
   };
 }