From 46ef7c49900b9726527b4324dda0033f6f715ebd Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:28:38 -0700
Subject: [PATCH 01/17] Drain queued SQLite replies before faulting after a
 main-loop stall (#26444)

* Give Windows Electron writer probes a larger test budget

* Drain queued writer replies across two poll turns before timing out

* Check writer shutdown after both reply-drain turns
---
 .../profile-state-writer-close.test.ts        |  1 +
 .../profile-state-writer-deadline.test.ts     | 37 +++++++++++++------
 .../profile-state-writer-deadline.ts          | 14 ++++---
 .../profile-state-writer-electron-fixture.ts  | 13 ++++++-
 4 files changed, 47 insertions(+), 18 deletions(-)

diff --git a/src/main/persistence/profile-state/profile-state-writer-close.test.ts b/src/main/persistence/profile-state/profile-state-writer-close.test.ts
index a082a1cb4ade..cf8b6a442585 100644
--- a/src/main/persistence/profile-state/profile-state-writer-close.test.ts
+++ b/src/main/persistence/profile-state/profile-state-writer-close.test.ts
@@ -68,6 +68,7 @@ it.each([true, false])(
     await waitForPoll()
     vi.advanceTimersByTime(TIMEOUT_MS)
     await waitForPoll()
+    await waitForPoll()
     expect(worker.terminate).toHaveBeenCalledOnce()
     expect(settled).toBe(false)
     worker.emit('exit', 1)
diff --git a/src/main/persistence/profile-state/profile-state-writer-deadline.test.ts b/src/main/persistence/profile-state/profile-state-writer-deadline.test.ts
index 3a60c019717c..95bd251d6cbb 100644
--- a/src/main/persistence/profile-state/profile-state-writer-deadline.test.ts
+++ b/src/main/persistence/profile-state/profile-state-writer-deadline.test.ts
@@ -13,6 +13,11 @@ import {
 
 const TIMEOUT_MS = 30_000
 
+async function drainTimeoutCheck(): Promise<void> {
+  await waitForPoll()
+  await waitForPoll()
+}
+
 afterEach(() => {
   vi.useRealTimers()
   publishSystemResume()
@@ -48,6 +53,16 @@ function harness() {
 }
 
 describe('profile state writer deadline', () => {
+  it('lets a queued reply clear the deadline after the first poll', async () => {
+    const { deadline, onTimeout, unsubscribe, run } = harness()
+    run(TIMEOUT_MS)
+    setImmediate(() => deadline.clear())
+    await drainTimeoutCheck()
+    expect(onTimeout).not.toHaveBeenCalled()
+    expect(unsubscribe).toHaveBeenCalledOnce()
+    expect(vi.getTimerCount()).toBe(0)
+  })
+
   it('times out a request after allowing queued replies to drain', async () => {
     const { onTimeout, onGrace, unsubscribe, run } = harness()
     run(TIMEOUT_MS - 1)
@@ -55,7 +70,7 @@ describe('profile state writer deadline', () => {
     run(1)
     expect(onGrace).not.toHaveBeenCalled()
     expect(onTimeout).not.toHaveBeenCalled()
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledExactlyOnceWith(
       expect.objectContaining({ overdueMs: 0, graces: 0, powerState: 'awake' })
     )
@@ -74,7 +89,7 @@ describe('profile state writer deadline', () => {
     run(TIMEOUT_MS - 1)
     expect(onTimeout).not.toHaveBeenCalled()
     run(1)
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledExactlyOnceWith(
       expect.objectContaining({ overdueMs: 0, graces: 1 })
     )
@@ -85,7 +100,7 @@ describe('profile state writer deadline', () => {
     stall(PROFILE_STATE_WRITER_OVERDUE_GRACE_MS - 1)
     run(TIMEOUT_MS)
     expect(onGrace).not.toHaveBeenCalled()
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledOnce()
   })
 
@@ -99,7 +114,7 @@ describe('profile state writer deadline', () => {
     stall(60 * 60_000)
     run(TIMEOUT_MS)
     expect(onGrace).toHaveBeenCalledTimes(PROFILE_STATE_WRITER_MAX_GRACES)
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledExactlyOnceWith(
       expect.objectContaining({ graces: PROFILE_STATE_WRITER_MAX_GRACES })
     )
@@ -114,7 +129,7 @@ describe('profile state writer deadline', () => {
     run(TIMEOUT_MS - 1)
     expect(onTimeout).not.toHaveBeenCalled()
     run(1)
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onGrace).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ graces: 1 }))
     expect(onTimeout).toHaveBeenCalledOnce()
   })
@@ -129,7 +144,7 @@ describe('profile state writer deadline', () => {
     expect(onGrace).toHaveBeenCalledTimes(PROFILE_STATE_WRITER_MAX_GRACES)
     expect(onTimeout).not.toHaveBeenCalled()
     run(TIMEOUT_MS)
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledExactlyOnceWith(
       expect.objectContaining({ powerState: 'suspended' })
     )
@@ -148,7 +163,7 @@ describe('profile state writer deadline', () => {
           power().onResume()
         }
         run(1)
-        await waitForPoll()
+        await drainTimeoutCheck()
         expect(onTimeout).toHaveBeenCalledExactlyOnceWith(
           expect.objectContaining({ graces: PROFILE_STATE_WRITER_MAX_GRACES })
         )
@@ -170,7 +185,7 @@ describe('profile state writer deadline', () => {
       run(TIMEOUT_MS)
       // An exhausted resume must not cancel the final queued timeout check.
       power().onResume()
-      await waitForPoll()
+      await drainTimeoutCheck()
       expect(onGrace).toHaveBeenCalledTimes(PROFILE_STATE_WRITER_MAX_GRACES)
       expect(onTimeout).toHaveBeenCalledOnce()
       expect(vi.getTimerCount()).toBe(0)
@@ -183,7 +198,7 @@ describe('profile state writer deadline', () => {
     const { deadline, onTimeout, unsubscribe, run } = harness()
     run(TIMEOUT_MS)
     deadline.clear()
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).not.toHaveBeenCalled()
     expect(unsubscribe).toHaveBeenCalledOnce()
     expect(vi.getTimerCount()).toBe(0)
@@ -193,10 +208,10 @@ describe('profile state writer deadline', () => {
     const { onTimeout, run, power } = harness()
     run(TIMEOUT_MS)
     power().onResume()
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).not.toHaveBeenCalled()
     run(TIMEOUT_MS)
-    await waitForPoll()
+    await drainTimeoutCheck()
     expect(onTimeout).toHaveBeenCalledOnce()
     expect(vi.getTimerCount()).toBe(0)
   })
diff --git a/src/main/persistence/profile-state/profile-state-writer-deadline.ts b/src/main/persistence/profile-state/profile-state-writer-deadline.ts
index fc17faea8b7d..9bc2db835004 100644
--- a/src/main/persistence/profile-state/profile-state-writer-deadline.ts
+++ b/src/main/persistence/profile-state/profile-state-writer-deadline.ts
@@ -97,13 +97,15 @@ export function createProfileStateWriterDeadline(
     ) {
       return
     }
-    // Even an on-time timer can run before a reply already queued by the worker.
+    // Windows can deliver a queued worker reply after the first poll following a stall.
     timeoutCheck = setImmediate(() => {
-      timeoutCheck = undefined
-      if (active) {
-        clear()
-        onTimeout(expiry)
-      }
+      timeoutCheck = setImmediate(() => {
+        timeoutCheck = undefined
+        if (active) {
+          clear()
+          onTimeout(expiry)
+        }
+      })
     })
   }
   // Subscription replays the current state synchronously; only later resumes re-arm.
diff --git a/src/main/persistence/profile-state/profile-state-writer-electron-fixture.ts b/src/main/persistence/profile-state/profile-state-writer-electron-fixture.ts
index e67832e8fc7e..12f946c27bb2 100644
--- a/src/main/persistence/profile-state/profile-state-writer-electron-fixture.ts
+++ b/src/main/persistence/profile-state/profile-state-writer-electron-fixture.ts
@@ -38,19 +38,29 @@ async function run(): Promise<void> {
   const counters = new SharedArrayBuffer(8)
   const counts = new Int32Array(counters)
   const failures: string[] = []
+  let phase = 'initialize'
   const initialization = { databasePath, profileId, revision: 0, counters }
   const client = new ProfileStateWriteWorkerClient(initialization, {
     workerPath: join(root, 'observed-worker.cjs'),
     timeoutMs,
-    onFailure: (error) => failures.push(error.message)
+    onFailure: (error) => {
+      failures.push(error.message)
+      console.error('[writer-fixture] failure', {
+        phase,
+        queuedReplies: Atomics.load(counts, 0),
+        workerStarts: Atomics.load(counts, 1)
+      })
+    }
   })
   const write = (marker: string) =>
     client.writeSerializedDomains([{ domain: 'ui', payload: JSON.stringify({ marker }) }])
   const revisions: number[] = []
   try {
     await client.ready
+    phase = 'before'
     assert.equal(await write('before'), 1)
     for (let cycle = 0; cycle < 4; cycle += 1) {
+      phase = `stall-${cycle}`
       let pending: Promise<number> | undefined
       await new Promise<void>((resolve, reject) => {
         // Dispatch from check so the overdue timer runs before the next poll.
@@ -76,6 +86,7 @@ async function run(): Promise<void> {
       }
       revisions.push(await pending)
     }
+    phase = 'after'
     assert.equal(await write('after'), 6)
   } finally {
     await client.close()

From 69900f023269fd81f51b52b9357d12b4351329f7 Mon Sep 17 00:00:00 2001
From: Neil <neil@stably.ai>
Date: Wed, 7 Oct 2026 22:06:46 -0700
Subject: [PATCH 02/17] Share provider search between workspace creation and
 reference editing

---
 ...spaceNameField-provider-boundaries.test.ts |   2 +-
 ...rkspaceNameField-repo-slug-routing.test.ts |   2 +-
 ...spaceNameField.jira-accessibility.test.tsx |   5 +-
 .../new-workspace/SmartWorkspaceNameField.tsx |   7 -
 .../SmartWorkspaceSourceResultList.tsx        | 166 ++++++++++++++
 .../SmartWorkspaceSourceTabs.tsx              |  57 +++++
 .../base-ref-picker-visibility.ts             |   4 +-
 .../jira-source-status-message.ts             |  43 ++++
 .../new-workspace-composer-card-props.ts      |   6 +-
 .../smart-workspace-localized-options.tsx     |   2 +-
 .../smart-workspace-name-field-copy.ts        |   2 +-
 .../smart-workspace-name-field-model.ts       |  54 +++--
 .../smart-workspace-name-field-surface.tsx    | 119 +---------
 .../smart-workspace-name-input-surface.tsx    |   2 +-
 ...smart-workspace-source-results-surface.tsx | 123 +----------
 .../smart-workspace-source-results.test.ts    |   2 +-
 .../smart-workspace-source-results.ts         |   2 -
 .../use-linear-source-connection.test.tsx     | 182 +++++++++++++++
 .../use-linear-source-connection.ts           |  82 +++++++
 .../use-smart-workspace-field-availability.ts | 161 ++------------
 ...rt-workspace-field-focus-controls.test.tsx |  31 +++
 ...se-smart-workspace-field-focus-controls.ts |  41 ++--
 .../use-smart-workspace-github-search.ts      |  10 +-
 .../use-smart-workspace-gitlab-search.ts      |  14 +-
 .../use-smart-workspace-name-field-actions.ts |  43 ++--
 ...e-smart-workspace-name-field-controller.ts | 207 +++++++-----------
 ...pace-name-field-foundation.source.test.tsx | 167 ++++++++++++++
 .../use-smart-workspace-secondary-searches.ts |  20 +-
 ....ts => use-work-item-source-foundation.ts} |  76 ++++---
 ...s => use-work-item-source-presentation.ts} |  55 +----
 .../use-work-item-source-search.ts            | 155 +++++++++++++
 ...state.ts => use-work-item-source-state.ts} |  24 +-
 .../work-item-source-selection.test.ts        |  69 ++++++
 .../work-item-source-selection.ts             | 103 +++++++++
 .../folder-workspace-composer-helpers.ts      |   2 +-
 ...rkspace-reference-fixtures.test-support.ts |  78 +++++++
 .../composer-state/composer-source-model.ts   |   2 +-
 .../hooks/composer-state/identity-model.ts    |   2 +-
 .../composer-state/issue-source-actions.ts    |   2 +-
 .../workspace-identity-state.ts               |   2 +-
 .../src/i18n/en-runtime-required.json         |   1 -
 41 files changed, 1421 insertions(+), 706 deletions(-)
 create mode 100644 src/renderer/src/components/new-workspace/SmartWorkspaceSourceResultList.tsx
 create mode 100644 src/renderer/src/components/new-workspace/SmartWorkspaceSourceTabs.tsx
 create mode 100644 src/renderer/src/components/new-workspace/jira-source-status-message.ts
 delete mode 100644 src/renderer/src/components/new-workspace/smart-workspace-source-results.ts
 create mode 100644 src/renderer/src/components/new-workspace/use-linear-source-connection.test.tsx
 create mode 100644 src/renderer/src/components/new-workspace/use-linear-source-connection.ts
 create mode 100644 src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.test.tsx
 create mode 100644 src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.source.test.tsx
 rename src/renderer/src/components/new-workspace/{use-smart-workspace-name-field-foundation.ts => use-work-item-source-foundation.ts} (72%)
 rename src/renderer/src/components/new-workspace/{use-smart-workspace-name-field-presentation.ts => use-work-item-source-presentation.ts} (84%)
 create mode 100644 src/renderer/src/components/new-workspace/use-work-item-source-search.ts
 rename src/renderer/src/components/new-workspace/{use-smart-workspace-name-field-state.ts => use-work-item-source-state.ts} (74%)
 create mode 100644 src/renderer/src/components/new-workspace/work-item-source-selection.test.ts
 create mode 100644 src/renderer/src/components/new-workspace/work-item-source-selection.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-fixtures.test-support.ts

diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-provider-boundaries.test.ts b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-provider-boundaries.test.ts
index 51a394e416be..3e1912250d51 100644
--- a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-provider-boundaries.test.ts
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-provider-boundaries.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { canUseGitLabSmartSource } from './SmartWorkspaceNameField'
+import { canUseGitLabSmartSource } from './smart-workspace-provider-availability'
 
 describe('SmartWorkspaceNameField provider boundaries', () => {
   it('advertises local GitLab smart lookup only when local glab is available', () => {
diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-repo-slug-routing.test.ts b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-repo-slug-routing.test.ts
index f2f6d4bd787a..32572a3b7eff 100644
--- a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-repo-slug-routing.test.ts
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField-repo-slug-routing.test.ts
@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { callRuntimeRpc } from '@/runtime/runtime-rpc-client'
 import type * as RuntimeRpcClient from '@/runtime/runtime-rpc-client'
 import type { TaskSourceContext } from '../../../../shared/task-source-context'
-import { getRepoSlugCached } from './SmartWorkspaceNameField'
+import { getRepoSlugCached } from './smart-workspace-repo-slug'
 
 vi.mock('@/runtime/runtime-rpc-client', async (importOriginal) => ({
   ...(await importOriginal<typeof RuntimeRpcClient>()),
diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.jira-accessibility.test.tsx b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.jira-accessibility.test.tsx
index 54c2e0832c74..51018fb8c446 100644
--- a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.jira-accessibility.test.tsx
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.jira-accessibility.test.tsx
@@ -4,9 +4,8 @@ import React, { act } from 'react'
 import { cleanup, createEvent, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { JiraIssue } from '../../../../shared/jira-types'
-import SmartWorkspaceNameField, {
-  type SmartWorkspaceNameSelection
-} from './SmartWorkspaceNameField'
+import SmartWorkspaceNameField from './SmartWorkspaceNameField'
+import type { SmartWorkspaceNameSelection } from './smart-workspace-name-field-model'
 
 const jiraMock = vi.hoisted(() => ({
   retry: vi.fn(),
diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.tsx b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.tsx
index f9165998e5af..4d7c34423fa1 100644
--- a/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.tsx
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceNameField.tsx
@@ -3,13 +3,6 @@ import { renderSmartWorkspaceNameField } from './smart-workspace-name-field-surf
 import type { SmartWorkspaceNameFieldProps } from './smart-workspace-name-field-model'
 import { useSmartWorkspaceNameFieldController } from './use-smart-workspace-name-field-controller'
 
-export type {
-  SmartWorkspaceNameSelection,
-  SmartWorkspaceNameFieldProps
-} from './smart-workspace-name-field-model'
-export { canUseGitLabSmartSource } from './smart-workspace-provider-availability'
-export { getRepoSlugCached } from './smart-workspace-repo-slug'
-
 export default function SmartWorkspaceNameField(
   props: SmartWorkspaceNameFieldProps
 ): React.JSX.Element {
diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceSourceResultList.tsx b/src/renderer/src/components/new-workspace/SmartWorkspaceSourceResultList.tsx
new file mode 100644
index 000000000000..f0c62a5f14e5
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceSourceResultList.tsx
@@ -0,0 +1,166 @@
+import React from 'react'
+import { Button } from '@/components/ui/button'
+import { CommandGroup, CommandItem, CommandList } from '@/components/ui/command'
+import { translate } from '@/i18n/i18n'
+import { cn } from '@/lib/utils'
+import { getSmartWorkspaceEmptyHint } from '../../../../shared/new-workspace/smart-workspace-source-results'
+import { getRowItemClassName, RowIcon, RowLabel } from './smart-workspace-source-row-content'
+import type { RowEntry } from './smart-workspace-name-field-model'
+import type { WorkItemSourceSearch } from './use-work-item-source-search'
+
+export function SmartWorkspaceSourceResultList({
+  model,
+  onSelect,
+  isLinked,
+  beforeResults,
+  emptyHint,
+  isRowDisabled
+}: {
+  model: Pick<
+    WorkItemSourceSearch,
+    | 'mode'
+    | 'mrStateFilters'
+    | 'mrStateFilter'
+    | 'setMrStateFilter'
+    | 'typedTextActionRow'
+    | 'jiraSource'
+    | 'loading'
+    | 'searchResultRows'
+    | 'linearStatusChecked'
+    | 'linearStatus'
+    | 'showJiraSiteContext'
+    | 'jiraConnectionStatus'
+    | 'reserveLinearLoadingResults'
+    | 'showLinearUrlLoadingFeedback'
+  >
+  onSelect: (row: RowEntry) => void
+  isLinked?: (row: RowEntry) => boolean
+  beforeResults?: React.ReactNode
+  emptyHint?: string
+  isRowDisabled?: (row: RowEntry) => boolean
+}): React.JSX.Element {
+  const {
+    mode,
+    mrStateFilters,
+    mrStateFilter,
+    setMrStateFilter,
+    typedTextActionRow,
+    jiraSource,
+    loading,
+    searchResultRows,
+    linearStatusChecked,
+    linearStatus,
+    showJiraSiteContext,
+    jiraConnectionStatus,
+    reserveLinearLoadingResults,
+    showLinearUrlLoadingFeedback
+  } = model
+  return (
+    <>
+      {mode === 'gitlab' ? (
+        // Why: state chips mirror GitLab's merge-request tab strip.
+        <div
+          className="flex shrink-0 items-center gap-1 border-b border-border/40 px-2 py-1.5"
+          onMouseDown={(e) => e.preventDefault()}
+        >
+          {mrStateFilters.map(({ id, label }) => (
+            <Button
+              key={id}
+              type="button"
+              variant={mrStateFilter === id ? 'secondary' : 'ghost'}
+              size="sm"
+              onClick={() => setMrStateFilter(id)}
+              className="h-6 px-2 text-xs"
+            >
+              {label}
+            </Button>
+          ))}
+        </div>
+      ) : null}
+      <CommandList className="!max-h-none min-h-0 flex-1 scrollbar-sleek">
+        {beforeResults}
+        {typedTextActionRow ? (
+          <div
+            className="sticky top-0 z-10 border-b border-border/40 bg-popover p-1"
+            onMouseDown={(event) => event.preventDefault()}
+          >
+            <CommandItem
+              selection="palette"
+              key={typedTextActionRow.value}
+              value={typedTextActionRow.value}
+              onSelect={() => onSelect(typedTextActionRow)}
+              className={getRowItemClassName(typedTextActionRow, { pinnedAction: true })}
+            >
+              <RowIcon row={typedTextActionRow} />
+              <RowLabel row={typedTextActionRow} />
+            </CommandItem>
+          </div>
+        ) : null}
+        {jiraSource.errorKind ? null : reserveLinearLoadingResults ? (
+          <div
+            aria-hidden="true"
+            className={cn('space-y-1 p-1', !showLinearUrlLoadingFeedback && 'invisible')}
+          >
+            {[0, 1, 2].map((index) => (
+              <div
+                key={index}
+                className={cn(
+                  'h-8 rounded bg-muted/40',
+                  showLinearUrlLoadingFeedback && 'animate-pulse'
+                )}
+              />
+            ))}
+          </div>
+        ) : loading && searchResultRows.length === 0 ? (
+          <div className="space-y-1 p-1">
+            {[0, 1, 2].map((index) => (
+              <div key={index} className="h-8 animate-pulse rounded bg-muted/40" />
+            ))}
+          </div>
+        ) : searchResultRows.length === 0 && !typedTextActionRow ? (
+          <div className="px-3 py-6 text-center text-xs text-muted-foreground">
+            {jiraSource.intent
+              ? null
+              : mode === 'linear' && linearStatusChecked && !linearStatus.connected
+                ? translate(
+                    'auto.components.new.workspace.SmartWorkspaceNameField.3e8bb1176a',
+                    'Connect Linear in Settings to search issues.'
+                  )
+                : (emptyHint ?? getSmartWorkspaceEmptyHint(mode))}
+          </div>
+        ) : searchResultRows.length > 0 ? (
+          <CommandGroup className="p-1">
+            {searchResultRows.map((row) => (
+              <CommandItem
+                selection="palette"
+                key={row.value}
+                value={row.value}
+                disabled={isLinked?.(row) || isRowDisabled?.(row)}
+                onSelect={() => onSelect(row)}
+                className={getRowItemClassName(row)}
+              >
+                <RowIcon row={row} />
+                <RowLabel
+                  row={row}
+                  jiraSite={
+                    showJiraSiteContext && row.kind === 'jira'
+                      ? (jiraConnectionStatus?.sites?.find(
+                          (site) => site.id === row.issue.siteId
+                        ) ?? null)
+                      : null
+                  }
+                  showJiraSiteContext={showJiraSiteContext}
+                />
+                {isLinked?.(row) ? (
+                  <span className="ml-auto shrink-0 text-xs text-muted-foreground">
+                    {translate('workspace.links.linkedResult', 'Linked')}
+                  </span>
+                ) : null}
+              </CommandItem>
+            ))}
+          </CommandGroup>
+        ) : null}
+      </CommandList>
+    </>
+  )
+}
diff --git a/src/renderer/src/components/new-workspace/SmartWorkspaceSourceTabs.tsx b/src/renderer/src/components/new-workspace/SmartWorkspaceSourceTabs.tsx
new file mode 100644
index 000000000000..830ad898532b
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/SmartWorkspaceSourceTabs.tsx
@@ -0,0 +1,57 @@
+import React from 'react'
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import type { WorkItemSourceSearch } from './use-work-item-source-search'
+
+export function SmartWorkspaceSourceTabs({
+  model,
+  onModeChange,
+  inputRef,
+  tabsListRef
+}: {
+  model: Pick<WorkItemSourceSearch, 'mode' | 'availableModes'>
+  onModeChange: (mode: WorkItemSourceSearch['mode']) => void
+  inputRef?: React.RefObject<HTMLInputElement | null>
+  tabsListRef?: React.RefObject<HTMLDivElement | null>
+}): React.JSX.Element {
+  return (
+    <div className="flex min-w-0 items-center gap-2 border-b border-border/40">
+      <Tabs
+        value={model.mode}
+        onValueChange={(value) => {
+          const mode = model.availableModes.find((item) => item.id === value)?.id
+          if (mode) {
+            onModeChange(mode)
+          }
+        }}
+        className="min-w-0 flex-1 gap-0"
+      >
+        <TabsList
+          ref={tabsListRef}
+          variant="line"
+          className="h-7 w-full justify-start gap-4 overflow-x-auto overflow-y-hidden px-0 scrollbar-sleek"
+          onFocusCapture={(event) => {
+            const previous = event.relatedTarget instanceof HTMLElement ? event.relatedTarget : null
+            const list = event.currentTarget
+            if (previous && previous !== inputRef?.current && !list.contains(previous)) {
+              event.stopPropagation()
+              inputRef?.current?.focus({ preventScroll: true })
+            }
+          }}
+        >
+          {model.availableModes.map(({ id, label, Icon }) => (
+            <TabsTrigger
+              key={id}
+              value={id}
+              tabIndex={-1}
+              data-smart-name-mode={id}
+              className="flex-none gap-1.5 px-0 text-xs"
+            >
+              <Icon className="size-3.5" />
+              <span>{label}</span>
+            </TabsTrigger>
+          ))}
+        </TabsList>
+      </Tabs>
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/new-workspace/base-ref-picker-visibility.ts b/src/renderer/src/components/new-workspace/base-ref-picker-visibility.ts
index 5a86e8310214..721a6a2af6cf 100644
--- a/src/renderer/src/components/new-workspace/base-ref-picker-visibility.ts
+++ b/src/renderer/src/components/new-workspace/base-ref-picker-visibility.ts
@@ -1,5 +1,5 @@
-import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/SmartWorkspaceNameField'
-import type { SmartNameMode } from './smart-workspace-source-results'
+import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/smart-workspace-name-field-model'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 
 /**
  * Whether the composer offers a base ref for the worktree it is about to create.
diff --git a/src/renderer/src/components/new-workspace/jira-source-status-message.ts b/src/renderer/src/components/new-workspace/jira-source-status-message.ts
new file mode 100644
index 000000000000..95b9537500c4
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/jira-source-status-message.ts
@@ -0,0 +1,43 @@
+import { translate } from '@/i18n/i18n'
+import type { JiraUrlSourceState } from './use-jira-url-source'
+
+export function getJiraSourceStatusMessage(jiraSource: JiraUrlSourceState): string {
+  if (jiraSource.loading) {
+    return translate(
+      'auto.components.new.workspace.SmartWorkspaceNameField.loadingJira',
+      'Loading Jira issue…'
+    )
+  }
+  switch (jiraSource.errorKind) {
+    case 'disconnected':
+      return translate(
+        'auto.components.new.workspace.SmartWorkspaceNameField.jiraDisconnected',
+        'Connect Jira in Settings to link this issue'
+      )
+    case 'site-not-connected':
+      return translate(
+        'auto.components.new.workspace.SmartWorkspaceNameField.jiraSiteNotConnected',
+        'This Jira site is not connected'
+      )
+    case 'update-runtime':
+      return translate(
+        'auto.components.new.workspace.SmartWorkspaceNameField.jiraRuntimeUpdate',
+        'Update the remote runtime to link Jira'
+      )
+    case 'read-failed':
+      return translate(
+        'auto.components.new.workspace.SmartWorkspaceNameField.jiraReadFailed',
+        'Couldn’t load this Jira issue'
+      )
+    case null:
+      return jiraSource.accountChoices.length > 0
+        ? translate(
+            'auto.components.new.workspace.SmartWorkspaceNameField.chooseJiraAccount',
+            'Choose a Jira account'
+          )
+        : translate(
+            'auto.components.new.workspace.SmartWorkspaceNameField.jiraLoaded',
+            'Jira issue loaded'
+          )
+  }
+}
diff --git a/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts b/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
index 21b5c58684ca..a23ac3e22e0e 100644
--- a/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
+++ b/src/renderer/src/components/new-workspace/new-workspace-composer-card-props.ts
@@ -6,9 +6,9 @@ import type {
 } from '@/lib/project-host-setup-options'
 import type { SetupConfig } from '@/lib/new-workspace'
 import type { WorkspaceCreateErrorDisplay } from '@/lib/workspace-create-error-format'
-import type { SmartNameMode } from '@/components/new-workspace/smart-workspace-source-results'
-import type SmartWorkspaceNameField from '@/components/new-workspace/SmartWorkspaceNameField'
-import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/SmartWorkspaceNameField'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
+import type SmartWorkspaceNameField from './SmartWorkspaceNameField'
+import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/smart-workspace-name-field-model'
 import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
 import type { GitLabWorkItem } from '../../../../shared/gitlab-types'
 import type { JiraIssue } from '../../../../shared/jira-types'
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-localized-options.tsx b/src/renderer/src/components/new-workspace/smart-workspace-localized-options.tsx
index 64697e2164d2..44bd03470c87 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-localized-options.tsx
+++ b/src/renderer/src/components/new-workspace/smart-workspace-localized-options.tsx
@@ -3,7 +3,7 @@ import { CaseSensitive, GitBranch, Github, Gitlab, Sparkles } from 'lucide-react
 
 import { JiraIcon } from '@/components/icons/JiraIcon'
 import { translate } from '@/i18n/i18n'
-import type { SmartNameMode } from './smart-workspace-source-results'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 
 export type MrStateFilter = 'opened' | 'merged' | 'closed' | 'all'
 
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-name-field-copy.ts b/src/renderer/src/components/new-workspace/smart-workspace-name-field-copy.ts
index ca171335083f..bae8b68ea6ec 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-name-field-copy.ts
+++ b/src/renderer/src/components/new-workspace/smart-workspace-name-field-copy.ts
@@ -1,5 +1,5 @@
 import { translate } from '@/i18n/i18n'
-import type { SmartNameMode } from './smart-workspace-source-results'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 
 export function getSmartWorkspaceNameFieldCopy({
   repoBackedSourcesDisabled,
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-name-field-model.ts b/src/renderer/src/components/new-workspace/smart-workspace-name-field-model.ts
index c4a85dd95273..52f7b892f84a 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-name-field-model.ts
+++ b/src/renderer/src/components/new-workspace/smart-workspace-name-field-model.ts
@@ -7,7 +7,10 @@ import type { JiraIssue, JiraSite } from '../../../../shared/jira-types'
 import type { LinearIssue } from '../../../../shared/linear/issue-types'
 import type { BaseRefSearchResult } from '../../../../shared/repo-types'
 import type { TaskSourceContext } from '../../../../shared/task-source-context'
-import type { SmartNameMode, SmartWorkspaceSourceRow } from './smart-workspace-source-results'
+import type {
+  SmartNameMode,
+  SmartWorkspaceSourceRow
+} from '../../../../shared/new-workspace/smart-workspace-source-results'
 
 export type RepoOption = ReturnType<typeof useAppStore.getState>['repos'][number]
 
@@ -26,6 +29,8 @@ export type SmartWorkspaceNameFieldProps = {
   onOpenJiraSettings?: () => void
   selectedSource: SmartWorkspaceNameSelection | null
   onClearSelectedSource: () => void
+  gitlabSourceContext?: TaskSourceContext | null
+  linearSourceContext?: TaskSourceContext | null
   githubSourceContext?: TaskSourceContext | null
   jiraSourceContext?: TaskSourceContext | null
   inputRef?: React.RefObject<HTMLInputElement | null>
@@ -41,27 +46,6 @@ export type SmartWorkspaceNameFieldProps = {
   onActiveSourceModeChange?: (mode: SmartNameMode) => void
 }
 
-export type NormalizedSmartWorkspaceNameFieldProps = Omit<
-  SmartWorkspaceNameFieldProps,
-  | 'jiraSourceContext'
-  | 'disabled'
-  | 'textOnly'
-  | 'branchesEnabled'
-  | 'repoBackedSourcesDisabled'
-  | 'repoBackedSearchRepos'
-  | 'allowCrossRepoProjectAdd'
-  | 'crossRepoSwitchTarget'
-> & {
-  jiraSourceContext: TaskSourceContext | null
-  disabled: boolean
-  textOnly: boolean
-  branchesEnabled: boolean
-  repoBackedSourcesDisabled: boolean
-  repoBackedSearchRepos: readonly RepoOption[]
-  allowCrossRepoProjectAdd: boolean
-  crossRepoSwitchTarget: 'project' | 'task-source'
-}
-
 export type SmartWorkspaceNameSelection = {
   kind: 'github-pr' | 'github-issue' | 'gitlab-mr' | 'gitlab-issue' | 'branch' | 'linear' | 'jira'
   label: string
@@ -103,3 +87,29 @@ export type CachedRepoSlug = RepoSlug
 export const EMPTY_REPO_SEARCH_REPOS: readonly RepoOption[] = []
 export const SEARCH_DEBOUNCE_MS = 200
 export const RESULT_LIMIT = 12
+
+export type WorkItemSourceSearchProps = Pick<
+  SmartWorkspaceNameFieldProps,
+  | 'repos'
+  | 'repoId'
+  | 'value'
+  | 'disabled'
+  | 'textOnly'
+  | 'branchesEnabled'
+  | 'repoBackedSourcesDisabled'
+  | 'repoBackedSearchRepos'
+  | 'crossRepoSwitchTarget'
+  | 'githubSourceContext'
+  | 'gitlabSourceContext'
+  | 'linearSourceContext'
+  | 'jiraSourceContext'
+> & { sourceSelected?: boolean; gitlabEnabled?: boolean; typedTextEnabled?: boolean }
+export type NormalizedWorkItemSourceSearchProps = WorkItemSourceSearchProps & {
+  disabled: boolean
+  textOnly: boolean
+  branchesEnabled: boolean
+  repoBackedSourcesDisabled: boolean
+  repoBackedSearchRepos: readonly RepoOption[]
+  crossRepoSwitchTarget: 'project' | 'task-source'
+  jiraSourceContext: TaskSourceContext | null
+}
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-name-field-surface.tsx b/src/renderer/src/components/new-workspace/smart-workspace-name-field-surface.tsx
index 3e14c244ec4b..64dc62e65afa 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-name-field-surface.tsx
+++ b/src/renderer/src/components/new-workspace/smart-workspace-name-field-surface.tsx
@@ -2,74 +2,24 @@ import React from 'react'
 import { Button } from '@/components/ui/button'
 import { Command } from '@/components/ui/command'
 import { Popover, PopoverAnchor } from '@/components/ui/popover'
-import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import { SmartWorkspaceSourceTabs } from './SmartWorkspaceSourceTabs'
 import { cn } from '@/lib/utils'
 import { translate } from '@/i18n/i18n'
 import { WorkspaceEmojiSuggestionPopover } from '@/components/workspace-emoji/WorkspaceEmojiSuggestionPopover'
 import { renderSmartWorkspaceCrossRepoDialog } from './smart-workspace-cross-repo-dialog'
 import { renderSmartWorkspaceNameInput } from './smart-workspace-name-input-surface'
 import { renderSmartWorkspaceSourceResults } from './smart-workspace-source-results-surface'
-import type { JiraUrlSourceState } from './use-jira-url-source'
+import { getJiraSourceStatusMessage } from './jira-source-status-message'
 import type { SmartWorkspaceNameFieldController } from './use-smart-workspace-name-field-controller'
 
-function getJiraSourceStatusMessage(jiraSource: JiraUrlSourceState): string {
-  if (jiraSource.loading) {
-    return translate(
-      'auto.components.new.workspace.SmartWorkspaceNameField.loadingJira',
-      'Loading Jira issue…'
-    )
-  }
-  switch (jiraSource.errorKind) {
-    case 'disconnected':
-      return translate(
-        'auto.components.new.workspace.SmartWorkspaceNameField.jiraDisconnected',
-        'Connect Jira in Settings to link this issue'
-      )
-    case 'site-not-connected':
-      return translate(
-        'auto.components.new.workspace.SmartWorkspaceNameField.jiraSiteNotConnected',
-        'This Jira site is not connected'
-      )
-    case 'update-runtime':
-      return translate(
-        'auto.components.new.workspace.SmartWorkspaceNameField.jiraRuntimeUpdate',
-        'Update the remote runtime to link Jira'
-      )
-    case 'read-failed':
-      return translate(
-        'auto.components.new.workspace.SmartWorkspaceNameField.jiraReadFailed',
-        'Couldn’t load this Jira issue'
-      )
-    case null:
-      return jiraSource.accountChoices.length > 0
-        ? translate(
-            'auto.components.new.workspace.SmartWorkspaceNameField.chooseJiraAccount',
-            'Choose a Jira account'
-          )
-        : translate(
-            'auto.components.new.workspace.SmartWorkspaceNameField.jiraLoaded',
-            'Jira issue loaded'
-          )
-  }
-}
-
 export function renderSmartWorkspaceNameField(
   controller: SmartWorkspaceNameFieldController
 ): React.JSX.Element {
   const {
-    textOnly,
     mode,
-    onActiveSourceModeChange,
-    setMode,
+    localInputRef,
     disabled,
     selectedSource,
-    markSourcePopoverUserEngaged,
-    setOpen,
-    cancelLocalInputFocusFrame,
-    localInputFocusFrameRef,
-    localInputRef,
-    tabsListRef,
-    availableModes,
     open,
     handleSourcePopoverOpenChange,
     resolvedCommandValue,
@@ -90,62 +40,13 @@ export function renderSmartWorkspaceNameField(
 
   return (
     <div className="min-w-0 space-y-1.5">
-      {textOnly ? null : (
-        <div className="flex min-w-0 items-center gap-2 border-b border-border/40">
-          <Tabs
-            value={mode}
-            onValueChange={(next) => {
-              const nextMode = next as typeof mode
-              onActiveSourceModeChange?.(nextMode)
-              setMode(nextMode)
-              if (!disabled && nextMode !== 'text' && selectedSource === null) {
-                markSourcePopoverUserEngaged()
-                setOpen(true)
-              } else {
-                setOpen(false)
-              }
-              cancelLocalInputFocusFrame()
-              localInputFocusFrameRef.current = requestAnimationFrame(() => {
-                localInputFocusFrameRef.current = null
-                localInputRef.current?.focus({ preventScroll: true })
-              })
-            }}
-            className="min-w-0 flex-1 gap-0"
-          >
-            <TabsList
-              ref={tabsListRef}
-              variant="line"
-              className="h-7 w-full justify-start gap-4 overflow-x-auto overflow-y-hidden px-0 scrollbar-sleek"
-              onFocusCapture={(event) => {
-                // Why: Radix roving focus races commits, so forward external Tab focus to the input.
-                const previous = event.relatedTarget as HTMLElement | null
-                const list = tabsListRef.current
-                const input = localInputRef.current
-                if (!list || !input) {
-                  return
-                }
-                if (!previous || previous === input || list.contains(previous)) {
-                  return
-                }
-                event.stopPropagation()
-                input.focus({ preventScroll: true })
-              }}
-            >
-              {availableModes.map(({ id, label, Icon }) => (
-                <TabsTrigger
-                  key={id}
-                  value={id}
-                  tabIndex={-1}
-                  data-smart-name-mode={id}
-                  className="flex-none gap-1.5 px-0 text-xs"
-                >
-                  <Icon className="size-3.5" />
-                  <span>{label}</span>
-                </TabsTrigger>
-              ))}
-            </TabsList>
-          </Tabs>
-        </div>
+      {controller.textOnly ? null : (
+        <SmartWorkspaceSourceTabs
+          model={controller}
+          onModeChange={controller.handleModeChange}
+          inputRef={controller.localInputRef}
+          tabsListRef={controller.tabsListRef}
+        />
       )}
       <Popover
         open={!disabled && open && mode !== 'text' && selectedSource === null}
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-name-input-surface.tsx b/src/renderer/src/components/new-workspace/smart-workspace-name-input-surface.tsx
index d43695e1c013..ffe9e4ad2154 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-name-input-surface.tsx
+++ b/src/renderer/src/components/new-workspace/smart-workspace-name-input-surface.tsx
@@ -4,7 +4,7 @@ import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { isImeCompositionKeyDown } from '@/lib/ime-composition-keyboard-event'
-import { isBlockingJiraUrlIntent } from './smart-workspace-source-results'
+import { isBlockingJiraUrlIntent } from '../../../../shared/new-workspace/smart-workspace-source-results'
 import { isBlockingLinearUrlIntent } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
 import { isComposerFieldToFieldFocus } from './smart-workspace-source-popover-focus'
 import { replaceCompletedWorkspaceEmojiShortcode } from '@/lib/workspace-emoji-shortcodes'
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-source-results-surface.tsx b/src/renderer/src/components/new-workspace/smart-workspace-source-results-surface.tsx
index 54402492d6b4..f60c78210a50 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-source-results-surface.tsx
+++ b/src/renderer/src/components/new-workspace/smart-workspace-source-results-surface.tsx
@@ -1,35 +1,12 @@
 import React from 'react'
-import { Button } from '@/components/ui/button'
-import { CommandGroup, CommandItem, CommandList } from '@/components/ui/command'
+import { SmartWorkspaceSourceResultList } from './SmartWorkspaceSourceResultList'
 import { PopoverContent } from '@/components/ui/popover'
-import { translate } from '@/i18n/i18n'
-import { cn } from '@/lib/utils'
-import { getSmartWorkspaceEmptyHint } from './smart-workspace-source-results'
-import { getRowItemClassName, RowIcon, RowLabel } from './smart-workspace-source-row-content'
 import type { SmartWorkspaceNameFieldController } from './use-smart-workspace-name-field-controller'
 
 export function renderSmartWorkspaceSourceResults(
   controller: SmartWorkspaceNameFieldController
 ): React.JSX.Element {
-  const {
-    localInputRef,
-    tabsListRef,
-    mode,
-    mrStateFilters,
-    mrStateFilter,
-    setMrStateFilter,
-    typedTextActionRow,
-    handleSelect,
-    jiraSource,
-    loading,
-    searchResultRows,
-    linearStatusChecked,
-    linearStatus,
-    showJiraSiteContext,
-    jiraConnectionStatus,
-    reserveLinearLoadingResults,
-    showLinearUrlLoadingFeedback
-  } = controller
+  const { localInputRef, tabsListRef } = controller
 
   return (
     <PopoverContent
@@ -56,101 +33,7 @@ export function renderSmartWorkspaceSourceResults(
         }
       }}
     >
-      {mode === 'gitlab' ? (
-        // Why: state chips mirror GitLab's merge-request tab strip.
-        <div
-          className="flex shrink-0 items-center gap-1 border-b border-border/40 px-2 py-1.5"
-          onMouseDown={(e) => e.preventDefault()}
-        >
-          {mrStateFilters.map(({ id, label }) => (
-            <Button
-              key={id}
-              type="button"
-              variant={mrStateFilter === id ? 'secondary' : 'ghost'}
-              size="sm"
-              onClick={() => setMrStateFilter(id)}
-              className="h-6 px-2 text-xs"
-            >
-              {label}
-            </Button>
-          ))}
-        </div>
-      ) : null}
-      <CommandList className="!max-h-none min-h-0 flex-1 scrollbar-sleek">
-        {typedTextActionRow ? (
-          <div
-            className="sticky top-0 z-10 border-b border-border/40 bg-popover p-1"
-            onMouseDown={(event) => event.preventDefault()}
-          >
-            <CommandItem
-              key={typedTextActionRow.value}
-              value={typedTextActionRow.value}
-              onSelect={() => handleSelect(typedTextActionRow)}
-              className={getRowItemClassName(typedTextActionRow, { pinnedAction: true })}
-            >
-              <RowIcon row={typedTextActionRow} />
-              <RowLabel row={typedTextActionRow} />
-            </CommandItem>
-          </div>
-        ) : null}
-        {jiraSource.errorKind ? null : reserveLinearLoadingResults ? (
-          <div
-            aria-hidden="true"
-            className={cn('space-y-1 p-1', !showLinearUrlLoadingFeedback && 'invisible')}
-          >
-            {[0, 1, 2].map((index) => (
-              <div
-                key={index}
-                className={cn(
-                  'h-8 rounded bg-muted/40',
-                  showLinearUrlLoadingFeedback && 'animate-pulse'
-                )}
-              />
-            ))}
-          </div>
-        ) : loading && searchResultRows.length === 0 ? (
-          <div className="space-y-1 p-1">
-            {[0, 1, 2].map((index) => (
-              <div key={index} className="h-8 animate-pulse rounded bg-muted/40" />
-            ))}
-          </div>
-        ) : searchResultRows.length === 0 && !typedTextActionRow ? (
-          <div className="px-3 py-6 text-center text-xs text-muted-foreground">
-            {jiraSource.intent
-              ? null
-              : mode === 'linear' && linearStatusChecked && !linearStatus.connected
-                ? translate(
-                    'auto.components.new.workspace.SmartWorkspaceNameField.3e8bb1176a',
-                    'Connect Linear in Settings to search issues.'
-                  )
-                : getSmartWorkspaceEmptyHint(mode)}
-          </div>
-        ) : searchResultRows.length > 0 ? (
-          <CommandGroup className="p-1">
-            {searchResultRows.map((row) => (
-              <CommandItem
-                key={row.value}
-                value={row.value}
-                onSelect={() => handleSelect(row)}
-                className={getRowItemClassName(row)}
-              >
-                <RowIcon row={row} />
-                <RowLabel
-                  row={row}
-                  jiraSite={
-                    showJiraSiteContext && row.kind === 'jira'
-                      ? (jiraConnectionStatus?.sites?.find(
-                          (site) => site.id === row.issue.siteId
-                        ) ?? null)
-                      : null
-                  }
-                  showJiraSiteContext={showJiraSiteContext}
-                />
-              </CommandItem>
-            ))}
-          </CommandGroup>
-        ) : null}
-      </CommandList>
+      <SmartWorkspaceSourceResultList model={controller} onSelect={controller.handleSelect} />
     </PopoverContent>
   )
 }
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-source-results.test.ts b/src/renderer/src/components/new-workspace/smart-workspace-source-results.test.ts
index b2d2b8a10976..67daefc0e108 100644
--- a/src/renderer/src/components/new-workspace/smart-workspace-source-results.test.ts
+++ b/src/renderer/src/components/new-workspace/smart-workspace-source-results.test.ts
@@ -9,7 +9,7 @@ import {
   isBlockingJiraUrlIntent,
   isBlockingTaskUrlResolution,
   shouldHoldSourceResultsForQuery
-} from './smart-workspace-source-results'
+} from '../../../../shared/new-workspace/smart-workspace-source-results'
 import {
   getSmartWorkspaceLinearSearchQuery,
   isBlockingLinearUrlIntent,
diff --git a/src/renderer/src/components/new-workspace/smart-workspace-source-results.ts b/src/renderer/src/components/new-workspace/smart-workspace-source-results.ts
deleted file mode 100644
index afa2d10651f1..000000000000
--- a/src/renderer/src/components/new-workspace/smart-workspace-source-results.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-// Re-export shim: the implementation moved to src/shared so mobile can share it.
-export * from '../../../../shared/new-workspace/smart-workspace-source-results'
diff --git a/src/renderer/src/components/new-workspace/use-linear-source-connection.test.tsx b/src/renderer/src/components/new-workspace/use-linear-source-connection.test.tsx
new file mode 100644
index 000000000000..09521348ae01
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-linear-source-connection.test.tsx
@@ -0,0 +1,182 @@
+// @vitest-environment happy-dom
+
+import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+import type { TaskSourceContext } from '../../../../shared/task-source-context'
+import type { LinearConnectionStatus } from '../../../../shared/linear/workspace-types'
+import { useLinearSourceConnection } from './use-linear-source-connection'
+
+const mocks = vi.hoisted(() => ({ linearStatus: vi.fn() }))
+vi.mock('@/runtime/runtime-linear-client', () => mocks)
+type ConnectionState = {
+  runtimeStatusByEnvironmentId: Map<
+    string,
+    { connectionGeneration?: number; hostContactEpoch?: number }
+  >
+  linearStatus: LinearConnectionStatus
+  linearStatusContextKey: string | null
+}
+const store = createStore<ConnectionState>(() => ({
+  runtimeStatusByEnvironmentId: new Map(),
+  linearStatus: { connected: false, viewer: null },
+  linearStatusContextKey: null
+}))
+vi.mock('@/store', () => ({
+  useAppStore: (selector: (state: ConnectionState) => unknown) => useStore(store, selector)
+}))
+
+function context(hostId: TaskSourceContext['hostId']): TaskSourceContext {
+  return {
+    kind: 'task-source',
+    provider: 'linear',
+    projectId: 'project-1',
+    hostId,
+    repoId: 'repo-1',
+    accountLabel: null,
+    providerIdentity: null
+  }
+}
+
+function status(connected: boolean): LinearConnectionStatus {
+  return { connected, viewer: null }
+}
+
+describe('useLinearSourceConnection', () => {
+  afterEach(cleanup)
+  beforeEach(() => {
+    vi.clearAllMocks()
+    store.setState({
+      runtimeStatusByEnvironmentId: new Map(),
+      linearStatus: status(false),
+      linearStatusContextKey: null
+    })
+  })
+
+  it('reads the explicit source host independently of focused runtime status', async () => {
+    const source = context('runtime:source-host')
+    mocks.linearStatus.mockResolvedValue(status(true))
+    const { result } = renderHook(() =>
+      useLinearSourceConnection({ enabled: true, sourceContext: source })
+    )
+    expect(result.current).toEqual({ status: null, loaded: false })
+    await waitFor(() => expect(result.current.status?.connected).toBe(true))
+    expect(result.current.loaded).toBe(true)
+    expect(mocks.linearStatus).toHaveBeenCalledWith(source)
+  })
+
+  it('does not add reads to existing consumers without an explicit source', async () => {
+    renderHook(() => useLinearSourceConnection({ enabled: true, sourceContext: null }))
+    renderHook(() => useLinearSourceConnection({ enabled: false, sourceContext: context('local') }))
+    await act(async () => {})
+    expect(mocks.linearStatus).not.toHaveBeenCalled()
+  })
+
+  it('keeps equivalent source objects from refetching on every renderer update', async () => {
+    mocks.linearStatus.mockResolvedValue(status(true))
+    const { result, rerender } = renderHook(() =>
+      useLinearSourceConnection({ enabled: true, sourceContext: context('local') })
+    )
+    await waitFor(() => expect(result.current.loaded).toBe(true))
+    const loaded = result.current
+    rerender()
+    expect(result.current).toBe(loaded)
+    expect(mocks.linearStatus).toHaveBeenCalledTimes(1)
+  })
+
+  it('hides old status immediately and rejects late responses after a host switch', async () => {
+    let resolveOld: (value: LinearConnectionStatus) => void = () => {}
+    const oldRead = new Promise<LinearConnectionStatus>((resolve) => {
+      resolveOld = resolve
+    })
+    mocks.linearStatus.mockReturnValueOnce(oldRead).mockResolvedValueOnce(status(false))
+    const { result, rerender } = renderHook(
+      ({ source }) => useLinearSourceConnection({ enabled: true, sourceContext: source }),
+      { initialProps: { source: context('local') } }
+    )
+    rerender({ source: context('runtime:new-host') })
+    expect(result.current).toEqual({ status: null, loaded: false })
+    await waitFor(() => expect(result.current.loaded).toBe(true))
+    await act(async () => {
+      resolveOld(status(true))
+      await oldRead
+    })
+    expect(result.current.status?.connected).toBe(false)
+  })
+
+  it('settles failed status reads as disconnected', async () => {
+    mocks.linearStatus.mockRejectedValue(new Error('Host unavailable'))
+    const { result } = renderHook(() =>
+      useLinearSourceConnection({ enabled: true, sourceContext: context('runtime:offline') })
+    )
+    await waitFor(() => expect(result.current.loaded).toBe(true))
+    expect(result.current.status?.connected).toBe(false)
+  })
+
+  it.each(['hostContactEpoch', 'connectionGeneration'] as const)(
+    'retries a failed saved-host read when %s advances without changing focus',
+    async (revision) => {
+      mocks.linearStatus.mockRejectedValueOnce(new Error('Offline')).mockResolvedValue(status(true))
+      const { result } = renderHook(() =>
+        useLinearSourceConnection({ enabled: true, sourceContext: context('runtime:saved-host') })
+      )
+      await waitFor(() => expect(result.current.status?.connected).toBe(false))
+      act(() => {
+        store.setState({
+          runtimeStatusByEnvironmentId: new Map([['saved-host', { [revision]: 1 }]])
+        })
+      })
+      await waitFor(() => expect(result.current.status?.connected).toBe(true))
+      expect(mocks.linearStatus).toHaveBeenCalledTimes(2)
+    }
+  )
+
+  it('rejects an earlier status read after the same host reconnects', async () => {
+    let resolveOld: (value: LinearConnectionStatus) => void = () => {}
+    const oldRead = new Promise<LinearConnectionStatus>((resolve) => {
+      resolveOld = resolve
+    })
+    mocks.linearStatus.mockReturnValueOnce(oldRead).mockResolvedValueOnce(status(true))
+    const { result } = renderHook(() =>
+      useLinearSourceConnection({ enabled: true, sourceContext: context('runtime:saved-host') })
+    )
+    act(() => {
+      store.setState({
+        runtimeStatusByEnvironmentId: new Map([['saved-host', { hostContactEpoch: 1 }]])
+      })
+    })
+    await waitFor(() => expect(result.current.status?.connected).toBe(true))
+    await act(async () => {
+      resolveOld(status(false))
+      await oldRead
+    })
+    expect(result.current.status?.connected).toBe(true)
+  })
+
+  it('refreshes matching-host workspace changes without borrowing another host status', async () => {
+    mocks.linearStatus.mockResolvedValue({ ...status(true), selectedWorkspaceId: 'original' })
+    const { result } = renderHook(() =>
+      useLinearSourceConnection({ enabled: true, sourceContext: context('runtime:saved-host') })
+    )
+    await waitFor(() => expect(result.current.loaded).toBe(true))
+    act(() => {
+      store.setState({
+        linearStatusContextKey: 'runtime:other-host#0',
+        linearStatus: { ...status(true), selectedWorkspaceId: 'other' },
+        runtimeStatusByEnvironmentId: new Map([['other-host', { hostContactEpoch: 1 }]])
+      })
+    })
+    expect(result.current.status?.selectedWorkspaceId).toBe('original')
+    expect(mocks.linearStatus).toHaveBeenCalledTimes(1)
+    mocks.linearStatus.mockResolvedValue({ ...status(true), selectedWorkspaceId: 'updated' })
+    act(() => {
+      store.setState({
+        linearStatusContextKey: 'runtime:saved-host#0',
+        linearStatus: { ...status(true), selectedWorkspaceId: 'updated' }
+      })
+    })
+    await waitFor(() => expect(result.current.status?.selectedWorkspaceId).toBe('updated'))
+    expect(mocks.linearStatus).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/src/renderer/src/components/new-workspace/use-linear-source-connection.ts b/src/renderer/src/components/new-workspace/use-linear-source-connection.ts
new file mode 100644
index 000000000000..1630027de128
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-linear-source-connection.ts
@@ -0,0 +1,82 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { linearStatus } from '@/runtime/runtime-linear-client'
+import { useAppStore } from '@/store'
+import { getProviderRuntimeContextKey } from '@/lib/provider-runtime-context'
+import {
+  getTaskSourceCacheScope,
+  getTaskSourceRuntimeSettings,
+  type TaskSourceContext
+} from '../../../../shared/task-source-context'
+import type { LinearConnectionStatus } from '../../../../shared/linear/workspace-types'
+
+type LinearSourceConnection = {
+  status: LinearConnectionStatus | null
+  loaded: boolean
+}
+
+const UNLOADED_CONNECTION: LinearSourceConnection = { status: null, loaded: false }
+
+export function useLinearSourceConnection(args: {
+  enabled: boolean
+  sourceContext: TaskSourceContext | null
+}): LinearSourceConnection {
+  const scope = args.sourceContext ? getTaskSourceCacheScope(args.sourceContext) : null
+  const runtimeSettings = getTaskSourceRuntimeSettings(args.sourceContext)
+  const environmentId = runtimeSettings.activeRuntimeEnvironmentId
+  const runtimeRevision = useAppStore((state) => {
+    const runtime = environmentId ? state.runtimeStatusByEnvironmentId?.get(environmentId) : null
+    return `${runtime?.connectionGeneration ?? 0}:${runtime?.hostContactEpoch ?? 0}`
+  })
+  const statusContextKey = getProviderRuntimeContextKey(runtimeSettings)
+  const sourceStoreStatus = useAppStore((state) =>
+    scope && state.linearStatusContextKey === statusContextKey ? state.linearStatus : null
+  )
+  const sourceRef = useRef(args.sourceContext)
+  useLayoutEffect(() => {
+    sourceRef.current = args.sourceContext
+  })
+  const [state, setState] = useState<{
+    scope: string | null
+    runtimeRevision: string
+    sourceStoreStatus: LinearConnectionStatus | null
+    status: LinearConnectionStatus | null
+  }>({ scope: null, runtimeRevision, sourceStoreStatus, status: null })
+
+  useEffect(() => {
+    const source = sourceRef.current
+    if (!args.enabled || !source || !scope) {
+      return
+    }
+    let stale = false
+    void linearStatus(source)
+      .then((status) => {
+        if (!stale) {
+          setState({ scope, runtimeRevision, sourceStoreStatus, status })
+        }
+      })
+      .catch(() => {
+        if (!stale) {
+          setState({
+            scope,
+            runtimeRevision,
+            sourceStoreStatus,
+            status: { connected: false, viewer: null }
+          })
+        }
+      })
+    return () => {
+      stale = true
+    }
+  }, [args.enabled, scope, runtimeRevision, sourceStoreStatus])
+
+  return useMemo(
+    () =>
+      scope !== null &&
+      state.scope === scope &&
+      state.runtimeRevision === runtimeRevision &&
+      state.sourceStoreStatus === sourceStoreStatus
+        ? { status: state.status, loaded: true }
+        : UNLOADED_CONNECTION,
+    [scope, state, runtimeRevision, sourceStoreStatus]
+  )
+}
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-field-availability.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-field-availability.ts
index 1f48e4ce5d35..c5ba8926a3cd 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-field-availability.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-field-availability.ts
@@ -4,13 +4,12 @@ import type { ExecutionHostId } from '../../../../shared/execution-host'
 import { getMrStateFilters, getSmartWorkspaceNameModes } from './smart-workspace-localized-options'
 import {
   SEARCH_DEBOUNCE_MS,
-  type NormalizedSmartWorkspaceNameFieldProps
+  type NormalizedWorkItemSourceSearchProps
 } from './smart-workspace-name-field-model'
 import { canUseGitLabSmartSource } from './smart-workspace-provider-availability'
-import { useSmartWorkspaceFieldFocusControls } from './use-smart-workspace-field-focus-controls'
-import type { useSmartWorkspaceNameFieldState } from './use-smart-workspace-name-field-state'
+import type { useWorkItemSourceState } from './use-work-item-source-state'
 
-type FieldState = ReturnType<typeof useSmartWorkspaceNameFieldState>
+type FieldState = ReturnType<typeof useWorkItemSourceState>
 
 export function useSmartWorkspaceFieldAvailability({
   props,
@@ -26,7 +25,7 @@ export function useSmartWorkspaceFieldAvailability({
   checkLinearConnection,
   jiraSourceConnected
 }: {
-  props: NormalizedSmartWorkspaceNameFieldProps
+  props: NormalizedWorkItemSourceSearchProps
   state: FieldState
   repoBackedSearchTargets: {
     gitlabSourceContext: { hostId?: ExecutionHostId | null } | null
@@ -41,37 +40,8 @@ export function useSmartWorkspaceFieldAvailability({
   checkLinearConnection: () => Promise<void>
   jiraSourceConnected: boolean
 }) {
-  const {
-    disabled,
-    textOnly,
-    repoBackedSourcesDisabled,
-    branchesEnabled,
-    onActiveSourceModeChange,
-    value
-  } = props
-  const {
-    mode,
-    setMode,
-    setOpen,
-    setGithubItems,
-    setGitlabItems,
-    setBranches,
-    setGithubLoading,
-    setGitlabLoading,
-    setBranchesLoading,
-    setBranchResultsSource,
-    setCrossRepoPrompt,
-    setLinearIssues,
-    setJiraIssues,
-    setLinearLoading,
-    setJiraLoading,
-    setCommandValue,
-    setDebouncedQuery
-  } = state
-
-  useEffect(() => {
-    onActiveSourceModeChange?.(mode)
-  }, [mode, onActiveSourceModeChange])
+  const { disabled, textOnly, repoBackedSourcesDisabled, branchesEnabled, value } = props
+  const { mode: storedMode, setMode, setDebouncedQuery } = state
   const preflightStatusCurrent = preflightStatusContextKey === expectedPreflightContextKey
   const localGitlabAvailable = preflightStatusCurrent && preflightStatus?.glab?.installed === true
   const gitlabSourceAvailable = repoBackedSearchTargets.some((target) =>
@@ -109,42 +79,17 @@ export function useSmartWorkspaceFieldAvailability({
     if (item.id === 'branches') {
       return branchesEnabled && !repoBackedSourcesDisabled
     }
-    return true
+    return item.id !== 'text' || props.typedTextEnabled === true
   })
-  const mrStateFilters = getMrStateFilters()
-
+  const mode = availableModes.some((item) => item.id === storedMode)
+    ? storedMode
+    : (availableModes[0]?.id ?? 'text')
   useEffect(() => {
-    if (availableModes.some((item) => item.id === mode)) {
-      return
+    if (storedMode !== mode) {
+      setMode(mode)
     }
-    setMode(availableModes[0]?.id ?? 'text')
-  }, [availableModes, mode, setMode])
-
-  useEffect(() => {
-    if (!repoBackedSourcesDisabled) {
-      return
-    }
-    setGithubItems([])
-    setGitlabItems([])
-    setBranches([])
-    setGithubLoading(false)
-    setGitlabLoading(false)
-    setBranchesLoading(false)
-    setBranchResultsSource(null)
-    setCrossRepoPrompt(null)
-  }, [
-    repoBackedSourcesDisabled,
-    setBranches,
-    setBranchesLoading,
-    setBranchResultsSource,
-    setCrossRepoPrompt,
-    setGithubItems,
-    setGithubLoading,
-    setGitlabItems,
-    setGitlabLoading
-  ])
-
-  const focusControls = useSmartWorkspaceFieldFocusControls({ props, state })
+  }, [storedMode, setMode, mode])
+  const mrStateFilters = getMrStateFilters()
 
   useEffect(() => {
     if (disabled || textOnly) {
@@ -166,90 +111,16 @@ export function useSmartWorkspaceFieldAvailability({
     textOnly
   ])
 
-  useEffect(() => {
-    if (textOnly) {
-      if (mode !== 'text') {
-        setMode('text')
-      }
-      setOpen(false)
-      return
-    }
-    if ((mode === 'gitlab' && gitlabSourceAvailable) || (mode === 'linear' && linearAvailable)) {
-      return
-    }
-    if (mode !== 'gitlab' && mode !== 'linear') {
-      return
-    }
-    setMode('smart')
-    setGitlabItems([])
-    setLinearIssues([])
-    setJiraIssues([])
-    setGitlabLoading(false)
-    setLinearLoading(false)
-    setJiraLoading(false)
-    setCommandValue('')
-  }, [
-    gitlabSourceAvailable,
-    linearAvailable,
-    mode,
-    setCommandValue,
-    setGitlabItems,
-    setGitlabLoading,
-    setJiraIssues,
-    setJiraLoading,
-    setLinearIssues,
-    setLinearLoading,
-    setMode,
-    setOpen,
-    textOnly
-  ])
-
-  useEffect(() => {
-    if (!disabled) {
-      return
-    }
-    setOpen(false)
-    setGithubItems([])
-    setGitlabItems([])
-    setBranches([])
-    setBranchResultsSource(null)
-    setLinearIssues([])
-    setJiraIssues([])
-    setGithubLoading(false)
-    setGitlabLoading(false)
-    setBranchesLoading(false)
-    setLinearLoading(false)
-    setJiraLoading(false)
-    setCommandValue('')
-    setCrossRepoPrompt(null)
-  }, [
-    disabled,
-    setBranches,
-    setBranchesLoading,
-    setBranchResultsSource,
-    setCommandValue,
-    setCrossRepoPrompt,
-    setGithubItems,
-    setGithubLoading,
-    setGitlabItems,
-    setGitlabLoading,
-    setJiraIssues,
-    setJiraLoading,
-    setLinearIssues,
-    setLinearLoading,
-    setOpen
-  ])
-
   useEffect(() => {
     const timer = window.setTimeout(() => setDebouncedQuery(value), SEARCH_DEBOUNCE_MS)
     return () => window.clearTimeout(timer)
   }, [setDebouncedQuery, value])
 
   return {
+    mode,
     gitlabSourceAvailable,
     linearAvailable,
     availableModes,
-    mrStateFilters,
-    ...focusControls
+    mrStateFilters
   }
 }
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.test.tsx b/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.test.tsx
new file mode 100644
index 000000000000..9eb1ec031478
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.test.tsx
@@ -0,0 +1,31 @@
+// @vitest-environment happy-dom
+import { act, renderHook } from '@testing-library/react'
+import { expect, it } from 'vitest'
+import { useSmartWorkspaceFieldFocusControls } from './use-smart-workspace-field-focus-controls'
+
+it.each(['disabled', 'text', 'cross-repository'] as const)(
+  'keeps a suspended %s source popover closed when the field resumes',
+  (reason) => {
+    let suspended = false
+    const { result, rerender } = renderHook(() =>
+      useSmartWorkspaceFieldFocusControls({
+        props: { selectedSource: null, disabled: suspended && reason === 'disabled' },
+        state: {
+          mode: suspended && reason === 'text' ? 'text' : 'smart',
+          crossRepoPrompt: suspended && reason === 'cross-repository'
+        }
+      })
+    )
+    act(() => {
+      result.current.markSourcePopoverUserEngaged()
+      result.current.setOpen(true)
+    })
+    expect(result.current.open).toBe(true)
+    suspended = true
+    rerender()
+    expect(result.current.open).toBe(false)
+    suspended = false
+    rerender()
+    expect(result.current.open).toBe(false)
+  }
+)
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.ts
index dcd1d9dc7160..771d5a4ae192 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-field-focus-controls.ts
@@ -1,25 +1,31 @@
-import { useCallback } from 'react'
-import type { NormalizedSmartWorkspaceNameFieldProps } from './smart-workspace-name-field-model'
-import type { useSmartWorkspaceNameFieldState } from './use-smart-workspace-name-field-state'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { SmartWorkspaceNameFieldProps } from './smart-workspace-name-field-model'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 
-type FieldState = ReturnType<typeof useSmartWorkspaceNameFieldState>
+type FieldState = { mode: SmartNameMode; crossRepoPrompt?: unknown }
 
 export function useSmartWorkspaceFieldFocusControls({
   props,
   state
 }: {
-  props: NormalizedSmartWorkspaceNameFieldProps
+  props: Pick<SmartWorkspaceNameFieldProps, 'selectedSource' | 'inputRef'> & { disabled: boolean }
   state: FieldState
 }) {
   const { disabled, selectedSource, inputRef } = props
-  const {
-    mode,
-    setOpen,
-    focusedSelectedSourceKeyRef,
-    localInputFocusFrameRef,
-    deferSourcePopoverUntilInteractionRef,
-    localInputRef
-  } = state
+  const { mode, crossRepoPrompt } = state
+  const [open, setOpen] = useState(false)
+  const [emojiCommandValue, setEmojiCommandValue] = useState('')
+  const [emojiCursor, setEmojiCursor] = useState<number | null>(null)
+  const localInputRef = useRef<HTMLInputElement | null>(null)
+  const focusedSelectedSourceKeyRef = useRef<string | null>(null)
+  const tabsListRef = useRef<HTMLDivElement | null>(null)
+  const localInputFocusFrameRef = useRef<number | null>(null)
+  const deferSourcePopoverUntilInteractionRef = useRef(true)
+  useEffect(() => {
+    if (disabled || mode === 'text' || crossRepoPrompt) {
+      setOpen(false)
+    }
+  }, [disabled, mode, crossRepoPrompt])
   const selectedSourceFocusKey = selectedSource
     ? `${selectedSource.kind}:${selectedSource.label}:${selectedSource.url ?? ''}`
     : null
@@ -84,6 +90,15 @@ export function useSmartWorkspaceFieldFocusControls({
   )
 
   return {
+    open,
+    setOpen,
+    emojiCommandValue,
+    setEmojiCommandValue,
+    emojiCursor,
+    setEmojiCursor,
+    localInputRef,
+    tabsListRef,
+    localInputFocusFrameRef,
     setSelectedSourceNode,
     cancelLocalInputFocusFrame,
     markSourcePopoverUserEngaged,
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-github-search.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-github-search.ts
index 5351890801fb..39a686b46ec4 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-github-search.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-github-search.ts
@@ -8,9 +8,9 @@ import { lookupSmartGitHubSubmitItem } from '@/lib/smart-github-submit'
 import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
 import { RESULT_LIMIT } from './smart-workspace-name-field-model'
 import { resolveSmartWorkspaceGithubDirectLink } from './smart-workspace-github-direct-link'
-import type { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
+import type { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
 
-type Foundation = ReturnType<typeof useSmartWorkspaceNameFieldFoundation>
+type Foundation = ReturnType<typeof useWorkItemSourceFoundation>
 
 export function useSmartWorkspaceGithubSearch({
   foundation,
@@ -36,7 +36,6 @@ export function useSmartWorkspaceGithubSearch({
     fetchWorkItemsAcrossRepos,
     setGithubItems,
     setGithubLoading,
-    setOpen,
     setCrossRepoPrompt
   } = foundation
   const normalizedGhQuery = useMemo(
@@ -50,6 +49,7 @@ export function useSmartWorkspaceGithubSearch({
 
   useEffect(() => {
     if (disabled || !shouldQueryGithub) {
+      setCrossRepoPrompt(null)
       setGithubItems([])
       setGithubLoading(false)
       return
@@ -80,7 +80,6 @@ export function useSmartWorkspaceGithubSearch({
           }
           setGithubItems(result.items)
           if (result.prompt) {
-            setOpen(false)
             setCrossRepoPrompt(result.prompt)
           }
         })
@@ -234,7 +233,6 @@ export function useSmartWorkspaceGithubSearch({
     repoSlugCacheRef,
     setCrossRepoPrompt,
     setGithubItems,
-    setGithubLoading,
-    setOpen
+    setGithubLoading
   ])
 }
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-gitlab-search.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-gitlab-search.ts
index 7f222aff95c1..faa61be2d5f3 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-gitlab-search.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-gitlab-search.ts
@@ -6,9 +6,9 @@ import {
 import { parseGitLabIssueOrMRLink } from '@/lib/gitlab-links'
 import type { GitLabWorkItem } from '../../../../shared/gitlab-types'
 import { RESULT_LIMIT } from './smart-workspace-name-field-model'
-import type { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
+import type { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
 
-type Foundation = ReturnType<typeof useSmartWorkspaceNameFieldFoundation>
+type Foundation = ReturnType<typeof useWorkItemSourceFoundation>
 
 export function useSmartWorkspaceGitlabSearch({
   foundation,
@@ -22,7 +22,7 @@ export function useSmartWorkspaceGitlabSearch({
   const {
     debouncedQuery,
     disabled,
-    onGitLabItemSelect,
+    gitlabEnabled,
     mode,
     repoBackedSearchTargets,
     mrStateFilter,
@@ -36,7 +36,7 @@ export function useSmartWorkspaceGitlabSearch({
   )
 
   useEffect(() => {
-    if (!shouldQueryGitlab || disabled || !onGitLabItemSelect) {
+    if (!shouldQueryGitlab || disabled || gitlabEnabled === false) {
       // Why: the list effect below is the sole writer in GitLab mode without a URL.
       if (!shouldQueryGitlab || (parsedGlLink === null && mode !== 'gitlab')) {
         setGitlabItems([])
@@ -89,7 +89,7 @@ export function useSmartWorkspaceGitlabSearch({
   }, [
     disabled,
     mode,
-    onGitLabItemSelect,
+    gitlabEnabled,
     parsedGlLink,
     repoBackedSearchTargets,
     setGitlabItems,
@@ -99,7 +99,7 @@ export function useSmartWorkspaceGitlabSearch({
 
   // Why: state chips mirror GitLab's default opened-MR list when no URL is pasted.
   useEffect(() => {
-    if (!shouldQueryGitlab || disabled || !onGitLabItemSelect) {
+    if (!shouldQueryGitlab || disabled || gitlabEnabled === false) {
       if (!shouldQueryGitlab) {
         setGitlabItems([])
         setGitlabLoading(false)
@@ -163,7 +163,7 @@ export function useSmartWorkspaceGitlabSearch({
     disabled,
     mode,
     mrStateFilter,
-    onGitLabItemSelect,
+    gitlabEnabled,
     parsedGlLink,
     repoBackedSearchTargets,
     setGitlabItems,
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-actions.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-actions.ts
index f54cb6f965b0..ac647876f333 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-actions.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-actions.ts
@@ -6,18 +6,28 @@ import { lookupGitHubWorkItemByOwnerRepoForSource } from '@/lib/github-work-item
 import {
   applyWorkspaceEmojiSuggestion,
   type WorkspaceEmojiReplacement,
+  type getActiveWorkspaceEmojiShortcode,
   type WorkspaceEmojiSuggestion
 } from '@/lib/workspace-emoji-shortcodes'
 import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
 import { buildTaskSourceContextFromRepo } from '../../../../shared/task-source-context'
-import { bindJiraIssueSourceContext } from './use-jira-url-source'
-import type { RepoOption, RowEntry } from './smart-workspace-name-field-model'
+import type {
+  RepoOption,
+  RowEntry,
+  SmartWorkspaceNameFieldProps
+} from './smart-workspace-name-field-model'
 import { getRepoSlugCached, sameSlug } from './smart-workspace-repo-slug'
-import type { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
-import type { useSmartWorkspaceNameFieldPresentation } from './use-smart-workspace-name-field-presentation'
+import type { useWorkItemSourceSearch } from './use-work-item-source-search'
+import type { useSmartWorkspaceFieldFocusControls } from './use-smart-workspace-field-focus-controls'
+import { useAppStore } from '@/store'
+import type { useWorkItemSourcePresentation } from './use-work-item-source-presentation'
 
-type Foundation = ReturnType<typeof useSmartWorkspaceNameFieldFoundation>
-type Presentation = ReturnType<typeof useSmartWorkspaceNameFieldPresentation>
+type Foundation = ReturnType<typeof useWorkItemSourceSearch> &
+  SmartWorkspaceNameFieldProps &
+  ReturnType<typeof useSmartWorkspaceFieldFocusControls>
+type Presentation = ReturnType<typeof useWorkItemSourcePresentation> & {
+  activeEmojiShortcode: ReturnType<typeof getActiveWorkspaceEmojiShortcode>
+}
 
 function scheduleEmojiInputFocus(
   frameRef: React.RefObject<number | null>,
@@ -36,8 +46,7 @@ export function useSmartWorkspaceNameFieldActions(
   presentation: Presentation
 ) {
   const {
-    jiraConnectionStatus,
-    jiraSourceContext,
+    resolveRow,
     onBranchSelect,
     onGitHubItemSelect,
     onGitLabItemSelect,
@@ -59,10 +68,10 @@ export function useSmartWorkspaceNameFieldActions(
     setCrossRepoPrompt,
     selectedRepo,
     allowCrossRepoProjectAdd,
-    addRepo,
     repoSlugCacheRef
   } = foundation
-  const { selectJiraAccount, jiraBoundSourceContext, activeEmojiShortcode } = presentation
+  const addRepo = useAppStore((s) => s.addRepo)
+  const { selectJiraAccount, activeEmojiShortcode } = presentation
 
   const handleSelect = useCallback(
     (row: RowEntry) => {
@@ -80,15 +89,7 @@ export function useSmartWorkspaceNameFieldActions(
       } else if (row.kind === 'branch') {
         onBranchSelect(row.refName, row.localBranchName)
       } else if (row.kind === 'jira') {
-        const sites = jiraConnectionStatus?.sites ?? []
-        const site =
-          sites.find((candidate) => candidate.id === row.issue.siteId) ??
-          (sites.length === 1 ? sites[0] : null)
-        const sourceContext =
-          jiraBoundSourceContext ??
-          (jiraSourceContext && site
-            ? bindJiraIssueSourceContext(jiraSourceContext, site, row.issue)
-            : null)
+        const sourceContext = resolveRow(row)?.taskSourceContext
         if (!sourceContext) {
           toast.error(
             translate(
@@ -105,9 +106,7 @@ export function useSmartWorkspaceNameFieldActions(
       setOpen(false)
     },
     [
-      jiraBoundSourceContext,
-      jiraConnectionStatus?.sites,
-      jiraSourceContext,
+      resolveRow,
       onBranchSelect,
       onGitHubItemSelect,
       onGitLabItemSelect,
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-controller.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-controller.ts
index 220b8e27e694..968966687bd5 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-controller.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-controller.ts
@@ -1,151 +1,98 @@
 import { useEffect, useMemo } from 'react'
-import { useTranslation } from 'react-i18next'
 import {
-  getJiraIssueSearchQuery,
-  isSmartWorkspaceSourceQueryWithinLimit
-} from './smart-workspace-source-results'
-import { parseBoundedSmartWorkspaceLinearIssueUrlIntent } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
-import {
-  EMPTY_REPO_SEARCH_REPOS,
-  type NormalizedSmartWorkspaceNameFieldProps,
-  type SmartWorkspaceNameFieldProps
-} from './smart-workspace-name-field-model'
-import { getSmartWorkspaceNameFieldCopy } from './smart-workspace-name-field-copy'
+  getActiveWorkspaceEmojiShortcode,
+  searchWorkspaceEmojiShortcodes,
+  type WorkspaceEmojiSuggestion
+} from '@/lib/workspace-emoji-shortcodes'
+import type { SmartWorkspaceNameFieldProps } from './smart-workspace-name-field-model'
+import { useWorkItemSourceSearch } from './use-work-item-source-search'
+import { useSmartWorkspaceFieldFocusControls } from './use-smart-workspace-field-focus-controls'
 import { useSmartWorkspaceNameFieldActions } from './use-smart-workspace-name-field-actions'
-import { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
-import { useSmartWorkspaceGithubSearch } from './use-smart-workspace-github-search'
-import { useSmartWorkspaceGitlabSearch } from './use-smart-workspace-gitlab-search'
-import { useSmartWorkspaceNameFieldPresentation } from './use-smart-workspace-name-field-presentation'
-import { useSmartWorkspaceSecondarySearches } from './use-smart-workspace-secondary-searches'
+import { getSmartWorkspaceNameFieldCopy } from './smart-workspace-name-field-copy'
 
-export function useSmartWorkspaceNameFieldController({
-  jiraSourceContext = null,
-  disabled = false,
-  textOnly = false,
-  branchesEnabled = true,
-  repoBackedSourcesDisabled = false,
-  repoBackedSearchRepos = EMPTY_REPO_SEARCH_REPOS,
-  allowCrossRepoProjectAdd = true,
-  crossRepoSwitchTarget = 'project',
-  ...props
-}: SmartWorkspaceNameFieldProps) {
-  // Why: translate()-based options must refresh on language changes without remounting.
-  useTranslation()
-  const normalizedProps: NormalizedSmartWorkspaceNameFieldProps = {
+export function useSmartWorkspaceNameFieldController(props: SmartWorkspaceNameFieldProps) {
+  const search = useWorkItemSourceSearch({
     ...props,
-    jiraSourceContext,
-    disabled,
-    textOnly,
-    branchesEnabled,
-    repoBackedSourcesDisabled,
-    repoBackedSearchRepos,
-    allowCrossRepoProjectAdd,
-    crossRepoSwitchTarget
-  }
-  const foundation = useSmartWorkspaceNameFieldFoundation(normalizedProps)
-  const { linearLoading, setLinearUrlLoadingFeedbackQuery } = foundation
-  const linearUrlIntent = useMemo(
-    () => parseBoundedSmartWorkspaceLinearIssueUrlIntent(foundation.value),
-    [foundation.value]
+    typedTextEnabled: true,
+    sourceSelected: props.selectedSource !== null,
+    gitlabEnabled: Boolean(props.onGitLabItemSelect)
+  })
+  const focus = useSmartWorkspaceFieldFocusControls({
+    props: {
+      selectedSource: props.selectedSource,
+      inputRef: props.inputRef,
+      disabled: search.disabled
+    },
+    state: search
+  })
+  const { value, selectedSource, disabled = false, onActiveSourceModeChange } = props
+  const { mode: sourceMode } = search
+  const { emojiCursor, emojiCommandValue } = focus
+  const activeEmojiShortcode = useMemo(
+    () => getActiveWorkspaceEmojiShortcode(value, emojiCursor),
+    [emojiCursor, value]
   )
-  const linearUrlIntentOwnsInput =
-    linearUrlIntent !== null && (foundation.mode === 'smart' || foundation.mode === 'linear')
-  const linearQuery = linearUrlIntentOwnsInput ? foundation.value : foundation.debouncedQuery
-  const sourceQueryWithinLimit = useMemo(
-    () => isSmartWorkspaceSourceQueryWithinLimit(foundation.debouncedQuery),
-    [foundation.debouncedQuery]
+  const emojiSuggestions: WorkspaceEmojiSuggestion[] = useMemo(
+    () => (activeEmojiShortcode ? searchWorkspaceEmojiShortcodes(activeEmojiShortcode.query) : []),
+    [activeEmojiShortcode]
   )
-  const linearQueryWithinLimit = useMemo(
-    () => isSmartWorkspaceSourceQueryWithinLimit(linearQuery),
-    [linearQuery]
+  const emojiMenuOpen =
+    !disabled &&
+    selectedSource === null &&
+    activeEmojiShortcode !== null &&
+    emojiSuggestions.length > 0
+  const resolvedEmojiCommandValue = emojiSuggestions.some(
+    (suggestion) => `emoji:${suggestion.shortcode}` === emojiCommandValue
   )
+    ? emojiCommandValue
+    : emojiSuggestions[0]
+      ? `emoji:${emojiSuggestions[0].shortcode}`
+      : ''
+  const selectedEmojiSuggestion =
+    emojiSuggestions.find(
+      (suggestion) => `emoji:${suggestion.shortcode}` === resolvedEmojiCommandValue
+    ) ?? null
   useEffect(() => {
-    if (!linearUrlIntentOwnsInput || !linearLoading) {
-      setLinearUrlLoadingFeedbackQuery(null)
-      return
+    onActiveSourceModeChange?.(sourceMode)
+  }, [sourceMode, onActiveSourceModeChange])
+  const handleModeChange = (mode: typeof search.mode): void => {
+    search.setMode(mode)
+    if (!search.disabled && mode !== 'text' && selectedSource === null) {
+      focus.markSourcePopoverUserEngaged()
+      focus.setOpen(true)
+    } else {
+      focus.setOpen(false)
     }
-    setLinearUrlLoadingFeedbackQuery(null)
-    const timer = window.setTimeout(() => setLinearUrlLoadingFeedbackQuery(linearQuery), 200)
-    return () => window.clearTimeout(timer)
-  }, [linearLoading, setLinearUrlLoadingFeedbackQuery, linearQuery, linearUrlIntentOwnsInput])
-  const shouldQueryGithub =
-    sourceQueryWithinLimit &&
-    !repoBackedSourcesDisabled &&
-    !foundation.jiraSource.intent &&
-    !linearUrlIntentOwnsInput &&
-    !textOnly &&
-    foundation.repoBackedSearchTargets.length > 0 &&
-    (foundation.mode === 'smart' || foundation.mode === 'github')
-  const shouldQueryLinear =
-    linearQueryWithinLimit &&
-    !foundation.jiraSource.intent &&
-    !textOnly &&
-    foundation.linearAvailable &&
-    (foundation.mode === 'smart' || foundation.mode === 'linear')
-  const jiraSearchQuery =
-    foundation.mode === 'jira' && !foundation.jiraSource.intent && sourceQueryWithinLimit
-      ? getJiraIssueSearchQuery(foundation.debouncedQuery)
-      : null
-  const shouldQueryJira =
-    !disabled &&
-    !textOnly &&
-    foundation.jiraSourceConnected &&
-    jiraSourceContext !== null &&
-    jiraSearchQuery !== null
-
-  useSmartWorkspaceGithubSearch({
-    foundation,
-    sourceQueryWithinLimit,
-    shouldQueryGithub
-  })
-  useSmartWorkspaceSecondarySearches({
-    foundation,
-    shouldQueryLinear,
-    linearQuery,
-    linearUrlIntent,
-    linearUrlIntentOwnsInput,
-    shouldQueryJira,
-    jiraSearchQuery
-  })
-  const shouldQueryGitlab =
-    sourceQueryWithinLimit &&
-    !repoBackedSourcesDisabled &&
-    !foundation.jiraSource.intent &&
-    !linearUrlIntentOwnsInput &&
-    !textOnly &&
-    foundation.gitlabSourceAvailable &&
-    foundation.repoBackedSearchTargets.length > 0 &&
-    (foundation.mode === 'smart' || foundation.mode === 'gitlab')
-  useSmartWorkspaceGitlabSearch({
-    foundation,
-    sourceQueryWithinLimit,
-    shouldQueryGitlab
-  })
-  const presentation = useSmartWorkspaceNameFieldPresentation(foundation, {
-    linearUrlIntent,
-    linearUrlIntentOwnsInput,
-    linearQuery
-  })
-  const actions = useSmartWorkspaceNameFieldActions(foundation, presentation)
+    focus.cancelLocalInputFocusFrame()
+    focus.localInputFocusFrameRef.current = requestAnimationFrame(() => {
+      focus.localInputFocusFrameRef.current = null
+      focus.localInputRef.current?.focus({ preventScroll: true })
+    })
+  }
+  const foundation = {
+    ...props,
+    ...search,
+    ...focus,
+    allowCrossRepoProjectAdd: props.allowCrossRepoProjectAdd ?? true
+  }
+  const actions = useSmartWorkspaceNameFieldActions(foundation, { ...search, activeEmojiShortcode })
   const copy = getSmartWorkspaceNameFieldCopy({
-    repoBackedSourcesDisabled,
-    linearAvailable: foundation.linearAvailable,
-    branchesEnabled,
-    crossRepoSwitchTarget,
-    disabled,
-    disabledPlaceholder: props.disabledPlaceholder,
-    mode: foundation.mode
+    ...search,
+    disabledPlaceholder: props.disabledPlaceholder
   })
-
   return {
     ...foundation,
-    ...presentation,
     ...actions,
     ...copy,
-    linearStatusId: foundation.linearStatusId
+    handleModeChange,
+    activeEmojiShortcode,
+    emojiSuggestions,
+    emojiMenuOpen,
+    resolvedEmojiCommandValue,
+    selectedEmojiSuggestion,
+    open: focus.open && !search.crossRepoPrompt && !search.disabled && search.mode !== 'text'
   }
 }
-
 export type SmartWorkspaceNameFieldController = ReturnType<
   typeof useSmartWorkspaceNameFieldController
 >
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.source.test.tsx b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.source.test.tsx
new file mode 100644
index 000000000000..abeea9ba49cc
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.source.test.tsx
@@ -0,0 +1,167 @@
+// @vitest-environment happy-dom
+
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { LinearIssue } from '../../../../shared/linear/issue-types'
+import type { TaskSourceContext } from '../../../../shared/task-source-context'
+import type { NormalizedWorkItemSourceSearchProps } from './smart-workspace-name-field-model'
+import { useWorkItemSourceSearch } from './use-work-item-source-search'
+import { referenceLinearIssue } from '../sidebar/workspace-reference-fixtures.test-support'
+import { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
+import { useSmartWorkspaceSecondarySearches } from './use-smart-workspace-secondary-searches'
+
+const mocks = vi.hoisted(() => ({
+  readStatus: vi.fn(),
+  readJiraSource: vi.fn(() => ({ intent: false })),
+  state: {
+    addRepo: vi.fn(),
+    checkLinearConnection: vi.fn(),
+    linearStatus: { connected: false, viewer: null, selectedWorkspaceId: 'focused-workspace' },
+    linearStatusChecked: true,
+    settings: null,
+    preflightStatus: null,
+    preflightStatusChecked: true,
+    preflightStatusContextKey: 'test',
+    refreshPreflightStatus: vi.fn(),
+    searchLinearIssues: vi.fn<
+      (query: string, limit: number, options: unknown) => Promise<LinearIssue[]>
+    >(async () => [])
+  }
+}))
+vi.mock('@/runtime/runtime-linear-client', () => ({ linearStatus: mocks.readStatus }))
+vi.mock('@/store', () => ({
+  useAppStore: (selector: (state: typeof mocks.state) => unknown) => selector(mocks.state)
+}))
+vi.mock('@/lib/local-preflight-context', () => ({
+  getLocalPreflightContext: () => ({}),
+  localPreflightContextKey: () => 'test'
+}))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+vi.mock('./use-jira-source-connection', () => ({
+  useJiraSourceConnection: () => ({ status: null, loaded: false })
+}))
+vi.mock('./use-jira-url-source', () => ({ useJiraUrlSource: mocks.readJiraSource }))
+
+const source: TaskSourceContext = {
+  kind: 'task-source',
+  provider: 'linear',
+  projectId: 'project-1',
+  hostId: 'runtime:saved-host',
+  repoId: null,
+  providerIdentity: null,
+  accountLabel: null
+}
+
+function props(context?: TaskSourceContext): NormalizedWorkItemSourceSearchProps {
+  return {
+    repos: [],
+    repoId: '',
+    value: '',
+    jiraSourceContext: null,
+    linearSourceContext: context,
+    disabled: false,
+    textOnly: false,
+    branchesEnabled: false,
+    repoBackedSourcesDisabled: true,
+    repoBackedSearchRepos: [],
+    crossRepoSwitchTarget: 'task-source'
+  }
+}
+
+describe('smart workspace explicit source connection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.state.linearStatus = {
+      connected: false,
+      viewer: null,
+      selectedWorkspaceId: 'focused-workspace'
+    }
+  })
+
+  it('exposes Linear on a connected saved host while the focused runtime is disconnected', async () => {
+    mocks.readStatus.mockResolvedValue({
+      connected: true,
+      viewer: null,
+      selectedWorkspaceId: 'source-workspace'
+    })
+    const fieldProps = props(source)
+    const { result } = renderHook(() => {
+      const foundation = useWorkItemSourceFoundation(fieldProps)
+      useSmartWorkspaceSecondarySearches({
+        foundation,
+        shouldQueryLinear: foundation.linearAvailable,
+        linearQuery: 'launch',
+        linearUrlIntent: null,
+        linearUrlIntentOwnsInput: false,
+        shouldQueryJira: false,
+        jiraSearchQuery: null
+      })
+      return foundation
+    })
+    await waitFor(() =>
+      expect(result.current.availableModes.some((mode) => mode.id === 'linear')).toBe(true)
+    )
+    expect(result.current.linearSourceContext).toBe(source)
+    expect(result.current.linearStatus.connected).toBe(true)
+    expect(mocks.state.searchLinearIssues).toHaveBeenCalledWith('launch', 12, {
+      sourceContext: source,
+      workspaceId: 'source-workspace'
+    })
+    expect(mocks.readStatus).toHaveBeenCalledWith(source)
+    expect(mocks.state.checkLinearConnection).not.toHaveBeenCalled()
+    expect(mocks.state.linearStatus.connected).toBe(false)
+  })
+
+  it('hides disconnected saved-host Linear even when the focused runtime is connected', async () => {
+    mocks.state.linearStatus = { ...mocks.state.linearStatus, connected: true }
+    mocks.readStatus.mockResolvedValue({ connected: false, viewer: null })
+    const fieldProps = props(source)
+    const { result } = renderHook(() => useWorkItemSourceFoundation(fieldProps))
+    await waitFor(() => expect(result.current.linearStatusChecked).toBe(true))
+    expect(result.current.availableModes.some((mode) => mode.id === 'linear')).toBe(false)
+    expect(result.current.linearStatus.connected).toBe(false)
+  })
+
+  it('retains focused runtime status and avoids a new status read without an override', async () => {
+    mocks.state.linearStatus = { ...mocks.state.linearStatus, connected: true }
+    const fieldProps = props()
+    const { result } = renderHook(() => useWorkItemSourceFoundation(fieldProps))
+    await act(async () => {})
+    expect(result.current.availableModes.some((mode) => mode.id === 'linear')).toBe(true)
+    expect(result.current.linearStatus).toBe(mocks.state.linearStatus)
+    expect(mocks.readStatus).not.toHaveBeenCalled()
+  })
+  it('returns to Smart after losing a provider and does not resurrect its stale mode or rows', async () => {
+    mocks.state.linearStatus = { ...mocks.state.linearStatus, connected: true }
+    mocks.state.searchLinearIssues.mockResolvedValue([referenceLinearIssue()])
+    const searchProps = { ...props(), value: 'launch' }
+    const { result, rerender } = renderHook(() => useWorkItemSourceSearch(searchProps))
+    act(() => result.current.setMode('linear'))
+    await waitFor(() => expect(result.current.rows.some((row) => row.kind === 'linear')).toBe(true))
+    mocks.state.linearStatus = { ...mocks.state.linearStatus, connected: false }
+    rerender()
+    await waitFor(() => expect(result.current.mode).toBe('smart'))
+    expect(result.current.rows).toEqual([])
+    mocks.state.searchLinearIssues.mockResolvedValue([])
+    mocks.state.linearStatus = { ...mocks.state.linearStatus, connected: true }
+    rerender()
+    await waitFor(() => expect(result.current.loading).toBe(false))
+    expect(result.current.mode).toBe('smart')
+    expect(result.current.rows).toEqual([])
+  })
+
+  it.each([false, true])(
+    'allows Jira URL resolution only while sourceSelected=%s is false',
+    (sourceSelected) => {
+      const fieldProps = {
+        ...props(),
+        sourceSelected,
+        value: 'https://company.atlassian.net/browse/ENG-1'
+      }
+      renderHook(() => useWorkItemSourceFoundation(fieldProps))
+      expect(mocks.readJiraSource).toHaveBeenLastCalledWith(
+        expect.objectContaining({ enabled: !sourceSelected })
+      )
+    }
+  )
+})
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-secondary-searches.ts b/src/renderer/src/components/new-workspace/use-smart-workspace-secondary-searches.ts
index 053614f9b2f1..7c18681bb1d2 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-secondary-searches.ts
+++ b/src/renderer/src/components/new-workspace/use-smart-workspace-secondary-searches.ts
@@ -6,10 +6,10 @@ import { linearWorkspaceScopeSignature } from '../../../../shared/linear/workspa
 import { getSmartWorkspaceLinearSearchQuery } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
 import type { parseBoundedSmartWorkspaceLinearIssueUrlIntent } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
 import { RESULT_LIMIT } from './smart-workspace-name-field-model'
-import { getBranchSearchRequest } from './smart-workspace-source-results'
-import type { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
+import { getBranchSearchRequest } from '../../../../shared/new-workspace/smart-workspace-source-results'
+import type { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
 
-type Foundation = ReturnType<typeof useSmartWorkspaceNameFieldFoundation>
+type Foundation = ReturnType<typeof useWorkItemSourceFoundation>
 
 export function useSmartWorkspaceSecondarySearches({
   foundation,
@@ -46,6 +46,7 @@ export function useSmartWorkspaceSecondarySearches({
     searchLinearIssues,
     listLinearIssues,
     linearSourceContext,
+    linearWorkspaceIdOverride,
     setLinearIssues,
     setLinearLoading,
     setSettledLinearUrlQuery,
@@ -171,13 +172,21 @@ export function useSmartWorkspaceSecondarySearches({
             getSmartWorkspaceLinearSearchQuery(trimmed),
             RESULT_LIMIT,
             {
-              sourceContext: linearSourceContext
+              sourceContext: linearSourceContext,
+              ...(linearWorkspaceIdOverride !== undefined
+                ? { workspaceId: linearWorkspaceIdOverride }
+                : {})
             }
           )
         : linearReadMethodsRef.current
             .listLinearIssues(
               { kind: 'list', filter: 'assigned', limit: RESULT_LIMIT },
-              { sourceContext: linearSourceContext }
+              {
+                sourceContext: linearSourceContext,
+                ...(linearWorkspaceIdOverride !== undefined
+                  ? { workspaceId: linearWorkspaceIdOverride }
+                  : {})
+              }
             )
             .then((result) => result.items)
     void request
@@ -208,6 +217,7 @@ export function useSmartWorkspaceSecondarySearches({
     linearQuery,
     linearScopeSignature,
     linearSourceContext,
+    linearWorkspaceIdOverride,
     linearUrlIntent,
     setSettledLinearUrlQuery,
     shouldQueryLinear
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.ts b/src/renderer/src/components/new-workspace/use-work-item-source-foundation.ts
similarity index 72%
rename from src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.ts
rename to src/renderer/src/components/new-workspace/use-work-item-source-foundation.ts
index 7cf2095e93fa..01198f759015 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-foundation.ts
+++ b/src/renderer/src/components/new-workspace/use-work-item-source-foundation.ts
@@ -5,17 +5,16 @@ import { getLocalPreflightContext, localPreflightContextKey } from '@/lib/local-
 import { getRepoOwnerRoutedSettings } from '@/lib/repo-runtime-owner'
 import { buildTaskSourceContextFromRepo } from '../../../../shared/task-source-context'
 import type {
-  NormalizedSmartWorkspaceNameFieldProps,
+  NormalizedWorkItemSourceSearchProps,
   RepoBackedSearchTarget
 } from './smart-workspace-name-field-model'
 import { useJiraSourceConnection } from './use-jira-source-connection'
 import { useJiraUrlSource } from './use-jira-url-source'
+import { useLinearSourceConnection } from './use-linear-source-connection'
 import { useSmartWorkspaceFieldAvailability } from './use-smart-workspace-field-availability'
-import { useSmartWorkspaceNameFieldState } from './use-smart-workspace-name-field-state'
+import { useWorkItemSourceState } from './use-work-item-source-state'
 
-export function useSmartWorkspaceNameFieldFoundation(
-  props: NormalizedSmartWorkspaceNameFieldProps
-) {
+export function useWorkItemSourceFoundation(props: NormalizedWorkItemSourceSearchProps) {
   const {
     repos,
     repoId,
@@ -25,17 +24,16 @@ export function useSmartWorkspaceNameFieldFoundation(
     value,
     disabled,
     jiraSourceContext,
-    selectedSource
+    sourceSelected
   } = props
   const {
-    addRepo,
     checkLinearConnection,
     fetchWorkItems,
     fetchWorkItemsAcrossRepos,
     fetchLinearIssue,
     getCachedWorkItems,
-    linearStatus,
-    linearStatusChecked,
+    linearStatus: defaultLinearStatus,
+    linearStatusChecked: defaultLinearStatusChecked,
     listLinearIssues,
     preflightStatus,
     preflightStatusChecked,
@@ -47,7 +45,6 @@ export function useSmartWorkspaceNameFieldFoundation(
     settings
   } = useAppStore(
     useShallow((s) => ({
-      addRepo: s.addRepo,
       checkLinearConnection: s.checkLinearConnection,
       fetchWorkItems: s.fetchWorkItems,
       fetchWorkItemsAcrossRepos: s.fetchWorkItemsAcrossRepos,
@@ -88,14 +85,16 @@ export function useSmartWorkspaceNameFieldFoundation(
   }, [githubSourceContextOverride, selectedRepo])
   const gitlabSourceContext = useMemo(
     () =>
-      selectedRepo
-        ? buildTaskSourceContextFromRepo({
-            provider: 'gitlab',
-            projectId: selectedRepo.id,
-            repo: selectedRepo
-          })
-        : null,
-    [selectedRepo]
+      props.gitlabSourceContext?.provider === 'gitlab'
+        ? props.gitlabSourceContext
+        : selectedRepo
+          ? buildTaskSourceContextFromRepo({
+              provider: 'gitlab',
+              projectId: selectedRepo.id,
+              repo: selectedRepo
+            })
+          : null,
+    [props.gitlabSourceContext, selectedRepo]
   )
   const repoBackedSearchTargets = useMemo<RepoBackedSearchTarget[]>(
     () =>
@@ -127,16 +126,29 @@ export function useSmartWorkspaceNameFieldFoundation(
   )
   const linearSourceContext = useMemo(
     () =>
-      selectedRepo
-        ? buildTaskSourceContextFromRepo({
-            provider: 'linear',
-            projectId: selectedRepo.id,
-            repo: selectedRepo
-          })
-        : null,
-    [selectedRepo]
+      props.linearSourceContext?.provider === 'linear'
+        ? props.linearSourceContext
+        : selectedRepo
+          ? buildTaskSourceContextFromRepo({
+              provider: 'linear',
+              projectId: selectedRepo.id,
+              repo: selectedRepo
+            })
+          : null,
+    [props.linearSourceContext, selectedRepo]
   )
-  const state = useSmartWorkspaceNameFieldState(textOnly, value)
+  const state = useWorkItemSourceState(textOnly, value)
+  const hasLinearSourceOverride = props.linearSourceContext?.provider === 'linear'
+  const linearConnection = useLinearSourceConnection({
+    enabled: hasLinearSourceOverride && !disabled && !textOnly,
+    sourceContext: hasLinearSourceOverride ? linearSourceContext : null
+  })
+  const linearStatus = hasLinearSourceOverride
+    ? (linearConnection.status ?? { connected: false, viewer: null })
+    : defaultLinearStatus
+  const linearStatusChecked = hasLinearSourceOverride
+    ? linearConnection.loaded
+    : defaultLinearStatusChecked
   const jiraConnection = useJiraSourceConnection({
     enabled: !disabled && !textOnly && jiraSourceContext !== null,
     sourceContext: jiraSourceContext
@@ -148,7 +160,7 @@ export function useSmartWorkspaceNameFieldFoundation(
       !disabled &&
       !textOnly &&
       (state.mode === 'smart' || state.mode === 'jira') &&
-      selectedSource === null,
+      !sourceSelected,
     sourceContext: jiraSourceContext,
     connection: jiraConnection
   })
@@ -167,7 +179,8 @@ export function useSmartWorkspaceNameFieldFoundation(
     expectedPreflightContextKey,
     refreshPreflightStatus,
     linearStatus,
-    linearStatusChecked,
+    // Explicit sources load independently instead of refreshing the focused runtime's store.
+    linearStatusChecked: hasLinearSourceOverride || linearStatusChecked,
     checkLinearConnection,
     jiraSourceConnected
   })
@@ -176,19 +189,22 @@ export function useSmartWorkspaceNameFieldFoundation(
     ...props,
     ...state,
     ...availability,
-    addRepo,
     fetchWorkItems,
     fetchWorkItemsAcrossRepos,
     fetchLinearIssue,
     getCachedWorkItems,
     linearStatus,
     linearStatusChecked,
+    linearWorkspaceIdOverride: hasLinearSourceOverride
+      ? (linearStatus.selectedWorkspaceId ?? linearStatus.activeWorkspaceId ?? null)
+      : undefined,
     listLinearIssues,
     searchJiraIssues,
     searchLinearIssues,
     selectedRepo,
     selectedRepoOwnerSettings,
     githubSourceContext,
+    gitlabSourceContext,
     repoBackedSearchTargets,
     linearSourceContext,
     jiraConnectionStatus,
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-presentation.ts b/src/renderer/src/components/new-workspace/use-work-item-source-presentation.ts
similarity index 84%
rename from src/renderer/src/components/new-workspace/use-smart-workspace-name-field-presentation.ts
rename to src/renderer/src/components/new-workspace/use-work-item-source-presentation.ts
index 5665e60a0aff..212d9d724505 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-presentation.ts
+++ b/src/renderer/src/components/new-workspace/use-work-item-source-presentation.ts
@@ -8,11 +8,6 @@ import {
   parseBoundedSmartWorkspaceLinearIssueUrlIntent,
   prioritizeSmartWorkspaceLinearIssueResults
 } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
-import {
-  getActiveWorkspaceEmojiShortcode,
-  searchWorkspaceEmojiShortcodes,
-  type WorkspaceEmojiSuggestion
-} from '@/lib/workspace-emoji-shortcodes'
 import { resolveSmartWorkspaceCommandValue } from './smart-workspace-command-value'
 import {
   buildSmartWorkspaceSourceRows,
@@ -20,17 +15,17 @@ import {
   getVisibleHeldProviderResults,
   isBlockingTaskUrlResolution,
   isSmartWorkspaceSourceQueryWithinLimit
-} from './smart-workspace-source-results'
+} from '../../../../shared/new-workspace/smart-workspace-source-results'
 import { RESULT_LIMIT, type RowEntry } from './smart-workspace-name-field-model'
-import type { useSmartWorkspaceNameFieldFoundation } from './use-smart-workspace-name-field-foundation'
+import type { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
 
-type Foundation = ReturnType<typeof useSmartWorkspaceNameFieldFoundation>
+type Foundation = ReturnType<typeof useWorkItemSourceFoundation>
 
 function isTypedTextSourceRow(row: RowEntry): boolean {
   return row.kind === 'use-name' || row.kind === 'create-branch'
 }
 
-export function useSmartWorkspaceNameFieldPresentation(
+export function useWorkItemSourcePresentation(
   foundation: Foundation,
   options?: {
     linearUrlIntent?: ReturnType<typeof parseBoundedSmartWorkspaceLinearIssueUrlIntent>
@@ -54,10 +49,6 @@ export function useSmartWorkspaceNameFieldPresentation(
     linearIssues,
     commandValue,
     setCommandValue,
-    emojiCursor,
-    disabled,
-    selectedSource,
-    emojiCommandValue,
     githubLoading,
     gitlabLoading,
     branchesLoading,
@@ -100,7 +91,7 @@ export function useSmartWorkspaceNameFieldPresentation(
         site
       }))
     }
-    return buildSmartWorkspaceSourceRows({
+    const results = buildSmartWorkspaceSourceRows({
       branches: getVisibleBranchResults({
         branches,
         mode,
@@ -143,7 +134,11 @@ export function useSmartWorkspaceNameFieldPresentation(
       resultLimit: RESULT_LIMIT,
       value
     })
+    return foundation.typedTextEnabled
+      ? results
+      : results.filter((row) => !isTypedTextSourceRow(row))
   }, [
+    foundation.typedTextEnabled,
     branches,
     branchResultsSource,
     debouncedQuery,
@@ -235,33 +230,6 @@ export function useSmartWorkspaceNameFieldPresentation(
     }
     setCommandValue(resolvedCommandValue)
   }, [commandValue, resolvedCommandValue, setCommandValue])
-  const activeEmojiShortcode = useMemo(
-    () => getActiveWorkspaceEmojiShortcode(value, emojiCursor),
-    [emojiCursor, value]
-  )
-  const emojiSuggestions = useMemo(
-    () =>
-      activeEmojiShortcode
-        ? searchWorkspaceEmojiShortcodes(activeEmojiShortcode.query)
-        : ([] as WorkspaceEmojiSuggestion[]),
-    [activeEmojiShortcode]
-  )
-  const emojiMenuOpen =
-    !disabled &&
-    selectedSource === null &&
-    activeEmojiShortcode !== null &&
-    emojiSuggestions.length > 0
-  const resolvedEmojiCommandValue = emojiSuggestions.some(
-    (suggestion) => `emoji:${suggestion.shortcode}` === emojiCommandValue
-  )
-    ? emojiCommandValue
-    : emojiSuggestions[0]
-      ? `emoji:${emojiSuggestions[0].shortcode}`
-      : ''
-  const selectedEmojiSuggestion =
-    emojiSuggestions.find(
-      (suggestion) => `emoji:${suggestion.shortcode}` === resolvedEmojiCommandValue
-    ) ?? null
   const showLinearUrlLoadingFeedback =
     linearLoading && linearUrlIntentOwnsInput && linearUrlLoadingFeedbackQuery === linearQuery
   const visibleLinearLoading =
@@ -280,11 +248,6 @@ export function useSmartWorkspaceNameFieldPresentation(
     searchResultRows,
     isQueryStale,
     resolvedCommandValue,
-    activeEmojiShortcode,
-    emojiSuggestions,
-    emojiMenuOpen,
-    resolvedEmojiCommandValue,
-    selectedEmojiSuggestion,
     loading,
     showSearchSpinner,
     linearUrlIntent,
diff --git a/src/renderer/src/components/new-workspace/use-work-item-source-search.ts b/src/renderer/src/components/new-workspace/use-work-item-source-search.ts
new file mode 100644
index 000000000000..98ee5f0f1578
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/use-work-item-source-search.ts
@@ -0,0 +1,155 @@
+import { resolveWorkItemSourceRow } from './work-item-source-selection'
+import { useCallback, useEffect, useMemo } from 'react'
+import { useTranslation } from 'react-i18next'
+import {
+  getJiraIssueSearchQuery,
+  isSmartWorkspaceSourceQueryWithinLimit
+} from '../../../../shared/new-workspace/smart-workspace-source-results'
+import { parseBoundedSmartWorkspaceLinearIssueUrlIntent } from '../../../../shared/new-workspace/smart-workspace-linear-intent'
+import {
+  EMPTY_REPO_SEARCH_REPOS,
+  type NormalizedWorkItemSourceSearchProps,
+  type WorkItemSourceSearchProps
+} from './smart-workspace-name-field-model'
+import { useWorkItemSourceFoundation } from './use-work-item-source-foundation'
+import { useSmartWorkspaceGithubSearch } from './use-smart-workspace-github-search'
+import { useSmartWorkspaceGitlabSearch } from './use-smart-workspace-gitlab-search'
+import { useWorkItemSourcePresentation } from './use-work-item-source-presentation'
+import { useSmartWorkspaceSecondarySearches } from './use-smart-workspace-secondary-searches'
+
+export function useWorkItemSourceSearch({
+  jiraSourceContext = null,
+  disabled = false,
+  textOnly = false,
+  branchesEnabled = true,
+  repoBackedSourcesDisabled = false,
+  repoBackedSearchRepos = EMPTY_REPO_SEARCH_REPOS,
+  crossRepoSwitchTarget = 'project',
+  ...props
+}: WorkItemSourceSearchProps) {
+  // Why: translate()-based options must refresh on language changes without remounting.
+  useTranslation()
+  const normalizedProps: NormalizedWorkItemSourceSearchProps = {
+    ...props,
+    jiraSourceContext,
+    disabled,
+    textOnly,
+    branchesEnabled,
+    repoBackedSourcesDisabled,
+    repoBackedSearchRepos,
+    crossRepoSwitchTarget
+  }
+  const foundation = useWorkItemSourceFoundation(normalizedProps)
+  const { linearLoading, setLinearUrlLoadingFeedbackQuery } = foundation
+  const linearUrlIntent = useMemo(
+    () => parseBoundedSmartWorkspaceLinearIssueUrlIntent(foundation.value),
+    [foundation.value]
+  )
+  const linearUrlIntentOwnsInput =
+    linearUrlIntent !== null && (foundation.mode === 'smart' || foundation.mode === 'linear')
+  const linearQuery = linearUrlIntentOwnsInput ? foundation.value : foundation.debouncedQuery
+  const sourceQueryWithinLimit = useMemo(
+    () => isSmartWorkspaceSourceQueryWithinLimit(foundation.debouncedQuery),
+    [foundation.debouncedQuery]
+  )
+  const linearQueryWithinLimit = useMemo(
+    () => isSmartWorkspaceSourceQueryWithinLimit(linearQuery),
+    [linearQuery]
+  )
+  useEffect(() => {
+    if (!linearUrlIntentOwnsInput || !linearLoading) {
+      setLinearUrlLoadingFeedbackQuery(null)
+      return
+    }
+    setLinearUrlLoadingFeedbackQuery(null)
+    const timer = window.setTimeout(() => setLinearUrlLoadingFeedbackQuery(linearQuery), 200)
+    return () => window.clearTimeout(timer)
+  }, [linearLoading, setLinearUrlLoadingFeedbackQuery, linearQuery, linearUrlIntentOwnsInput])
+  const shouldQueryGithub =
+    sourceQueryWithinLimit &&
+    !repoBackedSourcesDisabled &&
+    !foundation.jiraSource.intent &&
+    !linearUrlIntentOwnsInput &&
+    !textOnly &&
+    foundation.repoBackedSearchTargets.length > 0 &&
+    (foundation.mode === 'smart' || foundation.mode === 'github')
+  const shouldQueryLinear =
+    linearQueryWithinLimit &&
+    !foundation.jiraSource.intent &&
+    !textOnly &&
+    foundation.linearAvailable &&
+    (foundation.mode === 'smart' || foundation.mode === 'linear')
+  const jiraSearchQuery =
+    foundation.mode === 'jira' && !foundation.jiraSource.intent && sourceQueryWithinLimit
+      ? getJiraIssueSearchQuery(foundation.debouncedQuery)
+      : null
+  const shouldQueryJira =
+    !disabled &&
+    !textOnly &&
+    foundation.jiraSourceConnected &&
+    jiraSourceContext !== null &&
+    jiraSearchQuery !== null
+
+  useSmartWorkspaceGithubSearch({
+    foundation,
+    sourceQueryWithinLimit,
+    shouldQueryGithub
+  })
+  useSmartWorkspaceSecondarySearches({
+    foundation,
+    shouldQueryLinear,
+    linearQuery,
+    linearUrlIntent,
+    linearUrlIntentOwnsInput,
+    shouldQueryJira,
+    jiraSearchQuery
+  })
+  const shouldQueryGitlab =
+    sourceQueryWithinLimit &&
+    !repoBackedSourcesDisabled &&
+    !foundation.jiraSource.intent &&
+    !linearUrlIntentOwnsInput &&
+    !textOnly &&
+    foundation.gitlabSourceAvailable &&
+    foundation.repoBackedSearchTargets.length > 0 &&
+    (foundation.mode === 'smart' || foundation.mode === 'gitlab')
+  useSmartWorkspaceGitlabSearch({
+    foundation,
+    sourceQueryWithinLimit,
+    shouldQueryGitlab
+  })
+  const presentation = useWorkItemSourcePresentation(foundation, {
+    linearUrlIntent,
+    linearUrlIntentOwnsInput,
+    linearQuery
+  })
+  const resolveRow = useCallback(
+    (row: (typeof presentation.rows)[number]) =>
+      resolveWorkItemSourceRow(
+        row,
+        {
+          github: foundation.githubSourceContext,
+          gitlab: foundation.gitlabSourceContext ?? null,
+          linear: foundation.linearSourceContext,
+          jira: foundation.jiraSource.boundSourceContext ?? foundation.jiraSourceContext
+        },
+        foundation.jiraConnectionStatus?.sites
+      ),
+    [
+      foundation.githubSourceContext,
+      foundation.gitlabSourceContext,
+      foundation.linearSourceContext,
+      foundation.jiraSource.boundSourceContext,
+      foundation.jiraSourceContext,
+      foundation.jiraConnectionStatus?.sites
+    ]
+  )
+  return {
+    ...foundation,
+    ...presentation,
+    resolveRow,
+    linearStatusId: foundation.linearStatusId
+  }
+}
+
+export type WorkItemSourceSearch = ReturnType<typeof useWorkItemSourceSearch>
diff --git a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-state.ts b/src/renderer/src/components/new-workspace/use-work-item-source-state.ts
similarity index 74%
rename from src/renderer/src/components/new-workspace/use-smart-workspace-name-field-state.ts
rename to src/renderer/src/components/new-workspace/use-work-item-source-state.ts
index bf75ca318697..05641de4ed6b 100644
--- a/src/renderer/src/components/new-workspace/use-smart-workspace-name-field-state.ts
+++ b/src/renderer/src/components/new-workspace/use-work-item-source-state.ts
@@ -5,14 +5,13 @@ import type { GitLabWorkItem } from '../../../../shared/gitlab-types'
 import type { JiraIssue } from '../../../../shared/jira-types'
 import type { LinearIssue } from '../../../../shared/linear/issue-types'
 import type { BaseRefSearchResult } from '../../../../shared/repo-types'
-import type { SmartNameMode } from './smart-workspace-source-results'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 import type { MrStateFilter } from './smart-workspace-localized-options'
 import type { CrossRepoPrompt } from './smart-workspace-name-field-model'
 
-export function useSmartWorkspaceNameFieldState(textOnly: boolean, value: string) {
+export function useWorkItemSourceState(textOnly: boolean, value: string) {
   const [mode, setMode] = useState<SmartNameMode>(textOnly ? 'text' : 'smart')
   const [mrStateFilter, setMrStateFilter] = useState<MrStateFilter>('opened')
-  const [open, setOpen] = useState(false)
   const [debouncedQuery, setDebouncedQuery] = useState(value)
   const [githubItems, setGithubItems] = useState<GitHubWorkItem[]>([])
   const [gitlabItems, setGitlabItems] = useState<GitLabWorkItem[]>([])
@@ -33,16 +32,8 @@ export function useSmartWorkspaceNameFieldState(textOnly: boolean, value: string
   const [settledLinearUrlQuery, setSettledLinearUrlQuery] = useState<string | null>(null)
   const [jiraLoading, setJiraLoading] = useState(false)
   const [commandValue, setCommandValue] = useState('')
-  const [emojiCommandValue, setEmojiCommandValue] = useState('')
-  const [emojiCursor, setEmojiCursor] = useState<number | null>(null)
-  const localInputRef = useRef<HTMLInputElement | null>(null)
-  const focusedSelectedSourceKeyRef = useRef<string | null>(null)
-  const tabsListRef = useRef<HTMLDivElement | null>(null)
   const repoSlugCacheRef = useRef<Map<string, RepoSlug>>(new Map())
   const handledCrossRepoUrlRef = useRef<string | null>(null)
-  const localInputFocusFrameRef = useRef<number | null>(null)
-  // Why: Electron makes programmatic .focus() look user-initiated, so wait for real interaction.
-  const deferSourcePopoverUntilInteractionRef = useRef(true)
   const [crossRepoPrompt, setCrossRepoPrompt] = useState<CrossRepoPrompt | null>(null)
 
   return {
@@ -50,8 +41,6 @@ export function useSmartWorkspaceNameFieldState(textOnly: boolean, value: string
     setMode,
     mrStateFilter,
     setMrStateFilter,
-    open,
-    setOpen,
     debouncedQuery,
     setDebouncedQuery,
     githubItems,
@@ -82,17 +71,8 @@ export function useSmartWorkspaceNameFieldState(textOnly: boolean, value: string
     setJiraLoading,
     commandValue,
     setCommandValue,
-    emojiCommandValue,
-    setEmojiCommandValue,
-    emojiCursor,
-    setEmojiCursor,
-    localInputRef,
-    focusedSelectedSourceKeyRef,
-    tabsListRef,
     repoSlugCacheRef,
     handledCrossRepoUrlRef,
-    localInputFocusFrameRef,
-    deferSourcePopoverUntilInteractionRef,
     crossRepoPrompt,
     setCrossRepoPrompt
   }
diff --git a/src/renderer/src/components/new-workspace/work-item-source-selection.test.ts b/src/renderer/src/components/new-workspace/work-item-source-selection.test.ts
new file mode 100644
index 000000000000..7475986d2e5e
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/work-item-source-selection.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest'
+import type { JiraIssue, JiraSite } from '../../../../shared/jira-types'
+import type { TaskSourceContext } from '../../../../shared/task-source-context'
+import { bindJiraIssueSourceContext } from './use-jira-url-source'
+import { resolveWorkItemSourceRow } from './work-item-source-selection'
+
+const source: TaskSourceContext = {
+  kind: 'task-source',
+  provider: 'jira',
+  projectId: 'project',
+  hostId: 'ssh:box',
+  repoId: null,
+  providerIdentity: null,
+  accountLabel: null
+}
+const site: JiraSite = {
+  id: 'site',
+  siteUrl: 'https://company.atlassian.net',
+  email: 'account@example.com',
+  displayName: 'Account',
+  accountId: 'account'
+}
+const issue: JiraIssue = {
+  id: 'issue',
+  key: 'ENG-1',
+  title: 'Issue',
+  url: `${site.siteUrl}/browse/ENG-1`,
+  siteId: site.id,
+  project: { id: 'project', key: 'ENG', name: 'Engineering' },
+  issueType: { id: 'bug', name: 'Bug' },
+  status: { id: 'open', name: 'Open', categoryKey: 'new', categoryName: 'To do' },
+  labels: [],
+  updatedAt: '',
+  createdAt: ''
+}
+const contexts = { github: null, gitlab: null, linear: null, jira: source }
+
+describe('shared work-item source resolution', () => {
+  it('binds a known Jira account for both creation and attachment selection', () => {
+    expect(
+      resolveWorkItemSourceRow({ kind: 'jira', value: 'jira', issue }, contexts, [site])
+        ?.taskSourceContext
+    ).toEqual(bindJiraIssueSourceContext(source, site, issue))
+  })
+  it('rejects a row whose account is no longer available', () => {
+    expect(
+      resolveWorkItemSourceRow({ kind: 'jira', value: 'jira', issue }, contexts, [])
+    ).toBeNull()
+  })
+  it.each([{ siteId: 'another-account' }, { url: 'https://other.atlassian.net/browse/ENG-1' }])(
+    'rejects a pre-bound account that does not match the result: %j',
+    (overrides) => {
+      const bound = bindJiraIssueSourceContext(source, site, issue)
+      expect(
+        resolveWorkItemSourceRow(
+          { kind: 'jira', value: 'jira', issue: { ...issue, ...overrides } },
+          { ...contexts, jira: bound }
+        )
+      ).toBeNull()
+    }
+  )
+  it('accepts the callback-bound account when no connection list is available', () => {
+    const bound = bindJiraIssueSourceContext(source, site, issue)
+    expect(
+      resolveWorkItemSourceRow({ kind: 'jira', value: 'jira', issue }, { ...contexts, jira: bound })
+        ?.taskSourceContext
+    ).toEqual(bound)
+  })
+})
diff --git a/src/renderer/src/components/new-workspace/work-item-source-selection.ts b/src/renderer/src/components/new-workspace/work-item-source-selection.ts
new file mode 100644
index 000000000000..47196d8f7c28
--- /dev/null
+++ b/src/renderer/src/components/new-workspace/work-item-source-selection.ts
@@ -0,0 +1,103 @@
+import type { TaskSourceContext } from '../../../../shared/task-source-context'
+import { getMatchingJiraSites, parseJiraIssueUrl } from '../../../../shared/jira-issue-url'
+import type { JiraSite } from '../../../../shared/jira-types'
+import {
+  buildGitHubWorkspaceSource,
+  buildGitLabWorkspaceSource,
+  buildLinearWorkspaceSource,
+  buildJiraWorkspaceSource,
+  type WorkspaceSourceLinkedItem
+} from '../../../../shared/new-workspace/workspace-source'
+import { parseGitHubIssueOrPRLink } from '../../../../shared/github/links'
+import { parseGitLabIssueOrMRLink } from '../../../../shared/new-workspace/gitlab-links'
+import { bindJiraIssueSourceContext } from './use-jira-url-source'
+import type { RowEntry } from './smart-workspace-name-field-model'
+
+export type WorkItemSourceContexts = Record<
+  'github' | 'gitlab' | 'linear' | 'jira',
+  TaskSourceContext | null
+>
+export function resolveWorkItemSourceRow(
+  row: RowEntry,
+  contexts: WorkItemSourceContexts,
+  sites: readonly JiraSite[] = []
+):
+  | (WorkspaceSourceLinkedItem & { identifier?: string; taskSourceContext?: TaskSourceContext })
+  | null {
+  if (row.kind === 'github' || row.kind === 'gitlab') {
+    const { type, number, title, url, repoId } = row.item
+    const source =
+      row.kind === 'github'
+        ? buildGitHubWorkspaceSource({ ...row.item, type: row.item.type })
+        : buildGitLabWorkspaceSource(row.item)
+    const context = contexts[row.kind]
+    const github = row.kind === 'github' ? parseGitHubIssueOrPRLink(url) : null
+    const gitlab = row.kind === 'gitlab' ? parseGitLabIssueOrMRLink(url) : null
+    const identity = github
+      ? { provider: 'github' as const, ...github.slug }
+      : gitlab
+        ? { provider: 'gitlab' as const, webUrl: `${new URL(url).origin}/${gitlab.slug.path}` }
+        : context?.providerIdentity
+    return {
+      provider: source.provider,
+      type,
+      number,
+      title,
+      url,
+      repoId,
+      taskSourceContext: context ? { ...context, providerIdentity: identity } : undefined
+    }
+  }
+  if (row.kind === 'linear') {
+    const { linearBranchName: _branchName, ...source } = buildLinearWorkspaceSource(row.issue)
+    return {
+      ...source,
+      identifier: row.issue.identifier,
+      taskSourceContext: contexts.linear
+        ? {
+            ...contexts.linear,
+            providerIdentity: {
+              provider: 'linear',
+              workspaceId: row.issue.workspaceId,
+              workspaceName: row.issue.workspaceName,
+              teamId: row.issue.team.id,
+              teamKey: row.issue.team.key
+            }
+          }
+        : undefined
+    }
+  }
+  if (row.kind === 'jira') {
+    const parsed = parseJiraIssueUrl(row.issue.url)
+    const site =
+      sites.find((site) => site.id === row.issue.siteId) ??
+      (!row.issue.siteId && sites.length === 1 ? sites[0] : null)
+    const source = contexts.jira
+    const identity = source?.providerIdentity
+    const boundUrl =
+      identity?.provider === 'jira' && identity.siteUrl
+        ? parseJiraIssueUrl(`${identity.siteUrl.replace(/\/+$/, '')}/browse/${row.issue.key}`)
+        : null
+    const boundMatches =
+      identity?.provider === 'jira' &&
+      (!row.issue.siteId || row.issue.siteId === identity.siteId) &&
+      parsed &&
+      boundUrl &&
+      parsed.origin === boundUrl.origin &&
+      parsed.sitePath === boundUrl.sitePath
+    const context =
+      source && site && parsed && getMatchingJiraSites(parsed, [site]).length
+        ? bindJiraIssueSourceContext(source, site, row.issue)
+        : boundMatches
+          ? source
+          : null
+    return context
+      ? {
+          ...buildJiraWorkspaceSource(row.issue),
+          identifier: row.issue.key,
+          taskSourceContext: context
+        }
+      : null
+  }
+  return null
+}
diff --git a/src/renderer/src/components/sidebar/folder-workspace-composer-helpers.ts b/src/renderer/src/components/sidebar/folder-workspace-composer-helpers.ts
index a63a2caf9202..6a73cf1e51e6 100644
--- a/src/renderer/src/components/sidebar/folder-workspace-composer-helpers.ts
+++ b/src/renderer/src/components/sidebar/folder-workspace-composer-helpers.ts
@@ -23,7 +23,7 @@ import type { GitLabWorkItem } from '../../../../shared/gitlab-types'
 import type { LinearIssue } from '../../../../shared/linear/issue-types'
 import type { ProjectGroup } from '../../../../shared/project-group-types'
 import type { Repo } from '../../../../shared/repo-types'
-import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/SmartWorkspaceNameField'
+import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/smart-workspace-name-field-model'
 import { translate } from '@/i18n/i18n'
 
 const EMPTY_REPOS: Repo[] = []
diff --git a/src/renderer/src/components/sidebar/workspace-reference-fixtures.test-support.ts b/src/renderer/src/components/sidebar/workspace-reference-fixtures.test-support.ts
new file mode 100644
index 000000000000..312d8f0010c5
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-fixtures.test-support.ts
@@ -0,0 +1,78 @@
+import type { Worktree, WorkspaceAttachment } from '../../../../shared/worktree/types'
+import type { Repo } from '../../../../shared/repo-types'
+import type { HostedReviewInfo } from '../../../../shared/hosted-review'
+import type { LinearIssue } from '../../../../shared/linear/issue-types'
+
+export const referenceRepo: Repo = {
+  id: 'repo',
+  path: '/repo',
+  displayName: 'Orca',
+  badgeColor: '',
+  addedAt: 1,
+  gitRemoteIdentity: {
+    canonicalKey: 'github.com/acme/orca',
+    remoteName: 'origin',
+    remoteUrl: 'https://github.com/acme/orca.git'
+  }
+}
+export const referenceWorkspace: Worktree = {
+  id: 'repo::/repo/feature',
+  repoId: 'repo',
+  path: '/repo/feature',
+  displayName: 'Feature',
+  branch: 'feature',
+  head: 'head',
+  comment: '',
+  linkedIssue: null,
+  linkedPR: 7,
+  linkedLinearIssue: null,
+  isBare: false,
+  isMainWorktree: false,
+  isArchived: false,
+  isUnread: false,
+  isPinned: false,
+  sortOrder: 0,
+  lastActivityAt: 1
+}
+export function referenceAttachment(number = 7): WorkspaceAttachment {
+  return {
+    provider: 'github',
+    type: 'pr',
+    number,
+    url: `https://github.com/acme/orca/pull/${number}`
+  }
+}
+export function referenceReview(
+  number = 7,
+  overrides: Partial<HostedReviewInfo> = {}
+): HostedReviewInfo {
+  const reviewNumber = overrides.number ?? number
+  return {
+    provider: 'github',
+    number: reviewNumber,
+    title: `Review ${reviewNumber}`,
+    url: `https://github.com/acme/orca/pull/${reviewNumber}`,
+    state: 'open',
+    status: 'success',
+    mergeable: 'MERGEABLE',
+    updatedAt: '2026-10-07',
+    ...overrides
+  }
+}
+export function referenceLinearIssue(overrides: Partial<LinearIssue> = {}): LinearIssue {
+  const identifier = overrides.identifier ?? 'ENG-1'
+  return {
+    id: 'id',
+    identifier,
+    title: 'Task',
+    url: `https://linear.app/acme/issue/${identifier}/title`,
+    workspaceId: 'workspace',
+    state: { name: 'In Progress', type: 'started', color: '' },
+    team: { id: 'team', name: 'Engineering', key: 'ENG' },
+    labels: [],
+    labelIds: [],
+    priority: 0,
+    updatedAt: '2026-10-07',
+    ...overrides
+  }
+}
diff --git a/src/renderer/src/hooks/composer-state/composer-source-model.ts b/src/renderer/src/hooks/composer-state/composer-source-model.ts
index 41b335a683b9..1ecef7848792 100644
--- a/src/renderer/src/hooks/composer-state/composer-source-model.ts
+++ b/src/renderer/src/hooks/composer-state/composer-source-model.ts
@@ -7,7 +7,7 @@ import type { LinearIssue } from '../../../../shared/linear/issue-types'
 import type { SparsePreset } from '../../../../shared/worktree/create-types'
 import type { GlobalSettings } from '../../../../shared/global-settings-types'
 import type { PendingSmartGitHubSubmitResolution } from './source-selection-decisions'
-import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/SmartWorkspaceNameField'
+import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/smart-workspace-name-field-model'
 export type ComposerSourceModel = {
   addComposerAttachments: (paths: string[]) => void
   applyLinkedGitLabWorkItem: (item: GitLabWorkItem) => void
diff --git a/src/renderer/src/hooks/composer-state/identity-model.ts b/src/renderer/src/hooks/composer-state/identity-model.ts
index b207d3ed88b6..be289c4e1377 100644
--- a/src/renderer/src/hooks/composer-state/identity-model.ts
+++ b/src/renderer/src/hooks/composer-state/identity-model.ts
@@ -1,7 +1,7 @@
 import type * as React from 'react'
 import type { TuiAgent } from '../../../../shared/tui-agent'
 import type { GitPushTarget } from '../../../../shared/worktree/types'
-import type { SmartNameMode } from '@/components/new-workspace/smart-workspace-source-results'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
 
 export type ComposerIdentityModel = {
   linkedIssue: string
diff --git a/src/renderer/src/hooks/composer-state/issue-source-actions.ts b/src/renderer/src/hooks/composer-state/issue-source-actions.ts
index 64a6cf54e9a9..58df16c9cc03 100644
--- a/src/renderer/src/hooks/composer-state/issue-source-actions.ts
+++ b/src/renderer/src/hooks/composer-state/issue-source-actions.ts
@@ -54,7 +54,7 @@ import {
   buildWorkspaceSourceSelection,
   shouldApplyWorkspaceSourceAutoName
 } from '../../../../shared/new-workspace/workspace-source'
-import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/SmartWorkspaceNameField'
+import type { SmartWorkspaceNameSelection } from '@/components/new-workspace/smart-workspace-name-field-model'
 import type { TaskSourceContext } from '../../../../shared/task-source-context'
 
 export function useIssueSourceActions(input: IssueSourceActionsInput) {
diff --git a/src/renderer/src/hooks/composer-state/workspace-identity-state.ts b/src/renderer/src/hooks/composer-state/workspace-identity-state.ts
index b31878ccb964..37606e8cd7f3 100644
--- a/src/renderer/src/hooks/composer-state/workspace-identity-state.ts
+++ b/src/renderer/src/hooks/composer-state/workspace-identity-state.ts
@@ -20,7 +20,7 @@ import { getLinkedWorkItemProvider, isGitLabIssueUrl } from '@/lib/new-workspace
 import {
   type SmartNameMode,
   isBlockingJiraUrlIntent
-} from '@/components/new-workspace/smart-workspace-source-results'
+} from '../../../../shared/new-workspace/smart-workspace-source-results'
 import type { GitPushTarget } from '../../../../shared/worktree/types'
 import type { TuiAgent } from '../../../../shared/tui-agent'
 import { filterEnabledTuiAgents, isTuiAgentEnabled } from '../../../../shared/tui-agent-selection'
diff --git a/src/renderer/src/i18n/en-runtime-required.json b/src/renderer/src/i18n/en-runtime-required.json
index 57c9143f1eb0..fb8572dee168 100644
--- a/src/renderer/src/i18n/en-runtime-required.json
+++ b/src/renderer/src/i18n/en-runtime-required.json
@@ -3166,7 +3166,6 @@
       "linearConnectRequired": "Connect Linear in Settings to link this issue.",
       "linearModeRequired": "Select Smart or Linear to load this issue.",
       "linearReadFailed": "Couldn’t load this Linear issue. Check the URL and connected workspace.",
-      "linkedResult": "Linked",
       "loadingLinear": "Loading Linear issue…",
       "manage": "Manage links…",
       "mrReference": "MR !{{number}}",

From a2114892304d015c77d5bf9ed2c0367eee514178 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:42:11 -0700
Subject: [PATCH 03/17] Add saved force-delete preference to workspace deletion
 menu (#26425)

* Give Windows Electron writer probes a larger test budget

* Drain queued writer replies across two poll turns before timing out

* Check writer shutdown after both reply-drain turns

* Add inline always-force-delete preference to workspace recovery toast

* Use split-button menu for saved force-delete preference

* Await durable force-delete preference writes before deleting

* Restore absent settings keys after failed durable writes

* Place deletion translations beside worktree copy
---
 src/main/ipc/settings.test.ts                 |  19 +++
 src/main/ipc/settings.ts                      |   8 +-
 .../durable-settings-write.test.ts            |  96 +++++++++++
 .../loading-store/profile-preferences.ts      |  47 ++++++
 src/renderer/src/App.tsx                      |   2 +-
 .../sidebar/WorktreeForceDeleteButton.tsx     | 111 +++++++++++++
 ...-worktree-always-force-preference.test.tsx | 153 ++++++++++++++++++
 .../sidebar/delete-worktree-failure-toast.tsx |  18 ++-
 .../sidebar/run-worktree-delete-with-toast.ts |   2 +
 src/renderer/src/i18n/locales/en.json         |   6 +
 .../worktrees-always-force-delete.test.ts     | 117 ++++++++++++++
 .../worktrees/teardown/remove-worktree.ts     |  23 +--
 .../teardown/worktree-removal-preference.ts   |  20 +++
 src/shared/default-global-settings.ts         |   1 +
 src/shared/global-settings-types.ts           |   2 +
 15 files changed, 604 insertions(+), 21 deletions(-)
 create mode 100644 src/main/persistence/loading-store/durable-settings-write.test.ts
 create mode 100644 src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
 create mode 100644 src/renderer/src/components/sidebar/delete-worktree-always-force-preference.test.tsx
 create mode 100644 src/renderer/src/store/slices/worktrees-always-force-delete.test.ts
 create mode 100644 src/renderer/src/store/slices/worktrees/teardown/worktree-removal-preference.ts

diff --git a/src/main/ipc/settings.test.ts b/src/main/ipc/settings.test.ts
index 3089af28e74a..b1b4a8cdea47 100644
--- a/src/main/ipc/settings.test.ts
+++ b/src/main/ipc/settings.test.ts
@@ -99,6 +99,7 @@ type SettingsChangedListener = (
 const store = {
   getSettings: vi.fn(),
   updateSettings: vi.fn(),
+  updateSettingsAndFlush: vi.fn(),
   getGitHubCache: vi.fn(),
   setGitHubCache: vi.fn(),
   onSettingsChanged: vi.fn(() => () => {})
@@ -107,6 +108,7 @@ const store = {
 describe('registerSettingsHandlers', () => {
   beforeEach(() => {
     handleMock.mockClear()
+    store.updateSettingsAndFlush.mockReset()
     onMock.mockClear()
     applyAppIconMock.mockClear()
     applyAgentStatusHooksEnabledMock.mockReset().mockResolvedValue([])
@@ -239,6 +241,23 @@ describe('registerSettingsHandlers', () => {
     )
   })
 
+  it('propagates a failed durable force-delete preference write through settings:set', async () => {
+    store.getSettings.mockReturnValue({ alwaysForceDeleteWorktrees: false })
+    store.updateSettingsAndFlush.mockRejectedValue(new Error('Disk full'))
+    registerSettingsHandlers(store as never)
+    const handler = handleMock.mock.calls.find((call) => call[0] === 'settings:set')?.[1]
+    if (typeof handler !== 'function') {
+      throw new Error('Missing settings:set handler')
+    }
+    await expect(
+      handler(settingsInvokeEvent, { alwaysForceDeleteWorktrees: true, editorWordWrap: false })
+    ).rejects.toThrow('Disk full')
+    expect(store.updateSettingsAndFlush).toHaveBeenCalledWith(
+      { alwaysForceDeleteWorktrees: true, editorWordWrap: false },
+      { notifyListeners: true, originWebContentsId: 1 }
+    )
+  })
+
   it('persists Active Server only through the dedicated preference channel', () => {
     store.updateSettings.mockReturnValue({ activeRuntimeEnvironmentId: 'windows-2' })
     registerSettingsHandlers(store as never)
diff --git a/src/main/ipc/settings.ts b/src/main/ipc/settings.ts
index e2a173e21b16..8442bfd86829 100644
--- a/src/main/ipc/settings.ts
+++ b/src/main/ipc/settings.ts
@@ -199,10 +199,14 @@ export function registerSettingsHandlers(
     // (e.g. blur after a no-op edit), and a `settings_changed` event for a
     // no-op flip would inflate the experimental-feature-adoption signal.
     const before = store.getSettings()
-    const result = store.updateSettings(sanitizedArgs, {
+    const updateOptions = {
       notifyListeners: true,
       originWebContentsId: event.sender.id
-    })
+    }
+    const result =
+      'alwaysForceDeleteWorktrees' in sanitizedArgs
+        ? await store.updateSettingsAndFlush(sanitizedArgs, updateOptions)
+        : store.updateSettings(sanitizedArgs, updateOptions)
     const proxySettingsChanged =
       ('httpProxyUrl' in sanitizedArgs && before.httpProxyUrl !== result.httpProxyUrl) ||
       ('httpProxyBypassRules' in sanitizedArgs &&
diff --git a/src/main/persistence/loading-store/durable-settings-write.test.ts b/src/main/persistence/loading-store/durable-settings-write.test.ts
new file mode 100644
index 000000000000..3a415c8bd667
--- /dev/null
+++ b/src/main/persistence/loading-store/durable-settings-write.test.ts
@@ -0,0 +1,96 @@
+import { expect, it, vi } from 'vitest'
+import {
+  createWorkerMaintenanceFixture,
+  maintenanceBarrier
+} from './profile-state-maintenance-fixture'
+
+vi.mock('../../telemetry/client', () => ({ track: vi.fn() }))
+vi.mock('../../telemetry/cohort-classifier', () => ({
+  getCohortAtEmit: () => ({ nth_repo_added: 2 })
+}))
+vi.mock('../../ssh/ssh-config-parser', () => ({
+  loadUserSshConfig: () => ({ hosts: [] }),
+  sshConfigHostsToTargets: () => []
+}))
+
+it('waits for the SQLite write before returning or publishing the preference', async () => {
+  const { store, authority, readState } = await createWorkerMaintenanceFixture()
+  const started = maintenanceBarrier()
+  const release = maintenanceBarrier()
+  const write = authority.writeSerializedDomains.bind(authority)
+  vi.spyOn(authority, 'writeSerializedDomains').mockImplementationOnce(async (domains) => {
+    started.resolve()
+    await release.promise
+    await write(domains)
+  })
+  const onChanged = vi.fn()
+  store.onSettingsChanged(onChanged)
+  let settled = false
+  const pending = store.updateSettingsAndFlush(
+    { alwaysForceDeleteWorktrees: true },
+    { notifyListeners: true, originWebContentsId: 7 }
+  )
+  void pending.then(() => {
+    settled = true
+  })
+  await started.promise
+  expect(settled).toBe(false)
+  expect(onChanged).not.toHaveBeenCalled()
+  store.updateSettings({ theme: 'dark' })
+  release.resolve()
+  expect((await pending).theme).toBe('dark')
+  expect(readState().settings.alwaysForceDeleteWorktrees).toBe(true)
+  expect(onChanged).toHaveBeenCalledWith(
+    { alwaysForceDeleteWorktrees: true },
+    expect.objectContaining({ alwaysForceDeleteWorktrees: true }),
+    7
+  )
+})
+
+it('rejects a failed disk write and rolls back without publishing the preference', async () => {
+  const { store, authority, readState } = await createWorkerMaintenanceFixture()
+  const previous = store.getSettings().alwaysForceDeleteWorktrees
+  vi.spyOn(authority, 'writeSerializedDomains').mockRejectedValueOnce(new Error('Disk full'))
+  const onChanged = vi.fn()
+  store.onSettingsChanged(onChanged)
+  await expect(
+    store.updateSettingsAndFlush({ alwaysForceDeleteWorktrees: true }, { notifyListeners: true })
+  ).rejects.toThrow('Disk full')
+  expect(store.getSettings().alwaysForceDeleteWorktrees).toBe(previous)
+  expect(readState().settings.alwaysForceDeleteWorktrees).toBe(previous)
+  expect(onChanged).not.toHaveBeenCalled()
+})
+
+it('rolls back the preference while retaining unrelated concurrent settings edits', async () => {
+  const { store, authority } = await createWorkerMaintenanceFixture()
+  const previous = store.getSettings().alwaysForceDeleteWorktrees
+  const started = maintenanceBarrier()
+  const release = maintenanceBarrier()
+  vi.spyOn(authority, 'writeSerializedDomains').mockImplementationOnce(async () => {
+    started.resolve()
+    await release.promise
+    throw new Error('Disk full')
+  })
+  const pending = store.updateSettingsAndFlush({ alwaysForceDeleteWorktrees: true })
+  const rejected = expect(pending).rejects.toThrow('Disk full')
+  await started.promise
+  store.updateSettings({ theme: 'dark' })
+  release.resolve()
+  await rejected
+  expect(store.getSettings()).toMatchObject({
+    alwaysForceDeleteWorktrees: previous,
+    theme: 'dark'
+  })
+})
+
+it('removes previously absent optional keys after a failed preference payload write', async () => {
+  const { store, authority } = await createWorkerMaintenanceFixture()
+  delete store.getSettings().editorWordWrap
+  const previous = store.getSettings().alwaysForceDeleteWorktrees
+  vi.spyOn(authority, 'writeSerializedDomains').mockRejectedValueOnce(new Error('Disk full'))
+  await expect(
+    store.updateSettingsAndFlush({ alwaysForceDeleteWorktrees: true, editorWordWrap: false })
+  ).rejects.toThrow('Disk full')
+  expect(Object.hasOwn(store.getSettings(), 'editorWordWrap')).toBe(false)
+  expect(store.getSettings().alwaysForceDeleteWorktrees).toBe(previous)
+})
diff --git a/src/main/persistence/loading-store/profile-preferences.ts b/src/main/persistence/loading-store/profile-preferences.ts
index 153155189611..e3760a5d5f68 100644
--- a/src/main/persistence/loading-store/profile-preferences.ts
+++ b/src/main/persistence/loading-store/profile-preferences.ts
@@ -25,6 +25,7 @@ type ProfilePreferencesRuntime = Pick<
   | 'githubCacheDirty'
   | 'githubCacheGeneration'
   | 'protectedSecrets'
+  | 'runDurableMutation'
   | 'settingsChangeListeners'
   | 'state'
   | 'uiChangeListeners'
@@ -74,6 +75,52 @@ export class ProfilePreferences {
     return updateSettingsOperation(getSettingsMutationOperations(this), updates, options)
   }
 
+  async updateSettingsAndFlush(
+    updates: Partial<GlobalSettings>,
+    options: { notifyListeners?: boolean; originWebContentsId?: number } = {}
+  ): Promise<GlobalSettings> {
+    const { runtime } = this[profilePreferencesContext]
+    let changedUpdates: Partial<GlobalSettings> = {}
+    await runtime.runDurableMutation(() => {
+      const previous = runtime.state.settings
+      const next = this.updateSettings(updates)
+      const previousEntries = new Map(Object.entries(previous))
+      const updateKeys = new Set(Object.keys(updates))
+      changedUpdates = Object.fromEntries(
+        Object.entries(next).filter(
+          ([key, value]) => updateKeys.has(key) && !Object.is(previousEntries.get(key), value)
+        )
+      )
+      return {
+        value: undefined,
+        rollback: () => {
+          const currentEntries = new Map(Object.entries(runtime.state.settings))
+          const nextEntries = new Map(Object.entries(next))
+          const restoredUpdates = Object.fromEntries(
+            Object.entries(previous).filter(
+              ([key]) =>
+                updateKeys.has(key) && Object.is(currentEntries.get(key), nextEntries.get(key))
+            )
+          )
+          const restoredSettings = { ...runtime.state.settings, ...restoredUpdates }
+          for (const key of updateKeys) {
+            if (
+              !previousEntries.has(key) &&
+              Object.is(currentEntries.get(key), nextEntries.get(key))
+            ) {
+              Reflect.deleteProperty(restoredSettings, key)
+            }
+          }
+          runtime.state.settings = restoredSettings
+        }
+      }
+    })
+    if (options.notifyListeners && Object.keys(changedUpdates).length > 0) {
+      notifySettingsChanged(this, changedUpdates, options.originWebContentsId)
+    }
+    return this.getSettings()
+  }
+
   getUI(): PersistedState['ui'] {
     return getPersistedUI(
       this[profilePreferencesContext].runtime.state,
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 892c445d100b..1ed1194a66bb 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -101,8 +101,8 @@ function App(): React.JSX.Element {
             <BrowserWebAuthnAccountDialog />
           </LinkRoutingPreferenceDialogProvider>
         </ConfirmationDialogProvider>
+        <Toaster closeButton toastOptions={{ className: 'font-sans text-sm' }} />
       </TooltipProvider>
-      <Toaster closeButton toastOptions={{ className: 'font-sans text-sm' }} />
       <SkillFreshnessNudge />
       <WorktreeBaseFallbackDialog />
       <PinnedTabCloseDialog />
diff --git a/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx b/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
new file mode 100644
index 000000000000..259176381ee9
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
@@ -0,0 +1,111 @@
+import { useState } from 'react'
+import { ChevronDown } from 'lucide-react'
+import { toast } from 'sonner'
+import { translate } from '@/i18n/i18n'
+import { Button } from '../ui/button'
+import { ButtonGroup } from '../ui/button-group'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger
+} from '../ui/dropdown-menu'
+import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/tooltip'
+
+export function WorktreeForceDeleteButton({
+  toastId,
+  onForceDelete,
+  onAlwaysForceDelete
+}: {
+  toastId: string
+  onForceDelete: () => void
+  onAlwaysForceDelete?: () => Promise<void>
+}): React.JSX.Element {
+  const [isSaving, setIsSaving] = useState(false)
+  const forceDelete = (): void => {
+    toast.dismiss(toastId)
+    onForceDelete()
+  }
+  const alwaysForceDelete = async (): Promise<void> => {
+    if (!onAlwaysForceDelete) {
+      return
+    }
+    setIsSaving(true)
+    try {
+      await onAlwaysForceDelete()
+    } catch (error) {
+      setIsSaving(false)
+      toast.error(
+        translate('workspaceDeletion.preferenceSaveFailed', 'Could not save deletion preference'),
+        { description: error instanceof Error ? error.message : String(error) }
+      )
+      return
+    }
+    forceDelete()
+  }
+
+  return (
+    <DropdownMenu modal={false}>
+      <ButtonGroup
+        onBlur={(event) => {
+          if (
+            event.relatedTarget instanceof HTMLElement &&
+            event.relatedTarget.closest('[data-radix-menu-content]')
+          ) {
+            event.stopPropagation()
+          }
+        }}
+      >
+        <Button
+          type="button"
+          variant="destructive"
+          size="sm"
+          disabled={isSaving}
+          onClick={forceDelete}
+        >
+          {translate('auto.components.sidebar.delete.worktree.flow.2b20ce87b3', 'Force Delete')}
+        </Button>
+        {onAlwaysForceDelete ? (
+          <DropdownMenuTrigger asChild>
+            <Button
+              type="button"
+              variant="destructive"
+              size="icon-sm"
+              disabled={isSaving}
+              aria-label={translate('workspaceDeletion.moreActions', 'More force delete options')}
+            >
+              <ChevronDown className="size-3.5" />
+            </Button>
+          </DropdownMenuTrigger>
+        ) : null}
+      </ButtonGroup>
+      {onAlwaysForceDelete ? (
+        <DropdownMenuContent
+          align="end"
+          // Sonner restores toast focus on blur; the portaled menu owns its focus.
+          onFocus={(event) => event.stopPropagation()}
+          onBlur={(event) => event.stopPropagation()}
+        >
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <DropdownMenuItem
+                variant="destructive"
+                onSelect={() => {
+                  void alwaysForceDelete()
+                }}
+              >
+                {translate('workspaceDeletion.alwaysForceDelete', 'Always force delete')}
+              </DropdownMenuItem>
+            </TooltipTrigger>
+            <TooltipContent side="left" sideOffset={8}>
+              {translate(
+                'workspaceDeletion.alwaysForceDeleteTooltip',
+                'Applies to all future workspace deletions.'
+              )}
+            </TooltipContent>
+          </Tooltip>
+        </DropdownMenuContent>
+      ) : null}
+    </DropdownMenu>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/delete-worktree-always-force-preference.test.tsx b/src/renderer/src/components/sidebar/delete-worktree-always-force-preference.test.tsx
new file mode 100644
index 000000000000..c372f5204c6d
--- /dev/null
+++ b/src/renderer/src/components/sidebar/delete-worktree-always-force-preference.test.tsx
@@ -0,0 +1,153 @@
+// @vitest-environment happy-dom
+
+import { act, isValidElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import { TooltipProvider } from '../ui/tooltip'
+import { showDeleteWorktreeFailureToast } from './delete-worktree-failure-toast'
+
+vi.mock('sonner', () => ({ toast: { info: vi.fn(), error: vi.fn(), dismiss: vi.fn() } }))
+
+let root: Root | undefined
+
+function renderRecovery(onAlwaysForceDelete: () => Promise<void>, canForceDelete = true) {
+  const onForceDelete = vi.fn()
+  const onOutsideBlur = vi.fn()
+  showDeleteWorktreeFailureToast({
+    error: 'branch has changes',
+    canForceDelete,
+    forceDeleteReason: canForceDelete ? 'dirty' : null,
+    onViewChanges: vi.fn(),
+    onForceDelete,
+    onAlwaysForceDelete,
+    onDeleteAnyway: vi.fn(),
+    worktreeId: 'wt-1',
+    worktreeName: 'feature/foo'
+  })
+  const description = vi
+    .mocked(canForceDelete ? toast.info : toast.error)
+    .mock.calls.at(-1)?.[1]?.description
+  if (!isValidElement(description)) {
+    throw new Error('Expected a rendered recovery toast')
+  }
+  const container = document.createElement('div')
+  document.body.appendChild(container)
+  root = createRoot(container)
+  act(() =>
+    root?.render(
+      <TooltipProvider delayDuration={0}>
+        <div
+          onBlur={(event) => {
+            if (!event.currentTarget.contains(event.relatedTarget)) {
+              onOutsideBlur()
+            }
+          }}
+        >
+          {description}
+        </div>
+      </TooltipProvider>
+    )
+  )
+  return { container, onForceDelete, onOutsideBlur }
+}
+
+function click(container: HTMLElement, selector: string): void {
+  const element = container.querySelector(selector)
+  if (!(element instanceof HTMLElement)) {
+    throw new Error(`Missing ${selector}`)
+  }
+  element.click()
+}
+
+async function selectAlwaysForceDelete(container: HTMLElement): Promise<void> {
+  await act(async () => {
+    const trigger = container.querySelector('button[aria-label="More force delete options"]')
+    if (!(trigger instanceof HTMLElement)) {
+      throw new Error('Missing dropdown trigger')
+    }
+    trigger.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
+  })
+  await act(async () => click(document.body, '[role="menuitem"]'))
+}
+
+afterEach(() => {
+  act(() => root?.unmount())
+  root = undefined
+  document.body.innerHTML = ''
+  vi.clearAllMocks()
+})
+
+it('keeps the main Force Delete button a one-time action', async () => {
+  const savePreference = vi.fn().mockResolvedValue(undefined)
+  const { container, onForceDelete } = renderRecovery(savePreference)
+  expect(container.querySelector('button[aria-label="More force delete options"]')).not.toBeNull()
+  expect(document.querySelector('[role="menuitem"]')).toBeNull()
+
+  await act(async () => click(container, 'button[data-variant="destructive"]'))
+
+  expect(savePreference).not.toHaveBeenCalled()
+  expect(onForceDelete).toHaveBeenCalledOnce()
+})
+
+it('keeps portaled menu focus from triggering toast focus restoration', async () => {
+  const { container, onOutsideBlur } = renderRecovery(vi.fn())
+  const trigger = container.querySelector('button[aria-label="More force delete options"]')
+  if (!(trigger instanceof HTMLElement)) {
+    throw new Error('Missing dropdown trigger')
+  }
+  await act(async () => {
+    trigger.focus()
+    trigger.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
+  })
+  const item = document.querySelector('[role="menuitem"]')
+  if (!(item instanceof HTMLElement)) {
+    throw new Error('Missing preference menu item')
+  }
+  await act(async () => item.focus())
+  expect(onOutsideBlur).not.toHaveBeenCalled()
+  expect(document.querySelector('[role="menu"]')).not.toBeNull()
+})
+
+it('waits for the preference to persist before force-deleting and dismissing', async () => {
+  let finishSaving: (() => void) | undefined
+  const savePreference = vi.fn(
+    () =>
+      new Promise<void>((resolve) => {
+        finishSaving = resolve
+      })
+  )
+  const { container, onForceDelete } = renderRecovery(savePreference)
+  await selectAlwaysForceDelete(container)
+
+  expect(savePreference).toHaveBeenCalledOnce()
+  expect(
+    container.querySelector('button[data-variant="destructive"]')?.hasAttribute('disabled')
+  ).toBe(true)
+  expect(onForceDelete).not.toHaveBeenCalled()
+  expect(toast.dismiss).not.toHaveBeenCalled()
+  await act(async () => finishSaving?.())
+  expect(onForceDelete).toHaveBeenCalledOnce()
+  expect(toast.dismiss).toHaveBeenCalledWith('delete-worktree-failure:wt-1')
+})
+
+it('keeps recovery available when saving the preference fails', async () => {
+  const { container, onForceDelete } = renderRecovery(
+    vi.fn().mockRejectedValue(new Error('Disk full'))
+  )
+  await selectAlwaysForceDelete(container)
+
+  expect(onForceDelete).not.toHaveBeenCalled()
+  expect(toast.dismiss).not.toHaveBeenCalled()
+  expect(toast.error).toHaveBeenCalledWith('Could not save deletion preference', {
+    description: 'Disk full'
+  })
+  expect(
+    container.querySelector('button[data-variant="destructive"]')?.hasAttribute('disabled')
+  ).toBe(false)
+})
+
+it('does not offer the preference for a failure that cannot be force-deleted', () => {
+  const { container } = renderRecovery(vi.fn(), false)
+  expect(container.querySelector('button[aria-label="More force delete options"]')).toBeNull()
+})
diff --git a/src/renderer/src/components/sidebar/delete-worktree-failure-toast.tsx b/src/renderer/src/components/sidebar/delete-worktree-failure-toast.tsx
index 5f6e93444fa7..8dc934ae4261 100644
--- a/src/renderer/src/components/sidebar/delete-worktree-failure-toast.tsx
+++ b/src/renderer/src/components/sidebar/delete-worktree-failure-toast.tsx
@@ -3,6 +3,7 @@ import { Button } from '../ui/button'
 import { getDeleteWorktreeToastCopy } from './delete-worktree-toast'
 import { translate } from '@/i18n/i18n'
 import { DeleteNestedWorktreesDialog } from './DeleteNestedWorktreesDialog'
+import { WorktreeForceDeleteButton } from './WorktreeForceDeleteButton'
 import { isNestedWorktreeRemovalError } from '../../../../shared/worktree/nested-removal'
 import {
   isLockedWorktreeRemovalError,
@@ -20,6 +21,7 @@ type DeleteWorktreeFailureToastOptions = {
   canWaiveArchiveHook?: boolean
   onViewChanges: () => void
   onForceDelete: () => void
+  onAlwaysForceDelete?: () => Promise<void>
   onDeleteAnyway: () => void
   worktreeId: string
   worktreeName: string
@@ -38,6 +40,7 @@ function DeleteWorktreeFailureToastBody({
   showViewChanges,
   onViewChanges,
   onForceDelete,
+  onAlwaysForceDelete,
   onDeleteAnyway,
   toastId,
   nestedRemovalTarget,
@@ -50,6 +53,7 @@ function DeleteWorktreeFailureToastBody({
   showViewChanges: boolean
   onViewChanges: () => void
   onForceDelete: () => void
+  onAlwaysForceDelete?: () => Promise<void>
   onDeleteAnyway: () => void
   toastId: string
   nestedRemovalTarget?: WorktreeRemovalTarget
@@ -60,10 +64,6 @@ function DeleteWorktreeFailureToastBody({
     toast.dismiss(toastId)
     onViewChanges()
   }
-  const forceDelete = (): void => {
-    toast.dismiss(toastId)
-    onForceDelete()
-  }
   const deleteAnyway = (): void => {
     toast.dismiss(toastId)
     onDeleteAnyway()
@@ -89,9 +89,11 @@ function DeleteWorktreeFailureToastBody({
           />
         ) : null}
         {canForceDelete ? (
-          <Button type="button" variant="destructive" size="sm" onClick={forceDelete}>
-            {translate('auto.components.sidebar.delete.worktree.flow.2b20ce87b3', 'Force Delete')}
-          </Button>
+          <WorktreeForceDeleteButton
+            toastId={toastId}
+            onForceDelete={onForceDelete}
+            onAlwaysForceDelete={onAlwaysForceDelete}
+          />
         ) : null}
         {canWaiveArchiveHook ? (
           <Button type="button" variant="destructive" size="sm" onClick={deleteAnyway}>
@@ -115,6 +117,7 @@ export function showDeleteWorktreeFailureToast({
   canWaiveArchiveHook,
   onViewChanges,
   onForceDelete,
+  onAlwaysForceDelete,
   onDeleteAnyway,
   worktreeId,
   worktreeName,
@@ -146,6 +149,7 @@ export function showDeleteWorktreeFailureToast({
         showViewChanges={!isLockedWorktreeRemovalError(error) || hasKnownChanges === true}
         onViewChanges={onViewChanges}
         onForceDelete={onForceDelete}
+        onAlwaysForceDelete={onAlwaysForceDelete}
         onDeleteAnyway={onDeleteAnyway}
         toastId={id}
         nestedRemovalTarget={nestedTarget}
diff --git a/src/renderer/src/components/sidebar/run-worktree-delete-with-toast.ts b/src/renderer/src/components/sidebar/run-worktree-delete-with-toast.ts
index 68f8d0efea42..640ac5fc15aa 100644
--- a/src/renderer/src/components/sidebar/run-worktree-delete-with-toast.ts
+++ b/src/renderer/src/components/sidebar/run-worktree-delete-with-toast.ts
@@ -60,6 +60,8 @@ export function runWorktreeDeleteWithToast(
       lockReason: state?.lockReason ?? null,
       hasKnownChanges,
       onViewChanges: () => viewWorktreeDiff(worktreeId, target.executionHostId),
+      onAlwaysForceDelete: () =>
+        useAppStore.getState().updateSettingsOrThrow({ alwaysForceDeleteWorktrees: true }),
       // Why (#19334): re-runs the archive hook and waives the failure this time, so the waiver
       // is an informed choice made after reading the refusal -- not something `force` implied.
       onDeleteAnyway: () =>
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 9cc7c3d90488..97abc760cd61 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -19475,6 +19475,12 @@
   "fileSearch": {
     "failed": "Search failed. Try again."
   },
+  "workspaceDeletion": {
+    "preferenceSaveFailed": "Could not save deletion preference",
+    "alwaysForceDelete": "Always force delete",
+    "moreActions": "More force delete options",
+    "alwaysForceDeleteTooltip": "Applies to all future workspace deletions."
+  },
   "worktree": {
     "nestedRemoval": {
       "refreshFailed": "Could not refresh the workspace list",
diff --git a/src/renderer/src/store/slices/worktrees-always-force-delete.test.ts b/src/renderer/src/store/slices/worktrees-always-force-delete.test.ts
new file mode 100644
index 000000000000..ebe52c37af81
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees-always-force-delete.test.ts
@@ -0,0 +1,117 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import { getDefaultSettings } from '../../../../shared/constants'
+import { makeWorktree } from './worktrees-slice-test-fixtures'
+import {
+  createTestStore,
+  mockApi,
+  resetRemoteRuntimeMocks,
+  resetWorktreeSliceModuleMemory,
+  runtimeEnvironmentCall
+} from './worktrees-slice-test-harness'
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  resetWorktreeSliceModuleMemory()
+  resetRemoteRuntimeMocks()
+  mockApi.worktrees.remove.mockResolvedValue({})
+  runtimeEnvironmentCall.mockResolvedValue({
+    id: 'rpc-rm',
+    ok: true,
+    result: {},
+    _meta: { runtimeId: 'runtime-remote' }
+  })
+})
+
+it.each([undefined, false, true])(
+  'uses the saved force-delete preference for local deletion: %s',
+  async (enabled) => {
+    const store = createTestStore()
+    const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1' })
+    store.setState({
+      settings: { ...getDefaultSettings('/home/test'), alwaysForceDeleteWorktrees: enabled },
+      worktreesByRepo: { [wt.repoId]: [wt] }
+    })
+
+    expect(
+      await store.getState().removeWorktree({ id: wt.id, executionHostId: null }, false)
+    ).toEqual({ ok: true })
+    expect(mockApi.worktrees.remove).toHaveBeenCalledWith(
+      expect.objectContaining({
+        worktreeId: wt.id,
+        force: enabled === true,
+        allowUnverifiedPtyStop: enabled === true,
+        allowFailedArchiveHook: false
+      })
+    )
+  }
+)
+
+it('applies the preference through the existing remote removal flags', async () => {
+  const store = createTestStore()
+  const wt = makeWorktree({
+    id: 'repo1::/path/wt1',
+    repoId: 'repo1',
+    hostId: 'runtime:env-1',
+    runtimeOwnerEnvironmentId: 'env-1'
+  })
+  store.setState({
+    settings: {
+      ...getDefaultSettings('/home/test'),
+      activeRuntimeEnvironmentId: 'different-focused-hub',
+      alwaysForceDeleteWorktrees: true
+    },
+    worktreesByRepo: { [wt.repoId]: [wt] }
+  })
+
+  expect(
+    await store.getState().removeWorktree({ id: wt.id, executionHostId: 'runtime:env-1' }, false)
+  ).toEqual({ ok: true })
+  expect(runtimeEnvironmentCall).toHaveBeenCalledWith(
+    expect.objectContaining({
+      selector: 'env-1',
+      method: 'worktree.rm',
+      params: expect.objectContaining({
+        worktree: `id:${wt.id}`,
+        force: true,
+        allowUnverifiedPtyStop: true,
+        runHooks: true
+      })
+    })
+  )
+  expect(mockApi.worktrees.remove).not.toHaveBeenCalled()
+})
+
+it('still reports a failed forced removal instead of treating the workspace as deleted', async () => {
+  mockApi.worktrees.remove.mockRejectedValue(new Error('Workspace is locked'))
+  const store = createTestStore()
+  const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1' })
+  store.setState({
+    settings: { ...getDefaultSettings('/home/test'), alwaysForceDeleteWorktrees: true },
+    worktreesByRepo: { [wt.repoId]: [wt] }
+  })
+
+  expect(
+    await store.getState().removeWorktree({ id: wt.id, executionHostId: null }, false)
+  ).toEqual({ ok: false, error: 'Workspace is locked' })
+  expect(store.getState().worktreesByRepo[wt.repoId]).toEqual([wt])
+})
+
+it('keeps forgetting a disconnected workspace metadata-only when the preference is enabled', async () => {
+  const store = createTestStore()
+  const wt = makeWorktree({ id: 'repo1::/path/wt1', repoId: 'repo1', hostId: 'ssh:offline' })
+  store.setState({
+    settings: { ...getDefaultSettings('/home/test'), alwaysForceDeleteWorktrees: true },
+    worktreesByRepo: { [wt.repoId]: [wt] }
+  })
+
+  expect(
+    await store.getState().removeWorktree({ id: wt.id, executionHostId: 'ssh:offline' }, false, {
+      mode: 'forget-local'
+    })
+  ).toEqual({ ok: true })
+  expect(mockApi.worktrees.forgetLocal).toHaveBeenCalledWith(
+    expect.objectContaining({ worktreeId: wt.id })
+  )
+  expect(mockApi.worktrees.remove).not.toHaveBeenCalled()
+  expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/store/slices/worktrees/teardown/remove-worktree.ts b/src/renderer/src/store/slices/worktrees/teardown/remove-worktree.ts
index 626aeacc2bfa..1ad559bfe420 100644
--- a/src/renderer/src/store/slices/worktrees/teardown/remove-worktree.ts
+++ b/src/renderer/src/store/slices/worktrees/teardown/remove-worktree.ts
@@ -42,6 +42,7 @@ import { clearSessionCommitDraftForWorktree } from '@/lib/source-control-commit-
 import { dispatchWorktreeRemoval } from './dispatch-worktree-removal'
 import { tearDownRemovedWorktreeRendererState } from './removed-worktree-renderer-teardown'
 import { captureWorktreeStateBeforeRemoval } from './worktree-state-before-removal'
+import { resolveWorktreeRemovalPreference } from './worktree-removal-preference'
 
 export function createRemoveWorktree(
   set: WorktreeSliceSet,
@@ -49,7 +50,7 @@ export function createRemoveWorktree(
 ): WorktreeSlice['removeWorktree'] {
   return async (removalTarget, force, options) => {
     const worktreeId = removalTarget.id
-    const forgetLocalOnly = options?.mode === 'forget-local'
+    const policy = resolveWorktreeRemovalPreference(get().settings, force, options)
     // Why (STA-4343): this is the ONE chokepoint every delete entry point shares,
     // so host qualification is enforced here rather than at any single caller — a
     // guard bolted onto the sidebar would drift from the cleanup dialog's. The
@@ -60,7 +61,7 @@ export function createRemoveWorktree(
       get,
       worktreeId,
       requiredExecutionHostId,
-      forgetLocalOnly,
+      policy.forgetLocalOnly,
       options?.ignoreWorkspaceCleanupScanSurvivors === true
     )
     if (!start.ok) {
@@ -94,7 +95,7 @@ export function createRemoveWorktree(
     try {
       // Why: forget-local touches no remote, so there's no archive hook to run or trust prompt needed.
       // Why `get`: same-repo local deletes start together, and one approval must cover the rest.
-      const skipArchive = forgetLocalOnly
+      const skipArchive = policy.forgetLocalOnly
         ? true
         : (await ensureHooksConfirmed(
             get,
@@ -110,7 +111,7 @@ export function createRemoveWorktree(
         requiredExecutionHostId
       )
       const beforeRemoval = captureWorktreeStateBeforeRemoval(get(), worktreeId, hostId)
-      if (!forgetLocalOnly) {
+      if (!policy.forgetLocalOnly) {
         removalGenerationGuard?.assertCurrent()
       }
       // Why: forget-local clears Orca's records via local IPC regardless of host — the remote is gone or unreachable.
@@ -121,28 +122,28 @@ export function createRemoveWorktree(
             ? { ...get().settings, activeRuntimeEnvironmentId: null }
             : { activeRuntimeEnvironmentId: null }
       )
-      const unprovableRemoteRouting = forgetLocalOnly
+      const unprovableRemoteRouting = policy.forgetLocalOnly
         ? null
         : refuseUnprovableRemoteHostRouting(get, worktreeId, target.kind)
       if (unprovableRemoteRouting) {
         throw new Error(unprovableRemoteRouting)
       }
       let removalResult: RemoveWorktreeResult
-      let snapshotPruneHandledByLocalMain = forgetLocalOnly || target.kind === 'local'
+      let snapshotPruneHandledByLocalMain = policy.forgetLocalOnly || target.kind === 'local'
       try {
         removalResult = await dispatchWorktreeRemoval({
           worktreeId,
           hostId,
-          force,
+          force: policy.force,
           skipArchive,
           get,
           target,
-          options,
+          options: policy.options,
           assertCurrent: () => removalGenerationGuard?.assertCurrent()
         })
       } catch (error) {
         if (
-          !forgetLocalOnly &&
+          !policy.forgetLocalOnly &&
           target.kind !== 'local' &&
           (isRuntimeRepoNotFoundError(error) || isRuntimeSelectorNotFoundError(error))
         ) {
@@ -305,8 +306,8 @@ export function createRemoveWorktree(
       const error = readIpcErrorDetail(err) ?? (err instanceof Error ? err.message : String(err))
       const forceDeleteReason = classifyWorktreeForceDeleteReason(
         error,
-        force,
-        options?.allowUnverifiedPtyStop === true
+        policy.force,
+        policy.options?.allowUnverifiedPtyStop === true
       )
       const locked = isLockedWorktreeRemovalError(error)
       // Why (#19334): the refusal is the only failure a retry can clear by waiving rather than by
diff --git a/src/renderer/src/store/slices/worktrees/teardown/worktree-removal-preference.ts b/src/renderer/src/store/slices/worktrees/teardown/worktree-removal-preference.ts
new file mode 100644
index 000000000000..0e3bfe5af9fb
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees/teardown/worktree-removal-preference.ts
@@ -0,0 +1,20 @@
+import type { GlobalSettings } from '../../../../../../shared/global-settings-types'
+import type { RemoveWorktreeOptions } from '../../worktree-removal-options'
+
+export function resolveWorktreeRemovalPreference(
+  settings: GlobalSettings | null,
+  force: boolean | undefined,
+  options: RemoveWorktreeOptions | undefined
+): {
+  forgetLocalOnly: boolean
+  force: boolean | undefined
+  options: RemoveWorktreeOptions | undefined
+} {
+  const forgetLocalOnly = options?.mode === 'forget-local'
+  const alwaysForceDelete = !forgetLocalOnly && settings?.alwaysForceDeleteWorktrees === true
+  return {
+    forgetLocalOnly,
+    force: alwaysForceDelete || force,
+    options: alwaysForceDelete ? { ...options, allowUnverifiedPtyStop: true } : options
+  }
+}
diff --git a/src/shared/default-global-settings.ts b/src/shared/default-global-settings.ts
index 3e8bb8abbca3..7c0bd6afe7c5 100644
--- a/src/shared/default-global-settings.ts
+++ b/src/shared/default-global-settings.ts
@@ -200,6 +200,7 @@ export function buildDefaultSettings(args: {
     devPluginPaths: [],
     claudeAgentTeamsDefaultDisabledMigrated: true,
     skipDeleteWorktreeConfirm: false,
+    alwaysForceDeleteWorktrees: false,
     skipCloseTerminalWithRunningProcessConfirm: false,
     skipDeleteAutomationConfirm: false,
     skipDeleteArtifactConfirm: false,
diff --git a/src/shared/global-settings-types.ts b/src/shared/global-settings-types.ts
index 41fa7e8afa5b..b310d9fca0b1 100644
--- a/src/shared/global-settings-types.ts
+++ b/src/shared/global-settings-types.ts
@@ -361,6 +361,8 @@ export type GlobalSettings = NativeChatGlobalSettings & {
   claudeAgentTeamsDefaultDisabledMigrated?: boolean
   /** Why: worktree deletion is destructive (rm -rf of the working dir), so confirm by default. */
   skipDeleteWorktreeConfirm: boolean
+  /** Opt-in: workspace deletion discards changes and may waive terminal-stop verification. */
+  alwaysForceDeleteWorktrees?: boolean
   /** Why: closing a terminal with child processes kills foreground work; keep this skip separate from other confirmations. */
   skipCloseTerminalWithRunningProcessConfirm: boolean
   /** Why: deleting an automation also deletes its run history; keep this skip separate from worktree deletion. */

From f052e2f1ffd646106f957474c61cec5d668a8698 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:46:47 -0700
Subject: [PATCH 04/17] perf: skip unused Grok login-shell probe when
 installing agent hooks (#26241)

---
 src/main/agent-hooks/managed-hook-runtime.test.ts | 14 +++++++++++++-
 src/main/agent-hooks/managed-hook-runtime.ts      |  4 +++-
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/main/agent-hooks/managed-hook-runtime.test.ts b/src/main/agent-hooks/managed-hook-runtime.test.ts
index e4c23e13959e..79d0742ce6cd 100644
--- a/src/main/agent-hooks/managed-hook-runtime.test.ts
+++ b/src/main/agent-hooks/managed-hook-runtime.test.ts
@@ -155,6 +155,18 @@ describe.runIf(process.platform !== 'win32')('installManagedHooks', () => {
       errors: 0
     })
 
-    expect((await readdir(home)).sort()).toEqual(['.claude', '.orca', SHELL_NAME, SHELL_RUNS_NAME])
+    expect((await readdir(home)).sort()).toEqual(['.claude', '.orca', SHELL_NAME])
+  })
+
+  it('still probes the login shell when Grok is selected', async () => {
+    const home = await createTempHome()
+    await stubLoginShell(home)
+
+    await expect(installManagedHooks({ agents: ['grok'] })).resolves.toEqual({
+      installers: 1,
+      errors: 0
+    })
+
+    expect((await readdir(home)).sort()).toEqual(['.grok', '.orca', SHELL_NAME, SHELL_RUNS_NAME])
   })
 })
diff --git a/src/main/agent-hooks/managed-hook-runtime.ts b/src/main/agent-hooks/managed-hook-runtime.ts
index 99a2c68be89f..4d1baeef609e 100644
--- a/src/main/agent-hooks/managed-hook-runtime.ts
+++ b/src/main/agent-hooks/managed-hook-runtime.ts
@@ -86,7 +86,9 @@ export async function installManagedHooks(options?: {
     return { installers: 0, errors: 0 }
   }
   const home = homedir()
-  const grokHomeDir = await resolveRelayGrokHome(home, options?.signal)
+  const grokHomeDir = agents.includes('grok')
+    ? await resolveRelayGrokHome(home, options?.signal)
+    : undefined
   options?.signal?.throwIfAborted()
   const hostIdentity = scopeManagedHookHostIdentity(
     await readManagedHookHostIdentity(),

From e97d18df060a0ccd689b652aefd07a29fe1b5a71 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:48:20 -0700
Subject: [PATCH 05/17] Avoid repeated session copies when deleting project
 groups (#26230)

---
 .../session-owner-removal.ts                  |  21 +++
 .../project-group-operations.ts               |   6 +-
 .../project-group-session-batch.test.ts       | 163 ++++++++++++++++++
 3 files changed, 187 insertions(+), 3 deletions(-)
 create mode 100644 src/main/persistence/tracking-repos/project-group-session-batch.test.ts

diff --git a/src/main/persistence/restoring-sessions/session-owner-removal.ts b/src/main/persistence/restoring-sessions/session-owner-removal.ts
index 5fac53546c4c..1cb7a44e004d 100644
--- a/src/main/persistence/restoring-sessions/session-owner-removal.ts
+++ b/src/main/persistence/restoring-sessions/session-owner-removal.ts
@@ -131,3 +131,24 @@ export function removeWorkspaceSessionOwners(
   )
   return next
 }
+
+export function removeWorkspaceSessionOwnersEverywhere(
+  state: Pick<PersistedState, 'workspaceSession' | 'workspaceSessionsByHostId'>,
+  ownerKeys: ReadonlySet<string>
+): void {
+  if (ownerKeys.size === 0) {
+    return
+  }
+  state.workspaceSession = removeWorkspaceSessionOwners(state.workspaceSession, ownerKeys)!
+  const partitions = state.workspaceSessionsByHostId
+  if (!partitions) {
+    return
+  }
+  const next: Record<string, WorkspaceSessionState> = {}
+  for (const [hostId, partition] of Object.entries(partitions)) {
+    if (partition) {
+      next[hostId] = removeWorkspaceSessionOwners(partition, ownerKeys)!
+    }
+  }
+  state.workspaceSessionsByHostId = next
+}
diff --git a/src/main/persistence/tracking-repos/project-group-operations.ts b/src/main/persistence/tracking-repos/project-group-operations.ts
index 47a8166e9675..d17eaf47ca97 100644
--- a/src/main/persistence/tracking-repos/project-group-operations.ts
+++ b/src/main/persistence/tracking-repos/project-group-operations.ts
@@ -6,7 +6,7 @@ import {
   normalizeProjectGroupName
 } from '../../../shared/project-groups'
 import { folderWorkspaceKey } from '../../../shared/workspace-scope'
-import { removeWorkspaceSessionOwnerEverywhere } from '../restoring-sessions/session-owner-removal'
+import { removeWorkspaceSessionOwnersEverywhere } from '../restoring-sessions/session-owner-removal'
 
 export type ProjectGroupMutationOperations = {
   state: PersistedState
@@ -105,11 +105,11 @@ export class ProjectGroupPersistenceOperations {
     for (const workspace of this.state.folderWorkspaces ?? []) {
       if (deletedGroupIds.has(workspace.projectGroupId)) {
         removedFolderWorkspaceKeys.add(folderWorkspaceKey(workspace.id))
-        // Every partition, not just the local blob: the same reason `removeFolderWorkspace` does.
-        removeWorkspaceSessionOwnerEverywhere(this.state, folderWorkspaceKey(workspace.id))
         this.removeWorkspaceLineageForFolderParent(workspace.id)
       }
     }
+    // Every partition, not just the local blob: the same reason `removeFolderWorkspace` does.
+    removeWorkspaceSessionOwnersEverywhere(this.state, removedFolderWorkspaceKeys)
     this.state.folderWorkspaces = (this.state.folderWorkspaces ?? []).filter(
       (workspace) => !deletedGroupIds.has(workspace.projectGroupId)
     )
diff --git a/src/main/persistence/tracking-repos/project-group-session-batch.test.ts b/src/main/persistence/tracking-repos/project-group-session-batch.test.ts
new file mode 100644
index 000000000000..04fbee3c9dcd
--- /dev/null
+++ b/src/main/persistence/tracking-repos/project-group-session-batch.test.ts
@@ -0,0 +1,163 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { getDefaultPersistedState, getDefaultWorkspaceSession } from '../../../shared/constants'
+import { createProjectGroup } from '../../../shared/project-groups'
+import type { FolderWorkspace } from '../../../shared/folder-workspace-types'
+import type { WorkspaceSessionState } from '../../../shared/workspace-session-state-types'
+import { folderWorkspaceKey } from '../../../shared/workspace-scope'
+import { createMinimalPersistedTerminalTab } from '../restoring-sessions/session-owner-fields'
+import { ProjectGroupPersistenceOperations } from './project-group-operations'
+
+function workspace(id: string, projectGroupId: string): FolderWorkspace {
+  return {
+    id,
+    projectGroupId,
+    name: id,
+    folderPath: '/workspace',
+    linkedTask: null,
+    comment: '',
+    isArchived: false,
+    isUnread: false,
+    isPinned: false,
+    sortOrder: 0,
+    lastActivityAt: 0,
+    createdAt: 0,
+    updatedAt: 0
+  }
+}
+
+function session(owners: string[]): WorkspaceSessionState {
+  const result = getDefaultWorkspaceSession()
+  result.activeWorkspaceKey = folderWorkspaceKey(owners[0])
+  result.activeWorktreeId = folderWorkspaceKey(owners[0])
+  result.activeWorktreeIdsOnShutdown = owners.map(folderWorkspaceKey)
+  result.lastVisitedAtByWorktreeId = {}
+  result.defaultTerminalTabsAppliedByWorktreeId = {}
+  result.terminalPtyIncarnationsByPaneKey = {}
+  result.terminalTopologyRevisionByRepoId = { unrelated: 7 }
+  for (const id of owners) {
+    const owner = folderWorkspaceKey(id)
+    result.tabsByWorktree[owner] = [
+      {
+        ...createMinimalPersistedTerminalTab({
+          worktreeId: owner,
+          tabId: id,
+          ptyId: `pty-${id}`,
+          existingTabCount: 0
+        }),
+        createdAt: 0
+      }
+    ]
+    result.terminalLayoutsByTabId[id] = {
+      root: { type: 'leaf', leafId: `leaf-${id}` },
+      activeLeafId: `leaf-${id}`,
+      expandedLeafId: null,
+      buffersByLeafId: { [`leaf-${id}`]: 'scrollback'.repeat(1024) }
+    }
+    result.lastVisitedAtByWorktreeId[`ssh:builder|${owner}`] = 1
+    result.defaultTerminalTabsAppliedByWorktreeId[owner] = true
+    result.terminalPtyIncarnationsByPaneKey[`${id}:leaf-${id}`] = `incarnation-${id}`
+  }
+  return result
+}
+
+function fixture(folderCount: number) {
+  const state = getDefaultPersistedState('/home/test')
+  state.projectGroups = [
+    { ...createProjectGroup({ name: 'Root', createdFrom: 'manual', tabOrder: 0 }), id: 'root' },
+    {
+      ...createProjectGroup({ name: 'Child', createdFrom: 'manual', tabOrder: 1 }),
+      id: 'child',
+      parentGroupId: 'root'
+    },
+    { ...createProjectGroup({ name: 'Other', createdFrom: 'manual', tabOrder: 2 }), id: 'other' }
+  ]
+  const removedIds = Array.from({ length: folderCount }, (_, index) => `removed-${index}`)
+  state.folderWorkspaces = [
+    ...removedIds.map((id, index) => workspace(id, index % 2 ? 'child' : 'root')),
+    workspace('kept', 'other')
+  ]
+  state.workspaceSession = session([...removedIds, 'kept'])
+  state.workspaceSessionsByHostId = {
+    'ssh:builder': session([...removedIds, 'kept']),
+    'runtime:remote': session([...removedIds, 'kept'])
+  }
+  const scheduleSave = vi.fn()
+  const removeWorkspaceLineageForFolderParent = vi.fn()
+  const selected = new Set([...removedIds, 'kept'].map(folderWorkspaceKey))
+  const pruneMobileClientTabSelections = vi.fn((matches: (owner: string) => boolean) => {
+    for (const owner of selected) {
+      if (matches(owner)) {
+        selected.delete(owner)
+      }
+    }
+  })
+  const operations = new ProjectGroupPersistenceOperations({
+    state,
+    scheduleSave,
+    removeWorkspaceLineageForFolderParent,
+    pruneMobileClientTabSelections
+  })
+  return {
+    state,
+    removedIds,
+    selected,
+    operations,
+    scheduleSave,
+    removeWorkspaceLineageForFolderParent,
+    pruneMobileClientTabSelections
+  }
+}
+
+afterEach(() => vi.restoreAllMocks())
+
+describe('project group session removal', () => {
+  it('copies each host session once when deleting many folder workspaces', () => {
+    const { operations } = fixture(24)
+    const clone = vi.spyOn(globalThis, 'structuredClone')
+    expect(operations.deleteProjectGroup('root')).toBe(true)
+    expect(clone).toHaveBeenCalledTimes(3)
+  })
+
+  it('removes the entire subtree from local spill and remote sessions while preserving other owners', () => {
+    const setup = fixture(8)
+    const kept = session(['kept'])
+    kept.activeWorkspaceKey = null
+    kept.activeWorktreeId = null
+    expect(setup.operations.deleteProjectGroup('root')).toBe(true)
+    expect(setup.state.workspaceSession).toEqual(kept)
+    expect(setup.state.workspaceSessionsByHostId).toEqual({
+      'ssh:builder': kept,
+      'runtime:remote': kept
+    })
+    expect(setup.state.projectGroups?.map((group) => group.id)).toEqual(['other'])
+    expect(setup.state.folderWorkspaces.map((entry) => entry.id)).toEqual(['kept'])
+    expect(setup.selected).toEqual(new Set([folderWorkspaceKey('kept')]))
+    expect(setup.removeWorkspaceLineageForFolderParent.mock.calls).toEqual(
+      setup.removedIds.map((id) => [id])
+    )
+    expect(setup.pruneMobileClientTabSelections).toHaveBeenCalledTimes(1)
+    expect(setup.scheduleSave).toHaveBeenCalledTimes(1)
+  })
+
+  it('preserves session references when the deleted group has no folder workspaces', () => {
+    const { state, operations, scheduleSave } = fixture(0)
+    const local = state.workspaceSession
+    const hosts = state.workspaceSessionsByHostId
+    const clone = vi.spyOn(globalThis, 'structuredClone')
+    expect(operations.deleteProjectGroup('root')).toBe(true)
+    expect(state.workspaceSession).toBe(local)
+    expect(state.workspaceSessionsByHostId).toBe(hosts)
+    expect(clone).not.toHaveBeenCalled()
+    expect(scheduleSave).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not prune or save when the requested group does not exist', () => {
+    const setup = fixture(8)
+    const before = structuredClone(setup.state)
+    expect(setup.operations.deleteProjectGroup('missing')).toBe(false)
+    expect(setup.state).toEqual(before)
+    expect(setup.removeWorkspaceLineageForFolderParent).not.toHaveBeenCalled()
+    expect(setup.pruneMobileClientTabSelections).not.toHaveBeenCalled()
+    expect(setup.scheduleSave).not.toHaveBeenCalled()
+  })
+})

From 10ac42010cabd3b72b54a44997c6db4d72dbdd71 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:50:45 -0700
Subject: [PATCH 06/17] Release completed provider write payloads (#26208)

---
 .../acp/acp-write-queue-retention.test.ts     | 113 ++++++++++++++++++
 .../provider-stdio-write-queue.ts             |   2 +
 2 files changed, 115 insertions(+)
 create mode 100644 src/main/acp/acp-write-queue-retention.test.ts

diff --git a/src/main/acp/acp-write-queue-retention.test.ts b/src/main/acp/acp-write-queue-retention.test.ts
new file mode 100644
index 000000000000..1c9a5931737c
--- /dev/null
+++ b/src/main/acp/acp-write-queue-retention.test.ts
@@ -0,0 +1,113 @@
+import { PassThrough, Writable } from 'node:stream'
+import { expect, it } from 'vitest'
+import { AcpJsonRpcPeer } from './acp-json-rpc-peer'
+
+async function collect(): Promise<void> {
+  if (!('gc' in globalThis) || typeof globalThis.gc !== 'function') {
+    throw new Error('The test runner must enable --expose-gc')
+  }
+  for (let round = 0; round < 6; round++) {
+    await new Promise<void>((resolve) => setImmediate(resolve))
+    globalThis.gc()
+  }
+}
+
+function fixture(deferred: boolean, backpressure: boolean) {
+  const input = new PassThrough()
+  const refs: WeakRef<object>[] = []
+  const writes: string[] = []
+  let callback: ((error?: Error | null) => void) | undefined
+  const output = new Writable({
+    highWaterMark: backpressure ? 1 : 1024 * 1024,
+    write(chunk, _encoding, done) {
+      writes.push(JSON.parse(chunk.toString()).method)
+      if (deferred) {
+        callback = done
+      } else {
+        done()
+      }
+    }
+  })
+  output.on('newListener', (event, listener) => {
+    if (event === 'drain') {
+      refs.push(new WeakRef(listener))
+    }
+  })
+  const peer = new AcpJsonRpcPeer(input, output)
+  return {
+    input,
+    output,
+    refs,
+    peer,
+    writes,
+    complete() {
+      const done = callback
+      callback = undefined
+      if (!done) {
+        throw new Error('Missing pending stream callback')
+      }
+      done()
+    },
+    close() {
+      peer.close()
+      input.destroy()
+      output.destroy()
+    }
+  }
+}
+
+it.each([false, true])(
+  'releases the completed last drain closure while the peer remains usable (backpressure=%s)',
+  async (backpressure) => {
+    const state = fixture(false, backpressure)
+    try {
+      await state.peer.notify('first', { text: 'x'.repeat(256 * 1024) })
+      expect(state.output.writableLength).toBe(0)
+      expect(state.output.listenerCount('drain')).toBe(0)
+      await collect()
+      expect(state.refs.filter((ref) => ref.deref())).toHaveLength(0)
+      await state.peer.notify('next', {})
+      expect(state.writes).toEqual(['first', 'next'])
+    } finally {
+      state.close()
+    }
+  }
+)
+
+it('keeps the active write until stream completion then releases its drain closure', async () => {
+  const state = fixture(true, true)
+  try {
+    const first = state.peer.notify('first', {})
+    const second = state.peer.notify('second', {})
+    await collect()
+    expect(state.refs.filter((ref) => ref.deref())).toHaveLength(1)
+    expect(state.writes).toEqual(['first'])
+    state.complete()
+    await first
+    expect(state.writes).toEqual(['first', 'second'])
+    state.complete()
+    await second
+    await collect()
+    expect(state.refs.filter((ref) => ref.deref())).toHaveLength(0)
+    expect(state.output.listenerCount('drain')).toBe(0)
+  } finally {
+    state.close()
+  }
+})
+
+it('retires a closed peer drain closure after its late stream completion', async () => {
+  const state = fixture(true, true)
+  try {
+    const first = expect(state.peer.notify('first', {})).rejects.toThrow('closed')
+    const second = expect(state.peer.notify('second', {})).rejects.toThrow('closed')
+    state.peer.close()
+    await Promise.all([first, second])
+    state.complete()
+    await collect()
+    expect(state.refs.filter((ref) => ref.deref())).toHaveLength(0)
+    expect(state.output.listenerCount('drain')).toBe(0)
+    expect(state.writes).toEqual(['first'])
+  } finally {
+    state.close()
+  }
+})
diff --git a/src/main/provider-process/provider-stdio-write-queue.ts b/src/main/provider-process/provider-stdio-write-queue.ts
index 378caf1560fd..57a7d92f1910 100644
--- a/src/main/provider-process/provider-stdio-write-queue.ts
+++ b/src/main/provider-process/provider-stdio-write-queue.ts
@@ -65,6 +65,7 @@ export class ProviderStdioWriteQueue {
     }
     this.terminalError = error
     this.detachDrain?.()
+    this.detachDrain = undefined
     this.active?.detachAbort?.()
     this.active?.reject(error)
     this.active = undefined
@@ -96,6 +97,7 @@ export class ProviderStdioWriteQueue {
         return
       }
       this.detachDrain?.()
+      this.detachDrain = undefined
       write.detachAbort?.()
       this.active = undefined
       this.bytes -= Buffer.byteLength(write.line)

From a4854ac1e9696c7fb620f084b1a7ef59adfa9777 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Wed, 7 Oct 2026 23:55:00 -0700
Subject: [PATCH 07/17] perf: skip the OpenCode reader worker when its database
 is absent (#26113)

---
 .../foreign-sqlite-reader-spawn.test.ts       | 90 +++++++++++++++++++
 .../foreign-sqlite-reader-spawn.ts            | 16 +++-
 2 files changed, 105 insertions(+), 1 deletion(-)
 create mode 100644 src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.test.ts

diff --git a/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.test.ts b/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.test.ts
new file mode 100644
index 000000000000..9b1c6fd63b4e
--- /dev/null
+++ b/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.test.ts
@@ -0,0 +1,90 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import * as fsPromises from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('node:fs/promises', { spy: true })
+
+const reads = vi.hoisted(() => ({
+  binder: vi.fn<() => Promise<unknown[]>>(),
+  client: vi.fn()
+}))
+
+vi.mock('./foreign-sqlite-reader-client', () => ({
+  ForeignSqliteReaderClient: class {
+    constructor() {
+      reads.client()
+    }
+
+    readOpenCodeBinderSessions = reads.binder
+  }
+}))
+
+import { readOpenCodeBinderSessions } from './foreign-sqlite-reader-spawn'
+
+const CURSOR = { ms: 0, id: '' }
+let root = ''
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), 'orca-binder-preflight-'))
+  reads.binder.mockReset().mockResolvedValue([])
+  reads.client.mockClear()
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  rmSync(root, { recursive: true, force: true })
+})
+
+describe('OpenCode binder worker admission', () => {
+  it.each(['ENOENT', 'ENOTDIR'])('does not dispatch a worker read for %s', async (code) => {
+    const parent = join(root, 'parent')
+    if (code === 'ENOTDIR') {
+      writeFileSync(parent, '')
+    }
+    const path = join(parent, 'opencode.db')
+
+    expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual([])
+    expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual([])
+    expect(reads.binder).not.toHaveBeenCalled()
+    expect(reads.client).not.toHaveBeenCalled()
+  })
+
+  it('dispatches once the previously absent database appears', async () => {
+    const path = join(root, 'later', 'opencode.db')
+    expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual([])
+    expect(reads.binder).not.toHaveBeenCalled()
+
+    mkdirSync(join(root, 'later'))
+    writeFileSync(path, '')
+    const rows = [{ id: 'session', directory: root, createdAtMs: 1, parentId: null }]
+    reads.binder.mockResolvedValue(rows)
+
+    expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual(rows)
+    expect(reads.binder).toHaveBeenCalledExactlyOnceWith(path, CURSOR)
+  })
+
+  it.each(['EACCES', 'EIO'])(
+    'leaves %s failures to the existing worker error handling',
+    async (code) => {
+      const path = join(root, 'opencode.db')
+      vi.mocked(fsPromises.stat).mockRejectedValueOnce(Object.assign(new Error(code), { code }))
+
+      expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual([])
+      expect(reads.binder).toHaveBeenCalledExactlyOnceWith(path, CURSOR)
+    }
+  )
+
+  it('keeps the worker result authoritative when the database changes after the preflight', async () => {
+    const path = join(root, 'opencode.db')
+    writeFileSync(path, '')
+    reads.binder.mockImplementation(async () => {
+      rmSync(path)
+      return []
+    })
+
+    expect(await readOpenCodeBinderSessions(path, CURSOR)).toEqual([])
+    expect(reads.binder).toHaveBeenCalledExactlyOnceWith(path, CURSOR)
+  })
+})
diff --git a/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.ts b/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.ts
index de4654d1160c..043a317130d8 100644
--- a/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.ts
+++ b/src/main/foreign-sqlite-readers/foreign-sqlite-reader-spawn.ts
@@ -1,4 +1,5 @@
 import { existsSync } from 'node:fs'
+import { stat } from 'node:fs/promises'
 import { Worker } from 'node:worker_threads'
 import { currentWorkerEntryLayout } from '../worker-thread-entry-path'
 import type { CursorDesktopProfileReadResult } from './cursor-profile-result'
@@ -40,9 +41,22 @@ export function readCursorDesktopProfile(dbPath: string): Promise<CursorDesktopP
  * @param cursor - Store position the binder has handled up to.
  * @returns Rows oldest first; `[]` when the store or the worker cannot answer.
  */
-export function readOpenCodeBinderSessions(
+export async function readOpenCodeBinderSessions(
   dbPath: string,
   cursor: OpenCodeSessionCursor
 ): Promise<BinderSessionRow[]> {
+  try {
+    // Missing stores must not keep an otherwise unused reader worker alive on every binder poll.
+    await stat(dbPath)
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      'code' in error &&
+      (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+    ) {
+      return []
+    }
+    // The worker still owns reporting other failures and checking for changes after this probe.
+  }
   return getSharedClient().readOpenCodeBinderSessions(dbPath, cursor)
 }

From 07c23793952704fc830982e440824fac646113e9 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:02:56 -0700
Subject: [PATCH 08/17] Encode checkpoint strings in bounded native JSON chunks
 (#26177)

---
 .../terminal-checkpoint-serializer.test.ts    | 78 ++++++++++++++++---
 .../daemon/terminal-checkpoint-serializer.ts  | 73 ++++-------------
 2 files changed, 82 insertions(+), 69 deletions(-)

diff --git a/src/main/daemon/terminal-checkpoint-serializer.test.ts b/src/main/daemon/terminal-checkpoint-serializer.test.ts
index ca12dd1d9893..1308402ae4d3 100644
--- a/src/main/daemon/terminal-checkpoint-serializer.test.ts
+++ b/src/main/daemon/terminal-checkpoint-serializer.test.ts
@@ -92,29 +92,36 @@ describe('terminal checkpoint serializer', () => {
     expect(Buffer.byteLength(serialized, 'utf8')).toBeLessThanOrEqual(maxBytes)
   })
 
-  it('does not materialize and rescan a passing candidate', async () => {
+  it('keeps native conversion bounded without materializing the whole candidate', async () => {
     let reads = 0
     const input = snapshot()
     Object.defineProperty(input, 'snapshotAnsi', {
       enumerable: true,
       get: () => {
         reads += 1
-        return 'visible'
+        return 'visible'.repeat(20_000)
       }
     })
     const stringify = vi.spyOn(JSON, 'stringify')
     const byteLength = vi.spyOn(Buffer, 'byteLength')
 
     try {
-      await serializeTerminalCheckpointWithinLimit(input, metadata, 20 * 1024)
-
-      expect({
-        fullCandidateStringifies: stringify.mock.calls.filter(
-          ([value]) => typeof value === 'object' && value !== null
-        ).length,
-        byteLengthCalls: byteLength.mock.calls.length,
-        snapshotReads: reads
-      }).toEqual({ fullCandidateStringifies: 0, byteLengthCalls: 0, snapshotReads: 1 })
+      await serializeTerminalCheckpointWithinLimit(input, metadata, 200 * 1024)
+
+      expect(
+        stringify.mock.calls.some(([value]) => typeof value === 'object' && value !== null)
+      ).toBe(false)
+      for (const [value] of stringify.mock.calls) {
+        if (typeof value === 'string') {
+          expect(value.length).toBeLessThanOrEqual(64 * 1024)
+        }
+      }
+      for (const [value] of byteLength.mock.calls) {
+        if (typeof value === 'string') {
+          expect(value.length).toBeLessThanOrEqual(128 * 1024)
+        }
+      }
+      expect(reads).toBe(1)
     } finally {
       stringify.mockRestore()
       byteLength.mockRestore()
@@ -171,4 +178,53 @@ describe('terminal checkpoint serializer', () => {
       stringify.mockRestore()
     }
   })
+  it.each([16 * 1024 - 1, 16 * 1024])(
+    'preserves hardcoded control and surrogate JSON after %i code units',
+    async (prefixLength) => {
+      const prefix = 'x'.repeat(prefixLength)
+      const input = snapshot({
+        snapshotAnsi: `${prefix}😀\ud800x\udc00"\b\t\n\f\r\\\0`
+      })
+      const expectedPrefix =
+        `{"snapshotAnsi":"${prefix}😀\\ud800x\\udc00\\"\\b\\t\\n\\f\\r\\\\\\u0000",` +
+        '"scrollbackAnsi":""'
+      const serialized = await serializeTerminalCheckpointWithinLimit(input, metadata, 40 * 1024)
+      expect(serialized.startsWith(expectedPrefix)).toBe(true)
+      expect(JSON.parse(serialized).snapshotAnsi).toBe(input.snapshotAnsi)
+      const exactBytes = Buffer.byteLength(serialized, 'utf8')
+      await expect(
+        serializeTerminalCheckpointWithinLimit(input, metadata, exactBytes)
+      ).resolves.toBe(serialized)
+      const trimmed = await serializeTerminalCheckpointWithinLimit(input, metadata, exactBytes - 1)
+      expect(Buffer.byteLength(trimmed, 'utf8')).toBeLessThan(exactBytes)
+    }
+  )
+
+  it('rejects huge escaped metadata using bounded native conversions near the byte cap', async () => {
+    const stringify = vi.spyOn(JSON, 'stringify')
+    const byteLength = vi.spyOn(Buffer, 'byteLength')
+    try {
+      await expect(
+        serializeTerminalCheckpointWithinLimit(
+          snapshot(),
+          { ...metadata, cwd: String.fromCharCode(0).repeat(1_000_000) },
+          512
+        )
+      ).rejects.toThrow('Terminal checkpoint metadata exceeds byte limit')
+      for (const [value] of stringify.mock.calls) {
+        expect(typeof value === 'object' && value !== null).toBe(false)
+        if (typeof value === 'string') {
+          expect(value.length).toBeLessThanOrEqual(512)
+        }
+      }
+      for (const [value] of byteLength.mock.calls) {
+        if (typeof value === 'string') {
+          expect(value.length).toBeLessThanOrEqual(512 * 6)
+        }
+      }
+    } finally {
+      stringify.mockRestore()
+      byteLength.mockRestore()
+    }
+  })
 })
diff --git a/src/main/daemon/terminal-checkpoint-serializer.ts b/src/main/daemon/terminal-checkpoint-serializer.ts
index 8a686cf29f87..60ba778ef3ec 100644
--- a/src/main/daemon/terminal-checkpoint-serializer.ts
+++ b/src/main/daemon/terminal-checkpoint-serializer.ts
@@ -1,3 +1,4 @@
+import { clampToSafeSplitIndex } from './daemon-stream-data-split'
 import type { TerminalCheckpointFile, TerminalSnapshot } from './types'
 import { ColdRestoreReplayWriter } from './cold-restore-replay-writer'
 import { HeadlessEmulator } from './headless-emulator'
@@ -60,29 +61,12 @@ class BoundedJsonWriter {
     return true
   }
 
-  result(): string | null {
-    return this.exceeded ? null : this.output + this.chunk
+  remainingBytes(): number {
+    return this.maxBytes - this.bytes
   }
-}
 
-function escapedCodeUnit(codeUnit: number): string | null {
-  switch (codeUnit) {
-    case 0x08:
-      return '\\b'
-    case 0x09:
-      return '\\t'
-    case 0x0a:
-      return '\\n'
-    case 0x0c:
-      return '\\f'
-    case 0x0d:
-      return '\\r'
-    case 0x22:
-      return '\\"'
-    case 0x5c:
-      return '\\\\'
-    default:
-      return codeUnit < 0x20 ? `\\u${codeUnit.toString(16).padStart(4, '0')}` : null
+  result(): string | null {
+    return this.exceeded ? null : this.output + this.chunk
   }
 }
 
@@ -90,44 +74,17 @@ function appendJsonString(writer: BoundedJsonWriter, value: string): boolean {
   if (!writer.append('"', 1)) {
     return false
   }
-  let spanStart = 0
-  let spanBytes = 0
-  for (let index = 0; index < value.length; index += 1) {
-    const codeUnit = value.charCodeAt(index)
-    let escaped = escapedCodeUnit(codeUnit)
-    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
-      const next = value.charCodeAt(index + 1)
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        spanBytes += 4
-        index += 1
-      } else {
-        escaped = `\\u${codeUnit.toString(16)}`
-      }
-    } else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
-      escaped = `\\u${codeUnit.toString(16)}`
-    } else if (escaped === null) {
-      spanBytes += codeUnit < 0x80 ? 1 : codeUnit < 0x800 ? 2 : 3
-    }
-
-    if (escaped !== null) {
-      if (
-        (index > spanStart && !writer.append(value.slice(spanStart, index), spanBytes)) ||
-        !writer.append(escaped, escaped.length)
-      ) {
-        return false
-      }
-      spanStart = index + 1
-      spanBytes = 0
-    } else if (index + 1 - spanStart >= 16 * 1024) {
-      if (!writer.append(value.slice(spanStart, index + 1), spanBytes)) {
-        return false
-      }
-      spanStart = index + 1
-      spanBytes = 0
+  let start = 0
+  while (start < value.length) {
+    // Keep a surrogate pair together even when only one byte remains.
+    const remainingBytes = writer.remainingBytes()
+    const chunkLength = remainingBytes < 16 * 1024 ? Math.max(2, remainingBytes) : 16 * 1024
+    const end = clampToSafeSplitIndex(value, start, Math.min(value.length, start + chunkLength))
+    const json = JSON.stringify(value.slice(start, end)).slice(1, -1)
+    if (!writer.append(json, Buffer.byteLength(json, 'utf8'))) {
+      return false
     }
-  }
-  if (spanStart < value.length && !writer.append(value.slice(spanStart), spanBytes)) {
-    return false
+    start = end
   }
   return writer.append('"', 1)
 }

From 67dbd2fd06848ab583007adbf26ceeeecc1fcb05 Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:21:54 -0700
Subject: [PATCH 09/17] perf: reuse chat tab ownership across unrelated app
 updates (#26150)

---
 .../native-chat/NativeChatResolvedView.tsx    |   7 +-
 .../native-chat/native-chat-file-link.ts      |  34 ++-
 .../native-chat-owner-selectors.test.tsx      | 232 ++++++++++++++++++
 ...native-chat-runtime-owner-selector.test.ts | 122 +++++++++
 .../native-chat/native-chat-runtime-owner.ts  |  13 +-
 .../use-native-chat-file-link-context.ts      |   9 +-
 .../native-chat/use-native-chat-tab-owner.ts  |   6 +-
 7 files changed, 413 insertions(+), 10 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/native-chat-owner-selectors.test.tsx
 create mode 100644 src/renderer/src/components/native-chat/native-chat-runtime-owner-selector.test.ts

diff --git a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
index 83977dee7fe8..2c12d5ec41c1 100644
--- a/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatResolvedView.tsx
@@ -49,7 +49,7 @@ import {
   emptyNativeChatContextMenuActions,
   useNativeChatContextMenu
 } from './use-native-chat-context-menu'
-import { selectNativeChatRuntimeEnvironmentId } from './native-chat-runtime-owner'
+import { createNativeChatRuntimeSelector } from './native-chat-runtime-owner'
 import { useNativeChatPasteBridge } from './use-native-chat-paste-bridge'
 import { LinkActionPopover } from '@/components/link-actions/LinkActionPopover'
 import { useNativeChatLinkActions } from './use-native-chat-link-actions'
@@ -77,9 +77,8 @@ export function NativeChatResolvedView({
 }: NativeChatResolvedViewProps): React.JSX.Element {
   // Primitive owner selection (no useShallow): routes the pane's read/subscribe to
   // the remote runtime host for a runtime-owned pane; null keeps the local path.
-  const runtimeEnvironmentId = useAppStore((s) =>
-    selectNativeChatRuntimeEnvironmentId(s, terminalTabId)
-  )
+  const selectOwner = useMemo(() => createNativeChatRuntimeSelector(terminalTabId), [terminalTabId])
+  const runtimeEnvironmentId = useAppStore(selectOwner)
   const keybindings = useAppStore((s) => s.keybindings)
   const session = useNativeChatRetainedSession({
     paneKey,
diff --git a/src/renderer/src/components/native-chat/native-chat-file-link.ts b/src/renderer/src/components/native-chat/native-chat-file-link.ts
index 043bb9b78c69..e1b4f8c6b0f1 100644
--- a/src/renderer/src/components/native-chat/native-chat-file-link.ts
+++ b/src/renderer/src/components/native-chat/native-chat-file-link.ts
@@ -71,11 +71,43 @@ export function findNativeChatTabOwnerWorktreeId(
   )
 }
 
+export function createNativeChatTabOwnerSelector(tabId: string) {
+  let terminalTabs: NativeChatFileLinkState['tabsByWorktree'] | null = null
+  let unifiedTabs: NativeChatFileLinkState['unifiedTabsByWorktree']
+  let owner: string | null = null
+  return (state: Pick<NativeChatFileLinkState, 'tabsByWorktree' | 'unifiedTabsByWorktree'>) => {
+    // Hidden chats still subscribe; ownership changes only with the immutable tab maps.
+    if (terminalTabs !== state.tabsByWorktree || unifiedTabs !== state.unifiedTabsByWorktree) {
+      owner = findNativeChatTabOwnerWorktreeId(state, tabId)
+      terminalTabs = state.tabsByWorktree
+      unifiedTabs = state.unifiedTabsByWorktree
+    }
+    return owner
+  }
+}
+
 export function resolveNativeChatFileLinkContext(
   state: NativeChatFileLinkState,
   terminalTabId: string
 ): NativeChatFileLinkContext | null {
-  const worktreeId = findNativeChatTabOwnerWorktreeId(state, terminalTabId)
+  return resolveNativeChatFileLinkContextForOwner(
+    state,
+    terminalTabId,
+    findNativeChatTabOwnerWorktreeId(state, terminalTabId)
+  )
+}
+
+export function createNativeChatFileLinkContextSelector(tabId: string) {
+  const selectOwner = createNativeChatTabOwnerSelector(tabId)
+  return (state: NativeChatFileLinkState) =>
+    resolveNativeChatFileLinkContextForOwner(state, tabId, selectOwner(state))
+}
+
+function resolveNativeChatFileLinkContextForOwner(
+  state: NativeChatFileLinkState,
+  terminalTabId: string,
+  worktreeId: string | null
+): NativeChatFileLinkContext | null {
   if (!worktreeId) {
     return null
   }
diff --git a/src/renderer/src/components/native-chat/native-chat-owner-selectors.test.tsx b/src/renderer/src/components/native-chat/native-chat-owner-selectors.test.tsx
new file mode 100644
index 000000000000..2bee35ac5487
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-owner-selectors.test.tsx
@@ -0,0 +1,232 @@
+// @vitest-environment happy-dom
+import { act, cleanup, renderHook } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { FLOATING_TERMINAL_WORKTREE_ID, getDefaultSettings } from '../../../../shared/constants'
+import type { Tab } from '../../../../shared/tab-types'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import {
+  createNativeChatFileLinkContextSelector,
+  createNativeChatTabOwnerSelector,
+  findNativeChatTabOwnerWorktreeId,
+  resolveNativeChatFileLinkContext
+} from './native-chat-file-link'
+import { useNativeChatTabOwnerWorktreeId } from './use-native-chat-tab-owner'
+import { useNativeChatFileLinkContext } from './use-native-chat-file-link-context'
+import { useAppStore } from '@/store'
+
+type ContextState = Parameters<typeof resolveNativeChatFileLinkContext>[0]
+
+vi.mock('@/store', async () => {
+  const { create } = await import('zustand')
+  const { getDefaultSettings } = await import('../../../../shared/constants')
+  return {
+    useAppStore: create<ContextState>(() => ({
+      settings: getDefaultSettings('/home/test'),
+      repos: [],
+      projectGroups: [],
+      folderWorkspaces: [],
+      worktreesByRepo: {},
+      tabsByWorktree: {},
+      unifiedTabsByWorktree: {},
+      getKnownWorktreeById: () => undefined
+    }))
+  }
+})
+
+afterEach(cleanup)
+
+function terminal(id: string): TerminalTab {
+  return {
+    id,
+    ptyId: null,
+    worktreeId: 'terminal-owner',
+    title: 'Terminal',
+    customTitle: null,
+    color: null,
+    sortOrder: 0,
+    createdAt: 0
+  }
+}
+
+function structured(id: string, contentType: Tab['contentType'] = 'agent-session'): Tab {
+  return {
+    id,
+    entityId: `session-${id}`,
+    worktreeId: 'chat-owner',
+    groupId: 'group',
+    contentType,
+    agentSessionAgent: 'codex',
+    label: 'Chat',
+    customLabel: null,
+    color: null,
+    sortOrder: 0,
+    createdAt: 0
+  }
+}
+
+function worktree(id: string, path = '/repo'): Worktree {
+  return {
+    id,
+    repoId: 'repo',
+    path,
+    displayName: id,
+    comment: '',
+    linkedIssue: null,
+    linkedPR: null,
+    linkedLinearIssue: null,
+    isArchived: false,
+    isUnread: false,
+    isPinned: false,
+    sortOrder: 0,
+    lastActivityAt: 0,
+    head: '',
+    branch: 'main',
+    isBare: false,
+    isMainWorktree: false
+  }
+}
+
+function contextState(overrides: Partial<ContextState> = {}): ContextState {
+  return {
+    settings: getDefaultSettings('/home/test'),
+    repos: [],
+    projectGroups: [],
+    folderWorkspaces: [],
+    worktreesByRepo: {},
+    tabsByWorktree: {},
+    unifiedTabsByWorktree: {},
+    getKnownWorktreeById: () => undefined,
+    ...overrides
+  }
+}
+
+describe('native chat ownership selectors', () => {
+  it.each(['chat', 'missing'])('does no ownership scans on unrelated hook updates for %s', (id) => {
+    let reads = 0
+    const counted = <T extends { id: string }>(tab: T): T => {
+      const tabId = tab.id
+      Object.defineProperty(tab, 'id', { enumerable: true, get: () => (reads++, tabId) })
+      return tab
+    }
+    const state = contextState({
+      tabsByWorktree: Object.fromEntries(
+        Array.from({ length: 100 }, (_, index) => [
+          `terminal-owner-${index}`,
+          [counted(terminal(`terminal-${index}`))]
+        ])
+      ),
+      unifiedTabsByWorktree: { 'chat-owner': [counted(structured('chat'))] },
+      getKnownWorktreeById: (owner) => worktree(owner)
+    })
+    useAppStore.setState(state)
+    const { result } = renderHook(() => ({
+      owner: useNativeChatTabOwnerWorktreeId(id),
+      context: useNativeChatFileLinkContext(id)
+    }))
+    expect(result.current.owner).toBe(id === 'chat' ? 'chat-owner' : null)
+    expect(reads).toBeGreaterThan(0)
+    reads = 0
+    act(() => {
+      for (let index = 0; index < 100; index++) {
+        useAppStore.setState({ lastTerminalInputAtByPaneKey: { pane: index } })
+      }
+    })
+    expect(reads).toBe(0)
+    expect(result.current.context?.worktreePath ?? null).toBe(id === 'chat' ? '/repo' : null)
+  })
+
+  it('refreshes both hooks when the queried tab changes, moves, closes, or returns', () => {
+    const state = contextState({
+      unifiedTabsByWorktree: { first: [structured('one')], second: [structured('two')] },
+      getKnownWorktreeById: (owner) => worktree(owner, `/${owner}`)
+    })
+    useAppStore.setState(state)
+    const { result, rerender, unmount } = renderHook(
+      ({ id }) => ({
+        owner: useNativeChatTabOwnerWorktreeId(id),
+        context: useNativeChatFileLinkContext(id)
+      }),
+      { initialProps: { id: 'one' } }
+    )
+    expect(result.current.context?.worktreePath).toBe('/first')
+    rerender({ id: 'two' })
+    expect(result.current.context?.worktreePath).toBe('/second')
+    act(() => useAppStore.setState({ unifiedTabsByWorktree: { first: [structured('two')] } }))
+    expect(result.current.owner).toBe('first')
+    act(() => useAppStore.setState({ unifiedTabsByWorktree: {} }))
+    expect(result.current).toEqual({ owner: null, context: null })
+    act(() => useAppStore.setState({ tabsByWorktree: { returned: [terminal('two')] } }))
+    expect(result.current.context?.worktreePath).toBe('/returned')
+    unmount()
+    const reopened = renderHook(() => useNativeChatTabOwnerWorktreeId('two'))
+    expect(reopened.result.current).toBe('returned')
+  })
+
+  it('keeps first-owner collisions, terminal precedence, and the structured content gate', () => {
+    const select = createNativeChatTabOwnerSelector('same')
+    const states = [
+      contextState({
+        tabsByWorktree: { first: [terminal('same')], second: [terminal('same')] },
+        unifiedTabsByWorktree: { structured: [structured('same')] }
+      }),
+      contextState({
+        unifiedTabsByWorktree: {
+          editor: [structured('same', 'editor')],
+          first: [structured('same')],
+          second: [structured('same')]
+        }
+      }),
+      contextState({ unifiedTabsByWorktree: { editor: [structured('same', 'editor')] } }),
+      contextState()
+    ]
+    expect(states.map((state) => select(state))).toEqual(['first', 'first', null, null])
+    for (const state of states) {
+      expect(select(state)).toBe(findNativeChatTabOwnerWorktreeId(state, 'same'))
+    }
+  })
+
+  it('updates directory and runtime projections without replacing the ownership maps', () => {
+    let path = '/before'
+    const initial = contextState({
+      unifiedTabsByWorktree: { 'chat-owner': [structured('chat')] },
+      getKnownWorktreeById: (owner) => worktree(owner, path),
+      worktreesByRepo: { repo: [worktree('chat-owner')] }
+    })
+    const select = createNativeChatFileLinkContextSelector('chat')
+    expect(select(initial)?.worktreePath).toBe('/before')
+    path = '/after'
+    const current = {
+      ...initial,
+      settings: { ...getDefaultSettings('/home/test'), activeRuntimeEnvironmentId: 'focused' },
+      worktreesByRepo: {
+        repo: [{ ...worktree('chat-owner'), runtimeOwnerEnvironmentId: 'owning-runtime' }]
+      }
+    }
+    expect(select(current)).toEqual(resolveNativeChatFileLinkContext(current, 'chat'))
+    expect(select(current)).toEqual({
+      worktreeId: 'chat-owner',
+      worktreePath: '/after',
+      runtimeEnvironmentId: 'owning-runtime'
+    })
+  })
+
+  it('waits for a floating chat pin and follows pin changes without an ownership change', () => {
+    const initial = contextState({
+      floatingWorkspacePath: '/setting',
+      unifiedTabsByWorktree: { [FLOATING_TERMINAL_WORKTREE_ID]: [structured('chat')] }
+    })
+    const select = createNativeChatFileLinkContextSelector('chat')
+    expect(select(initial)).toBeNull()
+    for (const launchDirectory of ['/pinned', '/updated']) {
+      const current = {
+        ...initial,
+        structuredSessionLaunchDirectoryByTabId: {
+          chat: { sessionId: 'session-chat', launchDirectory }
+        }
+      }
+      expect(select(current)?.worktreePath).toBe(launchDirectory)
+      expect(select(current)).toEqual(resolveNativeChatFileLinkContext(current, 'chat'))
+    }
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-owner-selector.test.ts b/src/renderer/src/components/native-chat/native-chat-runtime-owner-selector.test.ts
new file mode 100644
index 000000000000..8e476421bba0
--- /dev/null
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-owner-selector.test.ts
@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import {
+  createNativeChatRuntimeSelector,
+  selectNativeChatRuntimeEnvironmentId,
+  type NativeChatRuntimeOwnerState
+} from './native-chat-runtime-owner'
+
+function tab(id: string): TerminalTab {
+  return {
+    id,
+    ptyId: null,
+    worktreeId: 'owner',
+    title: id,
+    customTitle: null,
+    color: null,
+    sortOrder: 0,
+    createdAt: 0
+  }
+}
+
+function state(): NativeChatRuntimeOwnerState {
+  return {
+    tabsByWorktree: { owner: [tab('target')] },
+    worktreesByRepo: { repo: [{ id: 'owner', repoId: 'repo', hostId: 'runtime:first' }] }
+  }
+}
+
+describe('createNativeChatRuntimeSelector', () => {
+  it('does not inspect terminal rows during unrelated publications and keeps runtime routing fresh', () => {
+    const initial = state()
+    const target = initial.tabsByWorktree.owner?.[0]
+    if (!target) {
+      throw new Error('Expected the target tab fixture')
+    }
+    let reads = 0
+    Object.defineProperty(target, 'id', {
+      get: () => {
+        reads++
+        return 'target'
+      }
+    })
+    const select = createNativeChatRuntimeSelector('target')
+    expect(select(initial)).toBe('first')
+    expect(reads).toBe(1)
+    for (let i = 0; i < 100; i++) {
+      const next: NativeChatRuntimeOwnerState = {
+        ...initial,
+        worktreesByRepo: { repo: [{ id: 'owner', repoId: 'repo', hostId: `runtime:next-${i}` }] }
+      }
+      expect(select(next)).toBe(`next-${i}`)
+    }
+    expect(reads).toBe(1)
+    expect(select({ ...initial, tabsByWorktree: { ...initial.tabsByWorktree } })).toBe('first')
+    expect(reads).toBe(2)
+  })
+
+  it('preserves first terminal owner, move, close, and independent tab identities', () => {
+    const initial = state()
+    const withCollision: NativeChatRuntimeOwnerState = {
+      ...initial,
+      tabsByWorktree: { ...initial.tabsByWorktree, later: [tab('target'), tab('second')] },
+      worktreesByRepo: {
+        repo: [
+          ...(initial.worktreesByRepo?.repo ?? []),
+          { id: 'later', repoId: 'repo', hostId: 'runtime:later' }
+        ]
+      }
+    }
+    const select = createNativeChatRuntimeSelector('target')
+    const selectSecond = createNativeChatRuntimeSelector('second')
+    for (const next of [
+      initial,
+      withCollision,
+      { ...withCollision, tabsByWorktree: { later: [tab('target'), tab('second')] } },
+      { ...withCollision, tabsByWorktree: {} }
+    ]) {
+      expect(select(next)).toBe(selectNativeChatRuntimeEnvironmentId(next, 'target'))
+      expect(selectSecond(next)).toBe(selectNativeChatRuntimeEnvironmentId(next, 'second'))
+    }
+  })
+
+  it('ignores structured-only tabs and refreshes active, detected, folder, and repo host projections', () => {
+    const select = createNativeChatRuntimeSelector('target')
+    const initial = state()
+    const missing = {
+      ...initial,
+      tabsByWorktree: {},
+      unifiedTabsByWorktree: { owner: [{ id: 'target', contentType: 'agent-session' }] }
+    }
+    expect(select(missing)).toBeNull()
+    const projections: NativeChatRuntimeOwnerState[] = [
+      initial,
+      {
+        ...initial,
+        activeWorktreeId: 'owner',
+        activeWorkspaceExecutionHostId: 'runtime:active' as const
+      },
+      {
+        ...initial,
+        detectedWorktreesByRepo: {
+          repo: { worktrees: [{ id: 'owner', repoId: 'repo', hostId: 'runtime:detected' }] }
+        }
+      },
+      {
+        ...initial,
+        worktreesByRepo: { repo: [{ id: 'owner', repoId: 'repo' }] },
+        repos: [{ id: 'repo', executionHostId: 'ssh:remote' as const }]
+      },
+      {
+        ...initial,
+        tabsByWorktree: { 'folder:scope': [tab('target')] },
+        folderWorkspaces: [
+          { id: 'scope', projectGroupId: 'group', executionHostId: 'runtime:folder' as const }
+        ]
+      }
+    ]
+    for (const next of projections) {
+      expect(select(next)).toBe(selectNativeChatRuntimeEnvironmentId(next, 'target'))
+    }
+  })
+})
diff --git a/src/renderer/src/components/native-chat/native-chat-runtime-owner.ts b/src/renderer/src/components/native-chat/native-chat-runtime-owner.ts
index 02aaae1a6f3a..a85739ae36c2 100644
--- a/src/renderer/src/components/native-chat/native-chat-runtime-owner.ts
+++ b/src/renderer/src/components/native-chat/native-chat-runtime-owner.ts
@@ -3,7 +3,10 @@ import {
   type WorktreeRuntimeOwnerState
 } from '@/lib/worktree-runtime-owner'
 import type { AppState } from '@/store/types'
-import { findTerminalTabWorktreeId } from './native-chat-file-link'
+import {
+  createNativeChatTabOwnerSelector,
+  findTerminalTabWorktreeId
+} from './native-chat-file-link'
 
 export type NativeChatRuntimeOwnerState = Pick<AppState, 'tabsByWorktree'> &
   WorktreeRuntimeOwnerState
@@ -28,3 +31,11 @@ export function selectNativeChatRuntimeEnvironmentId(
   const worktreeId = findTerminalTabWorktreeId(state.tabsByWorktree, terminalTabId)
   return worktreeId ? getRuntimeEnvironmentIdForWorktree(state, worktreeId) : null
 }
+
+export function createNativeChatRuntimeSelector(terminalTabId: string) {
+  const selectOwner = createNativeChatTabOwnerSelector(terminalTabId)
+  return (state: NativeChatRuntimeOwnerState): string | null => {
+    const worktreeId = selectOwner({ tabsByWorktree: state.tabsByWorktree })
+    return worktreeId ? getRuntimeEnvironmentIdForWorktree(state, worktreeId) : null
+  }
+}
diff --git a/src/renderer/src/components/native-chat/use-native-chat-file-link-context.ts b/src/renderer/src/components/native-chat/use-native-chat-file-link-context.ts
index d3073115b5a8..51ae6382794d 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-file-link-context.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-file-link-context.ts
@@ -1,7 +1,12 @@
+import { useMemo } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 import { useAppStore } from '../../store'
-import { resolveNativeChatFileLinkContext } from './native-chat-file-link'
+import { createNativeChatFileLinkContextSelector } from './native-chat-file-link'
 
 export function useNativeChatFileLinkContext(terminalTabId: string) {
-  return useAppStore(useShallow((state) => resolveNativeChatFileLinkContext(state, terminalTabId)))
+  const selectContext = useMemo(
+    () => createNativeChatFileLinkContextSelector(terminalTabId),
+    [terminalTabId]
+  )
+  return useAppStore(useShallow(selectContext))
 }
diff --git a/src/renderer/src/components/native-chat/use-native-chat-tab-owner.ts b/src/renderer/src/components/native-chat/use-native-chat-tab-owner.ts
index 8ec04deac071..1539547a36ce 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-tab-owner.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-tab-owner.ts
@@ -1,7 +1,9 @@
+import { useMemo } from 'react'
 import { useAppStore } from '@/store'
-import { findNativeChatTabOwnerWorktreeId } from './native-chat-file-link'
+import { createNativeChatTabOwnerSelector } from './native-chat-file-link'
 
 /** Owning workspace of a chat tab; launch identity must not wait on its directory resolving. */
 export function useNativeChatTabOwnerWorktreeId(tabId: string): string | null {
-  return useAppStore((state) => findNativeChatTabOwnerWorktreeId(state, tabId))
+  const selectOwner = useMemo(() => createNativeChatTabOwnerSelector(tabId), [tabId])
+  return useAppStore(selectOwner)
 }

From 0eee1cebac0ae44341be655ffaa65bd501f982dd Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:22:54 -0700
Subject: [PATCH 10/17] Remove repeated row copying from terminal redraw
 ingestion (#26118)

---
 .../runtime/terminal-tail-redraw-buffer.ts    | 41 +++++++++----
 .../terminal-tail-redraw-spans.test.ts        | 60 +++++++++++++++++++
 .../terminal-tail-row-retention.test.ts       | 17 +++++-
 3 files changed, 106 insertions(+), 12 deletions(-)
 create mode 100644 src/main/runtime/terminal-tail-redraw-spans.test.ts

diff --git a/src/main/runtime/terminal-tail-redraw-buffer.ts b/src/main/runtime/terminal-tail-redraw-buffer.ts
index d8971f7ea8be..2dd6d72badd4 100644
--- a/src/main/runtime/terminal-tail-redraw-buffer.ts
+++ b/src/main/runtime/terminal-tail-redraw-buffer.ts
@@ -73,7 +73,7 @@ export function appendNormalizedToMultilineTailBufferUnwindowed(
     ensureCursorRow()
     rows[cursorRow]!.completed = false
   }
-  const writeChar = (char: string): void => {
+  const writeText = (text: string): void => {
     ensureCursorRow()
     markCursorRowRewritten()
     const row = rows[cursorRow]!
@@ -82,9 +82,9 @@ export function appendNormalizedToMultilineTailBufferUnwindowed(
     }
     row.text =
       cursorColumn >= row.text.length
-        ? `${row.text}${char}`
-        : `${row.text.slice(0, cursorColumn)}${char}${row.text.slice(cursorColumn + 1)}`
-    cursorColumn += 1
+        ? `${row.text}${text}`
+        : `${row.text.slice(0, cursorColumn)}${text}${row.text.slice(cursorColumn + text.length)}`
+    cursorColumn += text.length
   }
   const eraseLine = (mode: number): void => {
     ensureCursorRow()
@@ -100,13 +100,28 @@ export function appendNormalizedToMultilineTailBufferUnwindowed(
     }
   }
 
+  let textStart = 0
+  const writePendingText = (end: number): void => {
+    if (end > textStart) {
+      writeText(
+        end === textStart + 1 ? normalizedChunk[textStart]! : normalizedChunk.slice(textStart, end)
+      )
+    }
+    textStart = end + 1
+  }
   for (let index = 0; index < normalizedChunk.length; index += 1) {
     const char = normalizedChunk[index]
     if (char === '\n') {
+      writePendingText(index)
       ensureCursorRow()
       rows[cursorRow]!.completed = true
       newCompleteLines += 1
-      retainNewlyCompletedLine(trimTerminalLineRight(rows[cursorRow]!.text))
+      // Own only retained text; a short erase-to-end result can otherwise pin a large span.
+      const row = rows[cursorRow]!
+      const trimmed = trimTerminalLineRight(row.text)
+      const completedLine = ownRetainedString(trimmed)
+      row.text = trimmed === row.text ? completedLine : ownRetainedString(row.text)
+      retainNewlyCompletedLine(completedLine)
       cursorRow += 1
       cursorColumn = 0
       ensureCursorRow()
@@ -114,19 +129,23 @@ export function appendNormalizedToMultilineTailBufferUnwindowed(
       continue
     }
     if (char === '\r') {
+      writePendingText(index)
       cursorColumn = 0
       continue
     }
     if (char === '\u0008') {
+      writePendingText(index)
       cursorColumn = Math.max(0, cursorColumn - 1)
       continue
     }
     if (char === '\u001b') {
+      writePendingText(index)
       const parsed = parseAnsiControlSequence(normalizedChunk, index)
       if (!parsed) {
         continue
       }
       index = parsed.endIndex
+      textStart = index + 1
       if (parsed.kind !== 'csi' || !hasCanonicalNumericCsiParams(parsed.params)) {
         continue
       }
@@ -145,8 +164,8 @@ export function appendNormalizedToMultilineTailBufferUnwindowed(
       }
       continue
     }
-    writeChar(char)
   }
+  writePendingText(normalizedChunk.length)
 
   return finalizeRetainedTerminalRows(
     rows,
@@ -186,7 +205,10 @@ function finalizeRetainedTerminalRows(
   newlyCompletedLines: string[]
 } {
   let truncated = initialTruncated
-  let retainedRows = rows.map((row) => ({ ...row, text: trimTerminalLineRight(row.text) }))
+  let retainedRows = rows.map((row) => {
+    const trimmed = trimTerminalLineRight(row.text)
+    return { ...row, text: trimmed === row.text ? row.text : ownRetainedString(trimmed) }
+  })
 
   if (retainedRows.length > MAX_TAIL_LINES + 1) {
     const removeCount = retainedRows.length - (MAX_TAIL_LINES + 1)
@@ -242,10 +264,7 @@ function finalizeRetainedTerminalRows(
 
   return {
     lines,
-    // Why only the partial: redraw rows are built character by character and never sliced from
-    // the chunk, but the partial is re-sliced from its own row on every chunk, so it alone can
-    // accumulate a backing string across frames. Owning the rows too costs 20-36% on TUI floods
-    // for no measured retention.
+    // Completed rows own their storage at newline; the final partial may still reference a span.
     partialLine: ownRetainedString(partialLine),
     redrawCursor,
     truncated,
diff --git a/src/main/runtime/terminal-tail-redraw-spans.test.ts b/src/main/runtime/terminal-tail-redraw-spans.test.ts
new file mode 100644
index 000000000000..d68ca1ad0302
--- /dev/null
+++ b/src/main/runtime/terminal-tail-redraw-spans.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from 'vitest'
+import { appendNormalizedToTailBuffer } from './terminal-tail-buffer'
+
+describe('retained terminal redraw text spans', () => {
+  it('overwrites a long row without copying its suffix for every code unit', () => {
+    const previous = 'p'.repeat(16 * 1024)
+    const replacement = 'x'.repeat(previous.length)
+    const slice = vi.spyOn(String.prototype, 'slice')
+    let copiedSuffixes = 0
+    try {
+      const result = appendNormalizedToTailBuffer([previous], '', `\x1b[1A\r${replacement}\n`)
+      copiedSuffixes = slice.mock.calls.length
+      expect(result.lines).toEqual([replacement])
+      expect(result.newlyCompletedLines).toEqual([replacement])
+      expect(result.redrawCursor).toBeNull()
+    } finally {
+      slice.mockRestore()
+    }
+    expect(copiedSuffixes).toBeLessThan(20)
+  })
+
+  it.each([
+    ['shorter overwrite', '\x1b[1A\rXY\n', 'XYcdef'],
+    ['extending overwrite', '\x1b[1A\r123456789\n', '123456789'],
+    ['erase to end', '\x1b[1A\rXY\x1b[KZ\n', 'XYZ'],
+    ['erase to start', '\x1b[1A\rXY\x1b[2C!\x1b[1KZ\n', '     Z'],
+    ['erase whole line', '\x1b[1A\rXY\x1b[2KZ\n', '  Z'],
+    ['backspace', '\x1b[1A\rXY\bZ\n', 'XZcdef'],
+    ['carriage return', '\x1b[1A\rXY\rZ\n', 'ZYcdef'],
+    ['split surrogate overwrite', '\x1b[1A\r😀\bZ\n', '\ud83dZcdef'],
+    [
+      'Unicode and non-special controls',
+      '\x1b[1A\r漢😀e\u0301\ud800\t\u0000\udfff\bZ\n',
+      '漢😀e\u0301\ud800\t\u0000Z'
+    ]
+  ])('preserves %s', (_name, chunk, expected) => {
+    const result = appendNormalizedToTailBuffer(['abcdef'], '', chunk)
+    expect(result).toEqual({
+      lines: [expected],
+      partialLine: '',
+      redrawCursor: null,
+      truncated: false,
+      newCompleteLines: 1,
+      newlyCompletedLines: [expected]
+    })
+  })
+
+  it('fills a cursor gap before a text span and retains its code-unit column', () => {
+    const result = appendNormalizedToTailBuffer(['abcdef'], '', '\x1b[1A\x1b[9G😀')
+    expect(result.lines).toEqual([])
+    expect(result.partialLine).toBe('abcdef  😀')
+    expect(result.redrawCursor).toBeNull()
+  })
+
+  it('keeps completed trailing spaces available to a later cursor-up rewrite', () => {
+    const result = appendNormalizedToTailBuffer(['abcdef'], '', '\x1b[1A\rab   \n\x1b[1A\x1b[5GX\n')
+    expect(result.lines).toEqual(['ab  Xf'])
+    expect(result.newlyCompletedLines).toEqual(['ab   f', 'ab  Xf'])
+  })
+})
diff --git a/src/main/runtime/terminal-tail-row-retention.test.ts b/src/main/runtime/terminal-tail-row-retention.test.ts
index 0e4effbf9688..e49fd7fdd0ca 100644
--- a/src/main/runtime/terminal-tail-row-retention.test.ts
+++ b/src/main/runtime/terminal-tail-row-retention.test.ts
@@ -79,6 +79,21 @@ describe('retained terminal tail row storage', () => {
     }
   })
 
+  it('does not pin overwritten multiline redraw chunks through completed rows', () => {
+    let lines: string[] = []
+    const before = collectHeap()
+    for (let index = 0; index < 200; index += 1) {
+      const chunk = `\x1b[0A${'x'.repeat(64 * 1024)}\rstep ${index} done\x1b[K\n`
+      const next = appendNormalizedToTailBuffer(lines, '', chunk)
+      lines = next.lines
+    }
+    const retained = collectHeap() - before
+
+    expect(lines).toHaveLength(200)
+    expect(lines.at(-1)).toBe('step 199 done')
+    expect(retained).toBeLessThan(4 * 1024 * 1024)
+  })
+
   it('owns the redraw partial line without re-owning carried rows', () => {
     const own = vi.spyOn(ownership, 'ownRetainedString')
     try {
@@ -93,7 +108,7 @@ describe('retained terminal tail row storage', () => {
 
       expect(redrawn.lines).toEqual(['row one'])
       expect(redrawn.partialLine).toBe('rewritten two')
-      // One call for the partial only: redraw rows are built character by character.
+      // Only the final partial is retained; carried rows need no copies.
       expect(own).toHaveBeenCalledTimes(1)
       expect(own).toHaveBeenLastCalledWith('rewritten two')
     } finally {

From 952898b8b95cf56228eca4055a4647123b27f73f Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:38:27 -0700
Subject: [PATCH 11/17] Add always force delete dropdown to workspace recovery
 dialog (#26476)

---
 .../sidebar/DeleteWorktreeDialog.tsx          |  31 +++--
 .../DeleteWorktreeDialogFooter.test.tsx       | 111 ++++++++++++++++++
 .../sidebar/DeleteWorktreeDialogFooter.tsx    |  24 +++-
 .../sidebar/WorktreeForceDeleteButton.tsx     |  37 ++++--
 4 files changed, 174 insertions(+), 29 deletions(-)
 create mode 100644 src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.test.tsx

diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
index f8f7731e3cb8..35e3ccc0085a 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialog.tsx
@@ -154,6 +154,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
   const allowSkipConfirm =
     !isBatchDelete && modalData.allowSkipConfirm !== false && childWorkspaceCount === 0
   const [dontAskAgain, setDontAskAgain] = useState(false)
+  const [isSavingForcePreference, setIsSavingForcePreference] = useState(false)
   const deleteTargets = useMemo(
     () => (canDeleteAllLineage ? lineageDelete.deleteAllTargets : worktrees),
     [canDeleteAllLineage, lineageDelete.deleteAllTargets, worktrees]
@@ -218,7 +219,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
 
   const handleOpenChange = useCallback(
     (open: boolean) => {
-      if (open) {
+      if (open || isSavingForcePreference) {
         return
       }
       const state = useAppStore.getState().deleteStateByWorktreeId
@@ -237,7 +238,14 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
       }
       closeModal()
     },
-    [clearWorktreeDeleteState, closeModal, deleteStateTargets, isBatchDelete, worktreeId]
+    [
+      clearWorktreeDeleteState,
+      closeModal,
+      deleteStateTargets,
+      isBatchDelete,
+      isSavingForcePreference,
+      worktreeId
+    ]
   )
 
   const persistDontAskAgainPreference = useCallback((): void => {
@@ -249,9 +257,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
   }, [openSettingsPage, openSettingsTarget, updateSettings])
 
   const handleForceDeletedFromToast = useCallback(
-    (deletedTarget: WorktreeRemovalTarget): void => {
-      onDeleted?.([deletedTarget])
-    },
+    (deletedTarget: WorktreeRemovalTarget): void => onDeleted?.([deletedTarget]),
     [onDeleted]
   )
 
@@ -313,7 +319,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
     ]
   )
 
-  const handleDeleteAll = useCallback(() => {
+  const handleDeleteAll = (): void => {
     runLineageDeleteAll({
       deleteAllTargetCount: lineageDelete.deleteAllTargets.length,
       lineageDeleteIdentities,
@@ -323,15 +329,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
       closeModal,
       onDeleted
     })
-  }, [
-    closeModal,
-    handleForceDeletedFromToast,
-    forceOnConfirm,
-    lineageDelete.deleteAllTargets.length,
-    lineageDeleteIdentities,
-    onDeleted,
-    resolveConfirmedTargets
-  ])
+  }
 
   return (
     <Dialog open={isOpen} onOpenChange={handleOpenChange}>
@@ -414,7 +412,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
         <DialogFooter>
           <DeleteWorktreeDialogFooter
             isMainWorktree={isMainWorktree}
-            isDeleting={isDeleting}
+            isDeleting={isDeleting || isSavingForcePreference}
             canForceDelete={canForceDelete}
             isBatchDelete={isBatchDelete}
             worktreeCount={worktrees.length}
@@ -422,6 +420,7 @@ const DeleteWorktreeDialog = React.memo(function DeleteWorktreeDialog() {
             lineageDeleteTargetCount={lineageDelete.deleteAllTargets.length}
             onCancel={() => handleOpenChange(false)}
             onForceDelete={() => handleDelete(true)}
+            onSavingChange={setIsSavingForcePreference}
             onDelete={canDeleteAllLineage ? handleDeleteAll : () => handleDelete(false)}
             confirmButtonRef={confirmButtonRef}
           />
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.test.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.test.tsx
new file mode 100644
index 000000000000..f805bca5c478
--- /dev/null
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.test.tsx
@@ -0,0 +1,111 @@
+// @vitest-environment happy-dom
+
+import { act, createRef } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, expect, it, vi } from 'vitest'
+import { toast } from 'sonner'
+import { TooltipProvider } from '../ui/tooltip'
+import { DeleteWorktreeDialogFooter } from './DeleteWorktreeDialogFooter'
+
+const savePreference = vi.hoisted(() => vi.fn())
+vi.mock('@/store', () => ({
+  useAppStore: { getState: () => ({ updateSettingsOrThrow: savePreference }) }
+}))
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), dismiss: vi.fn() } }))
+let root: Root | undefined
+
+function renderFooter(disabled = false) {
+  const container = document.createElement('div')
+  document.body.appendChild(container)
+  root = createRoot(container)
+  const onForceDelete = vi.fn()
+  const onSavingChange = vi.fn()
+  const confirmButtonRef = createRef<HTMLButtonElement>()
+  act(() =>
+    root?.render(
+      <TooltipProvider delayDuration={0}>
+        <DeleteWorktreeDialogFooter
+          isMainWorktree={false}
+          isDeleting={disabled}
+          canForceDelete
+          isBatchDelete={false}
+          worktreeCount={1}
+          canDeleteAllLineage={false}
+          lineageDeleteTargetCount={1}
+          onCancel={vi.fn()}
+          onDelete={vi.fn()}
+          onForceDelete={onForceDelete}
+          onSavingChange={onSavingChange}
+          confirmButtonRef={confirmButtonRef}
+        />
+      </TooltipProvider>
+    )
+  )
+  return { container, onForceDelete, onSavingChange, confirmButtonRef }
+}
+
+async function selectPreference(container: HTMLElement) {
+  await act(async () => {
+    container
+      .querySelector('button[aria-label="More force delete options"]')
+      ?.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
+  })
+  const item = document.querySelector('[role="menuitem"]')
+  if (!(item instanceof HTMLElement)) {
+    throw new Error('Missing preference option')
+  }
+  await act(async () => item.click())
+}
+
+afterEach(() => {
+  act(() => root?.unmount())
+  root = undefined
+  document.body.innerHTML = ''
+  vi.clearAllMocks()
+})
+
+it('keeps the primary button focused, full size, and a one-time delete', async () => {
+  const { confirmButtonRef, onForceDelete } = renderFooter()
+  expect(confirmButtonRef.current?.dataset.size).toBe('default')
+  expect(confirmButtonRef.current?.textContent).toBe('Force Delete')
+  await act(async () => confirmButtonRef.current?.click())
+  expect(onForceDelete).toHaveBeenCalledOnce()
+  expect(savePreference).not.toHaveBeenCalled()
+  expect(toast.dismiss).not.toHaveBeenCalled()
+})
+
+it('saves the shared preference before retrying and exposes the pending state', async () => {
+  let finish: (() => void) | undefined
+  savePreference.mockImplementation(
+    () =>
+      new Promise<void>((resolve) => {
+        finish = resolve
+      })
+  )
+  const { container, onForceDelete, onSavingChange } = renderFooter()
+  await selectPreference(container)
+  expect(savePreference).toHaveBeenCalledWith({ alwaysForceDeleteWorktrees: true })
+  expect(onForceDelete).not.toHaveBeenCalled()
+  expect(onSavingChange).toHaveBeenLastCalledWith(true)
+  expect(container.querySelectorAll('button:disabled')).toHaveLength(2)
+  await act(async () => finish?.())
+  expect(onSavingChange).toHaveBeenLastCalledWith(false)
+  expect(onForceDelete).toHaveBeenCalledOnce()
+})
+
+it('leaves the recovery action available when saving fails', async () => {
+  savePreference.mockRejectedValue(new Error('Disk full'))
+  const { container, onForceDelete, onSavingChange } = renderFooter()
+  await selectPreference(container)
+  expect(onForceDelete).not.toHaveBeenCalled()
+  expect(onSavingChange).toHaveBeenLastCalledWith(false)
+  expect(container.querySelectorAll('button:disabled')).toHaveLength(0)
+  expect(toast.error).toHaveBeenCalledWith('Could not save deletion preference', {
+    description: 'Disk full'
+  })
+})
+
+it('disables both retry choices while deletion is in progress', () => {
+  const { container } = renderFooter(true)
+  expect(container.querySelectorAll('button:disabled')).toHaveLength(3)
+})
diff --git a/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.tsx b/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.tsx
index e77787f23ee5..dce8257956d1 100644
--- a/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.tsx
+++ b/src/renderer/src/components/sidebar/DeleteWorktreeDialogFooter.tsx
@@ -2,6 +2,8 @@ import type { JSX, Ref } from 'react'
 import { LoaderCircle, Trash2 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { translate } from '@/i18n/i18n'
+import { useAppStore } from '@/store'
+import { WorktreeForceDeleteButton } from './WorktreeForceDeleteButton'
 
 export function DeleteWorktreeDialogFooter({
   isMainWorktree,
@@ -13,6 +15,7 @@ export function DeleteWorktreeDialogFooter({
   lineageDeleteTargetCount,
   onCancel,
   onForceDelete,
+  onSavingChange,
   onDelete,
   confirmButtonRef
 }: {
@@ -25,6 +28,7 @@ export function DeleteWorktreeDialogFooter({
   lineageDeleteTargetCount: number
   onCancel: () => void
   onForceDelete: () => void
+  onSavingChange: (saving: boolean) => void
   onDelete: () => void
   confirmButtonRef: Ref<HTMLButtonElement>
 }): JSX.Element {
@@ -47,17 +51,31 @@ export function DeleteWorktreeDialogFooter({
           ? translate('auto.components.sidebar.DeleteWorktreeDialogFooter.cf95e3b5bb', 'Close')
           : translate('auto.components.sidebar.DeleteWorktreeDialogFooter.c0e972d726', 'Cancel')}
       </Button>
-      {!isMainWorktree && (
+      {!isMainWorktree && canForceDelete ? (
+        <WorktreeForceDeleteButton
+          buttonRef={confirmButtonRef}
+          size="default"
+          disabled={isDeleting}
+          onForceDelete={onForceDelete}
+          onSavingChange={onSavingChange}
+          onAlwaysForceDelete={() =>
+            useAppStore.getState().updateSettingsOrThrow({ alwaysForceDeleteWorktrees: true })
+          }
+        >
+          {isDeleting ? <LoaderCircle className="size-4 animate-spin" /> : <Trash2 />}
+          {label}
+        </WorktreeForceDeleteButton>
+      ) : !isMainWorktree ? (
         <Button
           ref={confirmButtonRef}
           variant="destructive"
-          onClick={canForceDelete ? onForceDelete : onDelete}
+          onClick={onDelete}
           disabled={isDeleting}
         >
           {isDeleting ? <LoaderCircle className="size-4 animate-spin" /> : <Trash2 />}
           {label}
         </Button>
-      )}
+      ) : null}
     </>
   )
 }
diff --git a/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx b/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
index 259176381ee9..2c7e28f06705 100644
--- a/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeForceDeleteButton.tsx
@@ -1,4 +1,4 @@
-import { useState } from 'react'
+import { useState, type ReactNode, type Ref } from 'react'
 import { ChevronDown } from 'lucide-react'
 import { toast } from 'sonner'
 import { translate } from '@/i18n/i18n'
@@ -15,15 +15,27 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/tooltip'
 export function WorktreeForceDeleteButton({
   toastId,
   onForceDelete,
-  onAlwaysForceDelete
+  onAlwaysForceDelete,
+  onSavingChange,
+  size = 'sm',
+  disabled = false,
+  buttonRef,
+  children
 }: {
-  toastId: string
+  toastId?: string
   onForceDelete: () => void
   onAlwaysForceDelete?: () => Promise<void>
+  onSavingChange?: (saving: boolean) => void
+  size?: 'sm' | 'default'
+  disabled?: boolean
+  buttonRef?: Ref<HTMLButtonElement>
+  children?: ReactNode
 }): React.JSX.Element {
   const [isSaving, setIsSaving] = useState(false)
   const forceDelete = (): void => {
-    toast.dismiss(toastId)
+    if (toastId) {
+      toast.dismiss(toastId)
+    }
     onForceDelete()
   }
   const alwaysForceDelete = async (): Promise<void> => {
@@ -31,15 +43,18 @@ export function WorktreeForceDeleteButton({
       return
     }
     setIsSaving(true)
+    onSavingChange?.(true)
     try {
       await onAlwaysForceDelete()
     } catch (error) {
-      setIsSaving(false)
       toast.error(
         translate('workspaceDeletion.preferenceSaveFailed', 'Could not save deletion preference'),
         { description: error instanceof Error ? error.message : String(error) }
       )
       return
+    } finally {
+      setIsSaving(false)
+      onSavingChange?.(false)
     }
     forceDelete()
   }
@@ -57,21 +72,23 @@ export function WorktreeForceDeleteButton({
         }}
       >
         <Button
+          ref={buttonRef}
           type="button"
           variant="destructive"
-          size="sm"
-          disabled={isSaving}
+          size={size}
+          disabled={disabled || isSaving}
           onClick={forceDelete}
         >
-          {translate('auto.components.sidebar.delete.worktree.flow.2b20ce87b3', 'Force Delete')}
+          {children ??
+            translate('auto.components.sidebar.delete.worktree.flow.2b20ce87b3', 'Force Delete')}
         </Button>
         {onAlwaysForceDelete ? (
           <DropdownMenuTrigger asChild>
             <Button
               type="button"
               variant="destructive"
-              size="icon-sm"
-              disabled={isSaving}
+              size={size === 'sm' ? 'icon-sm' : 'icon'}
+              disabled={disabled || isSaving}
               aria-label={translate('workspaceDeletion.moreActions', 'More force delete options')}
             >
               <ChevronDown className="size-3.5" />

From a53967fc055ea96346a14413bce36c52a22a8c19 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Thu, 8 Oct 2026 00:48:05 -0700
Subject: [PATCH 12/17] Native chat: add an inline visuals switch and simplify
 the skill (#26358)

* Native chat: let users turn off inline visuals for new chats

* Native chat: keep inline visuals guidance light

* Move inline visuals setting to Chat settings
---
 .../skills/orca-chat-visuals/SKILL.md         |  65 +++-----
 .../claude/claude-structured-launch-flags.ts  |  21 ++-
 ...native-chat-inline-visuals-setting.test.ts | 154 ++++++++++++++++++
 .../native-chat-visuals-delivery.test.ts      |  36 +++-
 .../native-chat-visuals-delivery.ts           |   4 +
 .../runtime/orca-runtime-get-worktree-ps.ts   |   1 +
 src/main/runtime/runtime-store-contract.ts    |   1 +
 .../structured-agent-runtime-registrations.ts |   3 +-
 .../structured-agent-session-runtime.ts       |   2 +
 .../NativeChatMarkdown.visual.test.tsx        |  18 ++
 ...hatSettingsSection.inline-visuals.test.tsx |  96 +++++++++++
 .../ChatSettingsSection.navigation.test.tsx   |  24 ++-
 .../settings/ChatSettingsSection.test.tsx     |  17 +-
 .../settings/ChatSettingsSection.tsx          |  13 +-
 .../NativeChatExperimentalSetting.test.tsx    |  12 ++
 .../NativeChatInlineVisualsSetting.tsx        |  44 +++++
 .../settings/chat-inline-visuals-search.ts    |  12 ++
 ...ive-chat-experimental-search-entry.test.ts |   7 +
 .../settings-navigation-interface-sections.ts |   7 +-
 src/renderer/src/i18n/locales/en.json         |   5 +-
 src/shared/default-global-settings.ts         |   1 +
 src/shared/global-settings-types.ts           |   2 +
 22 files changed, 473 insertions(+), 72 deletions(-)
 create mode 100644 src/main/native-chat/native-chat-inline-visuals-setting.test.ts
 create mode 100644 src/renderer/src/components/settings/ChatSettingsSection.inline-visuals.test.tsx
 create mode 100644 src/renderer/src/components/settings/NativeChatInlineVisualsSetting.tsx
 create mode 100644 src/renderer/src/components/settings/chat-inline-visuals-search.ts

diff --git a/resources/native-chat-visuals/skills/orca-chat-visuals/SKILL.md b/resources/native-chat-visuals/skills/orca-chat-visuals/SKILL.md
index 2276e92d4e3f..dc63d3c8d206 100644
--- a/resources/native-chat-visuals/skills/orca-chat-visuals/SKILL.md
+++ b/resources/native-chat-visuals/skills/orca-chat-visuals/SKILL.md
@@ -1,58 +1,33 @@
 ---
 name: orca-chat-visuals
-description: Show a chart, diagram, timeline, comparison or UI mockup inline in this Orca chat by writing one self-contained HTML file and adding a visual line to your reply. Use when seeing something would explain the answer faster than prose or a small Markdown table, and only when the ORCA_CHAT_VISUALS_DIR environment variable is set.
+description: Show a chart, diagram, table, report or mockup inline in this Orca chat as an HTML
+  page. Use when a visual would help the user understand your answer. Only available when the
+  ORCA_CHAT_VISUALS_DIR environment variable is set.
 user-invocable: false
 ---
 
 # Inline visuals in an Orca chat
 
-Orca can render an HTML page inside your reply. Reach for it when the reader gains from seeing the
-answer: trends, many values side by side, flows, architecture, layouts. Answers that read fine as
-text, a short list or a small table don't need one.
-
-## When you can't make one
-
-- This chat's folder is the absolute path in the `ORCA_CHAT_VISUALS_DIR` environment variable. Read
-  it from your shell (`printenv ORCA_CHAT_VISUALS_DIR`; in PowerShell `$env:ORCA_CHAT_VISUALS_DIR`).
-- If the variable is unset or empty, or writing there fails, don't make a visual.
-- Stay inside what the user allowed. In plan or read-only mode don't make a visual. If a write
-  there is refused, don't retry it; never switch modes or ask for wider access for a visual.
-- Never put visuals in the user's project and never edit `.gitignore` or other files for them.
-
-Without a visual, use a Markdown table, a Mermaid code block or plain prose instead.
-
-## Writing the file
-
-- One visual is one complete HTML document saved directly in that folder (no subfolders).
-- Every visual gets a file name not used before in this chat: a few lowercase words and a short
-  random suffix, like `latency-by-region-7c1e.html`. Never overwrite or edit an earlier visual;
-  write a new file. Allowed: letters, digits, `.`, `_` and `-`; starts with a letter or digit;
-  ends in `.html`; at most 128 characters; no `..`; not a Windows device name like `con` or `nul`.
-- Put everything in the file: inline `<style>` and `<script>`, data embedded. Keep it under 512 KB.
-- Scripts, styles and fonts may load only from `https://cdn.jsdelivr.net`, `https://unpkg.com`,
-  `https://cdnjs.cloudflare.com`, `https://esm.sh`, `https://fonts.googleapis.com` and
-  `https://fonts.gstatic.com`. Pin library versions.
-- The page can't make requests: no `fetch`, `XMLHttpRequest`, `WebSocket` or `EventSource`.
-  Images must be inline SVG or `data:` URLs. No forms, popups, nested frames or navigation.
-- Fit the width you're given (fluid layout, `max-width: 100%`). Don't size anything to the viewport
-  height (`100vh`, `height: 100%` on the page): Orca sizes the frame to your content. Aim for well
-  under 1000px tall.
-- Match the user's theme with Orca's CSS variables: `--background`, `--foreground`, `--muted`,
-  `--muted-foreground`, `--border`, `--primary`, `--accent`, and `--chart-1` to `--chart-5` for data
-  series. Leave the page background transparent. When the user switches theme the values change
-  and `<html>` gains or loses the `dark` class, with no reload and no event: use the variables from
-  CSS or SVG, and redraw a canvas chart when that class changes (a `MutationObserver` on `<html>`).
-- Use real text for labels and give the page a heading so it reads without color alone.
+Orca can show an HTML page inside your reply. Use one whenever a visual would make the answer
+clearer.
+
+## Writing the page
+
+- Save it in the folder named by `ORCA_CHAT_VISUALS_DIR` (`printenv ORCA_CHAT_VISUALS_DIR`; in
+  PowerShell `$env:ORCA_CHAT_VISUALS_DIR`). If it's unset or you can't write there, skip the visual.
+- One complete HTML file per visual, directly in that folder, under 512 KB, with a new file name
+  each time (e.g. `latency-by-region-7c1e.html`): letters, digits, `.`, `_`, `-`, ending in `.html`.
+- Inline your styles, scripts and data. Libraries and fonts may load only from cdn.jsdelivr.net,
+  unpkg.com, cdnjs.cloudflare.com, esm.sh, fonts.googleapis.com and fonts.gstatic.com. The page
+  can't make network requests; use inline SVG or `data:` URLs for images.
+- Don't size anything to the viewport height (`100vh`); Orca fits the frame to your content.
+- Optional: Orca's theme colors are available as CSS variables (`--background`, `--foreground`,
+  `--muted-foreground`, `--border`, `--primary`, `--chart-1` to `--chart-5`).
 
 ## Showing it
 
-Only after the file exists, add this line to your reply on its own line, at the top level (not in
-a code block, list, table or quote):
+After the file exists, put this on its own line in your reply, outside any code block:
 
 ::orca-visual{file="latency-by-region-7c1e.html" title="Latency by region"}
 
-- `file` is the bare file name, never a path. `title` is optional plain text, at most 120
-  characters, without `"` or `\`.
-- At most 8 visuals in one reply.
-- Don't announce the visual or walk through it point by point. Do state the takeaway in a sentence,
-  so the reply still makes sense where the visual can't be shown.
+`file` is the bare file name, never a path; `title` is optional. At most 8 per reply.
diff --git a/src/main/claude/claude-structured-launch-flags.ts b/src/main/claude/claude-structured-launch-flags.ts
index b3c2cefae136..32ccef04dff3 100644
--- a/src/main/claude/claude-structured-launch-flags.ts
+++ b/src/main/claude/claude-structured-launch-flags.ts
@@ -39,21 +39,24 @@ export async function resolveClaudeLaunchFlags(
     deps.cliFlags?.supports(CLAUDE_THINKING_DISPLAY_FLAG, launch, budgetMs, startProbe) ?? false
   // Unlike the thinking display, a missed answer costs the chat its skill for its whole life, so
   // the plugin check waits for the probe up to its own kill time: bounded, and instant once known.
+  const preparedVisuals = deps.prepareVisuals?.(sessionId) ?? Promise.resolve(null)
   const [thinksFirst, visuals, loadsPlugins] = await Promise.all([
     thinking(),
-    deps.prepareVisuals?.(sessionId) ?? null,
-    deps.prepareVisuals
-      ? (deps.cliFlags?.supports(
-          CLAUDE_PLUGIN_DIR_FLAG,
-          launch,
-          CLAUDE_CLI_FLAG_PROBE_KILL_AFTER_MS
-        ) ?? false)
-      : false
+    preparedVisuals,
+    preparedVisuals.then((visuals) =>
+      visuals
+        ? (deps.cliFlags?.supports(
+            CLAUDE_PLUGIN_DIR_FLAG,
+            launch,
+            CLAUDE_CLI_FLAG_PROBE_KILL_AFTER_MS
+          ) ?? false)
+        : false
+    )
   ])
   // The plugin check may have outwaited the thinking budget and learned the version meanwhile; a
   // probe that gave none is not asked again here.
   const thinks =
-    thinksFirst || (deps.prepareVisuals ? await thinking(THINKING_RECHECK_BUDGET_MS, false) : false)
+    thinksFirst || (visuals ? await thinking(THINKING_RECHECK_BUDGET_MS, false) : false)
   return {
     thinkingDisplayArgs: thinks ? THINKING_DISPLAY_ARGS : {},
     visuals: visuals ? { visuals, pluginDir: loadsPlugins ? visuals.skill.pluginDir : null } : null
diff --git a/src/main/native-chat/native-chat-inline-visuals-setting.test.ts b/src/main/native-chat/native-chat-inline-visuals-setting.test.ts
new file mode 100644
index 000000000000..d778f98c247b
--- /dev/null
+++ b/src/main/native-chat/native-chat-inline-visuals-setting.test.ts
@@ -0,0 +1,154 @@
+import { existsSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { LOCAL_EXECUTION_HOST_ID } from '../../shared/execution-host'
+import { createClaudeStructuredLaunchResolver } from '../claude/claude-structured-launch-resolution'
+import { CLAUDE_PLUGIN_DIR_FLAG, type ClaudeCliFlag } from '../claude/claude-cli-flag-support'
+import { createCodexStructuredLaunchResolver } from '../codex/codex-structured-launch-resolution'
+import {
+  adapterFor,
+  fakeCodex,
+  identityFor
+} from '../codex/codex-structured-session-adapter-fixture'
+import { agentSessionRecordFixture } from './agent-session-record-test-fixture'
+import {
+  createNativeChatVisualsDelivery,
+  NATIVE_CHAT_VISUALS_DIR_ENV
+} from './native-chat-visuals-delivery'
+import { nativeChatVisualsFolderFor } from './native-chat-visuals-folder'
+
+const SKILL = { pluginDir: '/app/plugin', skillsRoot: '/app/plugin/skills' }
+const MANUAL = { approvalPolicy: 'on-request', sandbox: 'workspace-write' } as const
+const scratch: string[] = []
+afterEach(() => {
+  for (const dir of scratch.splice(0)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+function delivery(isEnabled: () => boolean) {
+  const stateDirectory = mkdtempSync(join(tmpdir(), 'orca-visuals-setting-'))
+  scratch.push(stateDirectory)
+  const prepareVisuals = createNativeChatVisualsDelivery({
+    stateDirectory,
+    logger: { warn: vi.fn(), error: vi.fn() },
+    isEnabled,
+    resolveSkill: async () => SKILL
+  })
+  return { stateDirectory, prepareVisuals }
+}
+
+describe('inline visuals launch preference', () => {
+  it('starts Claude without visuals while preserving configured plugins, user folders and attachment access', async () => {
+    const sessionId = 'claude-disabled'
+    const { stateDirectory, prepareVisuals } = delivery(() => false)
+    const supports = vi.fn(async (_flag: ClaudeCliFlag) => true)
+    const record = agentSessionRecordFixture({ sessionId })
+    const launch = await createClaudeStructuredLaunchResolver({
+      store: { getRecord: () => record, pinLaunchDirectory: vi.fn() },
+      resolveWorkspacePath: async () => '/repo',
+      resolveCommand: () => '/bin/claude',
+      resolveAuthPolicy: () => ({ stripAuthEnv: false }),
+      resolveLaunchArgs: () => ['--add-dir', '/user/notes', '--plugin-dir', '/user/plugin'],
+      resolveEnv: () => ({ [NATIVE_CHAT_VISUALS_DIR_ENV]: '/inherited', KEEP: 'yes' }),
+      resolveInheritedEnv: async () => ({ PATH: '/bin' }),
+      attachmentDirectory: '/state/agent-session-attachments',
+      hasTranscript: async () => false,
+      cliFlags: { supports },
+      prepareVisuals
+    })({ identity: { ...identityFor(sessionId), agent: 'claude', providerHandle: null } })
+    expect(launch.options).not.toHaveProperty('plugins')
+    expect(launch.options.extraArgs).toHaveProperty('plugin-dir', '/user/plugin')
+    expect(launch.options.additionalDirectories).toEqual([
+      '/user/notes',
+      '/state/agent-session-attachments'
+    ])
+    expect(launch.env).not.toHaveProperty(NATIVE_CHAT_VISUALS_DIR_ENV)
+    expect(launch.env?.KEEP).toBe('yes')
+    expect(supports.mock.calls.map(([flag]) => flag)).not.toContain(CLAUDE_PLUGIN_DIR_FLAG)
+    expect(existsSync(nativeChatVisualsFolderFor(stateDirectory, sessionId))).toBe(false)
+  })
+
+  it('gives new Codex chats the current preference without changing another live chat', async () => {
+    let enabled = true
+    const { stateDirectory, prepareVisuals } = delivery(() => enabled)
+    const codex = fakeCodex({
+      'config/read': () => ({
+        config: { sandbox_workspace_write: { writable_roots: ['/user/notes'] } }
+      })
+    })
+    const resolveLaunch = createCodexStructuredLaunchResolver({
+      store: {
+        getRecord: (sessionId) =>
+          agentSessionRecordFixture({
+            sessionId,
+            provider: 'codex',
+            accountHome: { variable: 'CODEX_HOME', path: '/home/codex' }
+          }),
+        pinLaunchDirectory: vi.fn()
+      },
+      resolveWorkspacePath: async () => '/repo',
+      resolveCommand: () => '/bin/codex',
+      resolveLaunchArgs: () => [],
+      resolvePermissionPolicy: () => MANUAL,
+      resolveEnvironment: async () => ({
+        [NATIVE_CHAT_VISUALS_DIR_ENV]: '/inherited',
+        KEEP: 'yes'
+      }),
+      prepareVisuals
+    })
+    const adapter = adapterFor(codex, {}, [], { resolveLaunch })
+    const start = (sessionId: string) =>
+      adapter.acquire({
+        identity: {
+          ...identityFor(sessionId),
+          hostId: LOCAL_EXECUTION_HOST_ID,
+          providerHandle: null
+        },
+        fence: 1,
+        spawnToken: sessionId
+      })
+    try {
+      await start('first')
+      const first = codex.connections[0]!
+      const firstCalls = [...first.calls]
+      const firstFolder = nativeChatVisualsFolderFor(stateDirectory, 'first')
+      expect(first.launch.env?.[NATIVE_CHAT_VISUALS_DIR_ENV]).toBe(firstFolder)
+      expect(first.calls.find(({ method }) => method === 'thread/start')?.params).toMatchObject({
+        config: { 'sandbox_workspace_write.writable_roots': ['/user/notes', firstFolder] }
+      })
+
+      enabled = false
+      await start('disabled')
+      const disabled = codex.connections[1]!
+      expect(disabled.launch.env).not.toHaveProperty(NATIVE_CHAT_VISUALS_DIR_ENV)
+      expect(disabled.launch.env?.KEEP).toBe('yes')
+      expect(disabled.calls.map(({ method }) => method)).not.toContain('skills/extraRoots/set')
+      const openIndex = disabled.calls.findIndex(({ method }) => method === 'thread/start')
+      expect(disabled.calls.slice(0, openIndex).map(({ method }) => method)).not.toContain(
+        'config/read'
+      )
+      expect(
+        disabled.calls.find(({ method }) => method === 'thread/start')?.params
+      ).not.toHaveProperty('config')
+      expect(existsSync(nativeChatVisualsFolderFor(stateDirectory, 'disabled'))).toBe(false)
+      expect(first.closed).toBe(false)
+      expect(first.calls).toEqual(firstCalls)
+
+      enabled = true
+      await start('reenabled')
+      const reenabled = codex.connections[2]!
+      expect(
+        reenabled.calls.find(({ method }) => method === 'skills/extraRoots/set')?.params
+      ).toEqual({ extraRoots: [SKILL.skillsRoot] })
+      expect(reenabled.launch.env?.[NATIVE_CHAT_VISUALS_DIR_ENV]).toBe(
+        nativeChatVisualsFolderFor(stateDirectory, 'reenabled')
+      )
+      expect(first.closed).toBe(false)
+      expect(first.calls).toEqual(firstCalls)
+    } finally {
+      await adapter.closeAll()
+    }
+  })
+})
diff --git a/src/main/native-chat/native-chat-visuals-delivery.test.ts b/src/main/native-chat/native-chat-visuals-delivery.test.ts
index c383eabde5a1..72faec6dfdbf 100644
--- a/src/main/native-chat/native-chat-visuals-delivery.test.ts
+++ b/src/main/native-chat/native-chat-visuals-delivery.test.ts
@@ -1,12 +1,10 @@
-import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
-  NATIVE_CHAT_VISUAL_FILE_MAX_LENGTH,
   NATIVE_CHAT_VISUAL_MAX_BYTES,
   NATIVE_CHAT_VISUAL_MAX_PER_MESSAGE,
-  NATIVE_CHAT_VISUAL_TITLE_MAX_LENGTH,
   parseNativeChatVisualDirectiveLine
 } from '../../shared/native-chat-visual-directive'
 import { NATIVE_CHAT_VISUAL_THEME_TOKENS } from '../../shared/native-chat-visual-shell'
@@ -16,7 +14,7 @@ import {
   NATIVE_CHAT_VISUALS_DIR_ENV,
   withNativeChatVisualsEnv
 } from './native-chat-visuals-delivery'
-import { nativeChatVisualsFolderFor } from './native-chat-visuals-folder'
+import { nativeChatVisualsFolderFor, nativeChatVisualsRootFor } from './native-chat-visuals-folder'
 import { buildClaudeChildProcessEnv } from '../claude/claude-child-process-environment'
 import { codexStructuredChildEnvironment } from '../codex/codex-structured-child-environment'
 import { resolveProviderChildEnv } from '../provider-process/provider-process-launch'
@@ -50,6 +48,32 @@ function tempDir(): string {
 const logger = () => ({ warn: vi.fn(), error: vi.fn() })
 
 describe('preparing a chat for visuals', () => {
+  it('reads the preference for each launch and prepares nothing while it is off', async () => {
+    const state = tempDir()
+    let enabled = false
+    const resolveSkill = vi.fn(async () => SKILL)
+    const prepare = createNativeChatVisualsDelivery({
+      stateDirectory: state,
+      logger: logger(),
+      isEnabled: () => enabled,
+      resolveSkill
+    })
+    await expect(prepare('disabled-chat')).resolves.toBeNull()
+    expect(resolveSkill).not.toHaveBeenCalled()
+    expect(existsSync(nativeChatVisualsRootFor(state))).toBe(false)
+    enabled = true
+    const launched = await prepare('enabled-chat')
+    expect(launched).toEqual({
+      folder: nativeChatVisualsFolderFor(state, 'enabled-chat'),
+      skill: SKILL
+    })
+    enabled = false
+    await expect(prepare('next-chat')).resolves.toBeNull()
+    expect(resolveSkill).toHaveBeenCalledOnce()
+    expect(existsSync(nativeChatVisualsFolderFor(state, 'next-chat'))).toBe(false)
+    expect(existsSync(launched!.folder)).toBe(true)
+  })
+
   it("creates the chat's own private folder and hands back the skill", async () => {
     const state = tempDir()
     const prepare = createNativeChatVisualsDelivery({
@@ -159,9 +183,7 @@ describe('the bundled skill', () => {
       file: 'latency-by-region-7c1e.html',
       title: 'Latency by region'
     })
-    expect(SKILL_TEXT).toContain(`At most ${NATIVE_CHAT_VISUAL_MAX_PER_MESSAGE} visuals`)
-    expect(SKILL_TEXT).toContain(`at most ${NATIVE_CHAT_VISUAL_FILE_MAX_LENGTH} characters`)
-    expect(SKILL_TEXT).toContain(`at most ${NATIVE_CHAT_VISUAL_TITLE_MAX_LENGTH}`)
+    expect(SKILL_TEXT).toContain(`At most ${NATIVE_CHAT_VISUAL_MAX_PER_MESSAGE} per reply`)
     expect(SKILL_TEXT).toContain(`under ${NATIVE_CHAT_VISUAL_MAX_BYTES / 1024} KB`)
     expect(SKILL_TEXT).toContain(NATIVE_CHAT_VISUALS_DIR_ENV)
     expect(SKILL_TEXT).toMatch(new RegExp(`^name: ${NATIVE_CHAT_VISUALS_SKILL_NAME}$`, 'm'))
diff --git a/src/main/native-chat/native-chat-visuals-delivery.ts b/src/main/native-chat/native-chat-visuals-delivery.ts
index a1500e179a08..662dce2b567c 100644
--- a/src/main/native-chat/native-chat-visuals-delivery.ts
+++ b/src/main/native-chat/native-chat-visuals-delivery.ts
@@ -28,11 +28,15 @@ export type PrepareNativeChatVisuals = (
 export function createNativeChatVisualsDelivery(deps: {
   stateDirectory: string
   logger: StructuredAgentSessionLogger
+  isEnabled?: () => boolean
   resolveSkill?: () => Promise<NativeChatVisualsSkillLocation | null>
 }): PrepareNativeChatVisuals {
   const resolveSkill = deps.resolveSkill ?? (() => resolveNativeChatVisualsSkillLocation())
   return async (sessionId) => {
     try {
+      if (deps.isEnabled?.() === false) {
+        return null
+      }
       const skill = await resolveSkill()
       if (!skill) {
         deps.logger.warn('native-chat visuals skill is missing from this install', {
diff --git a/src/main/runtime/orca-runtime-get-worktree-ps.ts b/src/main/runtime/orca-runtime-get-worktree-ps.ts
index b73d018c211f..8ac017498e68 100644
--- a/src/main/runtime/orca-runtime-get-worktree-ps.ts
+++ b/src/main/runtime/orca-runtime-get-worktree-ps.ts
@@ -229,6 +229,7 @@ export class OrcaRuntimeWithGetWorktreePs extends OrcaRuntimeWithStartTuiIdleVis
       // Wired only here, so a test runtime never runs a real `claude --version`.
       claudeCliFlags: claudeCliFlagSupport,
       nativeChatVisuals: {
+        isEnabled: () => this.requireStore().getSettings().nativeChatInlineVisuals !== false,
         // Chats and their visuals are shared by every profile; each profile keeps its own catalog.
         workspaceVerdicts: createNativeChatVisualsWorkspaceVerdicts(() =>
           this.store ? readNativeChatVisualsWorkspaceCatalogs(this.store) : null
diff --git a/src/main/runtime/runtime-store-contract.ts b/src/main/runtime/runtime-store-contract.ts
index a3787e7f3020..24940d7f2dbb 100644
--- a/src/main/runtime/runtime-store-contract.ts
+++ b/src/main/runtime/runtime-store-contract.ts
@@ -130,6 +130,7 @@ export type RuntimeStore = {
     hostSettingOverrides?: GlobalSettings['hostSettingOverrides']
     agentSkillSharingEnabled?: GlobalSettings['agentSkillSharingEnabled']
     nativeChatSessionOptions?: GlobalSettings['nativeChatSessionOptions']
+    nativeChatInlineVisuals?: GlobalSettings['nativeChatInlineVisuals']
     nativeChatInheritShellEnvironment?: GlobalSettings['nativeChatInheritShellEnvironment']
     nativeChatShellEnvironmentVariables?: GlobalSettings['nativeChatShellEnvironmentVariables']
     aiVaultSearch?: GlobalSettings['aiVaultSearch']
diff --git a/src/main/runtime/structured-agent-runtime-registrations.ts b/src/main/runtime/structured-agent-runtime-registrations.ts
index 2787ee62245a..060a87153530 100644
--- a/src/main/runtime/structured-agent-runtime-registrations.ts
+++ b/src/main/runtime/structured-agent-runtime-registrations.ts
@@ -116,7 +116,8 @@ function nativeChatVisualsFor(deps: StructuredAgentSessionRuntimeDeps): {
     ? {
         prepareVisuals: createNativeChatVisualsDelivery({
           stateDirectory: deps.stateDirectory,
-          logger: deps.logger
+          logger: deps.logger,
+          isEnabled: deps.nativeChatVisuals.isEnabled
         })
       }
     : {}
diff --git a/src/main/runtime/structured-agent-session-runtime.ts b/src/main/runtime/structured-agent-session-runtime.ts
index 9c28b4b8ad24..59bab3526748 100644
--- a/src/main/runtime/structured-agent-session-runtime.ts
+++ b/src/main/runtime/structured-agent-session-runtime.ts
@@ -106,6 +106,8 @@ export type StructuredAgentSessionRuntimeDeps = {
   /** Gives each chat a visuals folder and the skill that teaches it, and sweeps folders whose chat
    *  is gone. Wired by the real hosts only, so a test runtime never loads the bundled skill. */
   nativeChatVisuals?: {
+    /** Read this host's preference when a chat starts a provider process. */
+    isEnabled: () => boolean
     workspaceVerdicts: NonNullable<NativeChatVisualsSweepDeps['workspaceVerdicts']>
   }
   /** Provider transports are overridden only to drive the runtime against scripted children. */
diff --git a/src/renderer/src/components/native-chat/NativeChatMarkdown.visual.test.tsx b/src/renderer/src/components/native-chat/NativeChatMarkdown.visual.test.tsx
index 98a08e57436e..c0414b00e7e8 100644
--- a/src/renderer/src/components/native-chat/NativeChatMarkdown.visual.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatMarkdown.visual.test.tsx
@@ -19,6 +19,8 @@ import {
 } from './native-chat-visual-owner'
 import { clearNativeChatVisualCacheForTests } from './native-chat-visual-read-client'
 import { TooltipProvider } from '@/components/ui/tooltip'
+import { useAppStore } from '@/store'
+import { getDefaultSettings } from '../../../../shared/constants'
 
 const owner: NativeChatVisualOwner = {
   target: { kind: 'local' },
@@ -61,6 +63,22 @@ afterEach(() => {
 })
 
 describe('NativeChatMarkdown visuals', () => {
+  it('still renders an existing reply after inline visuals are turned off', async () => {
+    const settings = useAppStore.getState().settings
+    useAppStore.setState({
+      settings: { ...getDefaultSettings('/tmp'), nativeChatInlineVisuals: false }
+    })
+    try {
+      const { container } = render(
+        withOwner(<NativeChatMarkdown content={LINE} visualMessageId="m1" />)
+      )
+      await waitFor(() => expect(container.querySelector('iframe')).not.toBeNull())
+      expect(container).not.toHaveTextContent('::orca-visual')
+    } finally {
+      useAppStore.setState({ settings })
+    }
+  })
+
   it('holds back an unfinished directive at the end of a streaming reply', () => {
     const { container } = render(
       withOwner(
diff --git a/src/renderer/src/components/settings/ChatSettingsSection.inline-visuals.test.tsx b/src/renderer/src/components/settings/ChatSettingsSection.inline-visuals.test.tsx
new file mode 100644
index 000000000000..b7853aa2f250
--- /dev/null
+++ b/src/renderer/src/components/settings/ChatSettingsSection.inline-visuals.test.tsx
@@ -0,0 +1,96 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { getDefaultSettings } from '../../../../shared/constants'
+import type { GlobalSettings } from '../../../../shared/global-settings-types'
+import { ChatSettingsSection } from './ChatSettingsSection'
+import { ActiveSettingsSectionProvider } from './SettingsSection'
+import { getChatInlineVisualsSearchEntry } from './chat-inline-visuals-search'
+import { matchesSettingsSearch } from './settings-search'
+import { getSettingsScrollTarget } from './settings-navigation-foundations'
+import { buildSettingsNavigationMetadata } from '@/hooks/useSettingsNavigationMetadata'
+import { buildCmdJSettingsResults } from '../cmd-j/palette-results'
+
+const state = vi.hoisted((): { settingsSearchQuery: string; settings: GlobalSettings | null } => ({
+  settingsSearchQuery: '',
+  settings: null
+}))
+vi.mock('../../store', () => ({
+  useAppStore: Object.assign((selector: (value: typeof state) => unknown) => selector(state), {
+    getState: () => state
+  })
+}))
+afterEach(cleanup)
+beforeEach(() => {
+  state.settingsSearchQuery = ''
+  state.settings = null
+})
+
+function renderChat(nativeChatInlineVisuals: boolean | undefined) {
+  const settings = {
+    ...getDefaultSettings('/tmp'),
+    experimentalStructuredNativeChat: true,
+    nativeChatInlineVisuals
+  }
+  state.settings = settings
+  const updateSettings = vi.fn()
+  return {
+    ...render(
+      <ActiveSettingsSectionProvider value="chat">
+        <ChatSettingsSection
+          settings={settings}
+          updateSettings={updateSettings}
+          writeSourceControlAiSettings={async () => {}}
+          searchEntries={[getChatInlineVisualsSearchEntry()]}
+          showDesktopOnlySettings
+          isMounted
+        />
+      </ActiveSettingsSectionProvider>
+    ),
+    updateSettings
+  }
+}
+
+describe('Inline visuals on the Chat settings page', () => {
+  it.each([true, undefined])('defaults on for saved preference %s and turns off', (preference) => {
+    expect(getDefaultSettings('/tmp').nativeChatInlineVisuals).toBe(true)
+    const { updateSettings } = renderChat(preference)
+    const toggle = screen.getByRole('switch', { name: 'Toggle inline visuals' })
+    expect(toggle.getAttribute('aria-checked')).toBe('true')
+    fireEvent.click(toggle)
+    expect(updateSettings).toHaveBeenCalledWith({ nativeChatInlineVisuals: false })
+  })
+
+  it('uses saved off and turns on', () => {
+    const { updateSettings } = renderChat(false)
+    expect(screen.getByText(/Applies to newly started chats/)).toBeTruthy()
+    const toggle = screen.getByRole('switch', { name: 'Toggle inline visuals' })
+    expect(toggle.getAttribute('aria-checked')).toBe('false')
+    fireEvent.click(toggle)
+    expect(updateSettings).toHaveBeenCalledWith({ nativeChatInlineVisuals: true })
+  })
+
+  it.each(['inline visuals', 'charts', 'mockups'])(
+    'finds %s and resolves its own Chat target',
+    (query) => {
+      state.settingsSearchQuery = query
+      const { container } = renderChat(true)
+      const toggle = screen.getByRole('switch', { name: 'Toggle inline visuals' })
+      expect(screen.queryByRole('spinbutton', { name: 'Text size' })).toBeNull()
+      const sections = buildSettingsNavigationMetadata({
+        isMac: false,
+        isWindows: false,
+        isWebClient: false,
+        experimentalStructuredNativeChat: true,
+        repos: []
+      })
+      const results = buildCmdJSettingsResults(sections)
+      expect(matchesSettingsSearch(query, getChatInlineVisualsSearchEntry())).toBe(true)
+      const result = results.find((entry) => entry.title === 'Inline visuals')
+      expect(result?.sectionId).toBe('chat')
+      expect(result?.targetSectionId).toBe('chat-inline-visuals')
+      expect(getSettingsScrollTarget('chat-inline-visuals', container)?.contains(toggle)).toBe(true)
+      expect(results.filter((entry) => entry.title === 'Inline visuals')).toHaveLength(1)
+    }
+  )
+})
diff --git a/src/renderer/src/components/settings/ChatSettingsSection.navigation.test.tsx b/src/renderer/src/components/settings/ChatSettingsSection.navigation.test.tsx
index 6ad47215df5c..4a065f0881ba 100644
--- a/src/renderer/src/components/settings/ChatSettingsSection.navigation.test.tsx
+++ b/src/renderer/src/components/settings/ChatSettingsSection.navigation.test.tsx
@@ -8,6 +8,7 @@ import { ChatSettingsSection } from './ChatSettingsSection'
 import { ActiveSettingsSectionProvider } from './SettingsSection'
 import { getChatAppearanceSearchEntries } from './chat-appearance-search'
 import { getChatNamingSearchEntry } from './chat-naming-search'
+import { getChatInlineVisualsSearchEntry } from './chat-inline-visuals-search'
 import { useSettingsRepoScrollEffects } from './use-settings-repo-scroll-effects'
 import type { SettingsStoreModel } from './use-settings-store-model'
 import type { SettingsInteractionController } from './use-settings-interaction-controller'
@@ -96,7 +97,11 @@ function NavigationHarness({
         settings={settings}
         updateSettings={vi.fn()}
         writeSourceControlAiSettings={async () => {}}
-        searchEntries={[...getChatAppearanceSearchEntries(), getChatNamingSearchEntry()]}
+        searchEntries={[
+          ...getChatAppearanceSearchEntries(),
+          getChatNamingSearchEntry(),
+          getChatInlineVisualsSearchEntry()
+        ]}
         showDesktopOnlySettings
         isMounted
       />
@@ -105,6 +110,23 @@ function NavigationHarness({
 }
 
 describe('Chat settings deep links', () => {
+  it('activates Chat and scrolls to Inline visuals from another settings page', async () => {
+    const scrollIntoView = vi.spyOn(HTMLElement.prototype, 'scrollIntoView')
+    const { container } = render(
+      <NavigationHarness enabled initialSection="appearance" targetSection="chat-inline-visuals" />
+    )
+    await waitFor(() => {
+      expect(screen.getByRole('status', { name: 'Selected settings page' }).textContent).toBe(
+        'chat'
+      )
+    })
+    const visuals = container.querySelector('#chat-inline-visuals')
+    expect(visuals?.querySelector('[role="switch"]')).toBe(
+      screen.getByRole('switch', { name: 'Toggle inline visuals' })
+    )
+    await waitFor(() => expect(scrollIntoView.mock.contexts).toContain(visuals))
+  })
+
   it('activates Chat and renders the moved row for a deep link', async () => {
     render(<NavigationHarness enabled initialSection="appearance" />)
     await waitFor(() => {
diff --git a/src/renderer/src/components/settings/ChatSettingsSection.test.tsx b/src/renderer/src/components/settings/ChatSettingsSection.test.tsx
index b2581d3f280a..9e5716452527 100644
--- a/src/renderer/src/components/settings/ChatSettingsSection.test.tsx
+++ b/src/renderer/src/components/settings/ChatSettingsSection.test.tsx
@@ -7,6 +7,7 @@ import { ChatSettingsSection } from './ChatSettingsSection'
 import { ActiveSettingsSectionProvider } from './SettingsSection'
 import { getChatAppearanceSearchEntries } from './chat-appearance-search'
 import { getChatNamingSearchEntry } from './chat-naming-search'
+import { getChatInlineVisualsSearchEntry } from './chat-inline-visuals-search'
 import { buildSettingsNavigationMetadata } from '@/hooks/useSettingsNavigationMetadata'
 import { buildCmdJSettingsResults } from '../cmd-j/palette-results'
 import { isSettingsNavigationTarget } from '@/lib/settings-navigation-types'
@@ -46,7 +47,12 @@ function renderChat(
         settings={settings}
         updateSettings={updateSettings}
         writeSourceControlAiSettings={async () => {}}
-        searchEntries={[...getChatAppearanceSearchEntries(), getChatNamingSearchEntry()]}
+        searchEntries={[
+          ...getChatAppearanceSearchEntries(),
+          ...(showDesktopOnlySettings
+            ? [getChatNamingSearchEntry(), getChatInlineVisualsSearchEntry()]
+            : [])
+        ]}
         showDesktopOnlySettings={showDesktopOnlySettings}
         isMounted
         hasUnsavedChatPromptChanges={hasUnsavedChatPromptChanges}
@@ -62,6 +68,7 @@ describe('Chat settings page', () => {
     expect(screen.getByRole('spinbutton', { name: 'Text size' })).toBeTruthy()
     expect(container.querySelector('#chat-names')).toBeNull()
     expect(screen.queryByRole('switch', { name: 'Name chats automatically' })).toBeNull()
+    expect(screen.queryByRole('switch', { name: 'Toggle inline visuals' })).toBeNull()
     const sections = buildSettingsNavigationMetadata({
       isMac: false,
       isWindows: false,
@@ -72,6 +79,7 @@ describe('Chat settings page', () => {
     const results = buildCmdJSettingsResults(sections).filter((entry) => entry.sectionId === 'chat')
     expect(results.some((entry) => entry.targetSectionId === 'chat-text-size')).toBe(true)
     expect(results.some((entry) => entry.targetSectionId === 'chat-names')).toBe(false)
+    expect(results.some((entry) => entry.targetSectionId === 'chat-inline-visuals')).toBe(false)
   })
 
   it.each([false, undefined])('is absent with structured chat set to %s', (enabled) => {
@@ -99,14 +107,19 @@ describe('Chat settings page', () => {
     )
   })
 
-  it('renders Appearance and Chat names as peer sections with separate cards', () => {
+  it('renders Appearance, Inline visuals and Chat names as peers with separate cards', () => {
     const { container } = renderChat(true)
     const appearance = container.querySelector('#chat-appearance')
     const names = container.querySelector('#chat-names')
+    const visuals = container.querySelector('#chat-inline-visuals')
     expect(screen.getByRole('heading', { name: 'Chat names', level: 3 })).toBeTruthy()
     expect(appearance).toBeTruthy()
     expect(names).toBeTruthy()
     expect(appearance?.parentElement).toBe(names?.parentElement)
+    expect(visuals?.parentElement).toBe(appearance?.parentElement)
+    expect(visuals?.querySelector('[data-slot="card"]')).toBeTruthy()
+    expect(visuals?.contains(appearance)).toBe(false)
+    expect(visuals?.contains(names)).toBe(false)
     expect(appearance?.closest('[data-slot="card"]')).toBeNull()
     expect(names?.closest('[data-slot="card"]')).toBeNull()
     const appearanceCard = screen
diff --git a/src/renderer/src/components/settings/ChatSettingsSection.tsx b/src/renderer/src/components/settings/ChatSettingsSection.tsx
index df8f28aaa10e..62d83dafa056 100644
--- a/src/renderer/src/components/settings/ChatSettingsSection.tsx
+++ b/src/renderer/src/components/settings/ChatSettingsSection.tsx
@@ -1,6 +1,7 @@
 import { translate } from '@/i18n/i18n'
 import { AppearanceChatSection } from './AppearanceChatSection'
 import { ChatNamingSetting } from './ChatNamingSetting'
+import { NativeChatInlineVisualsSetting } from './NativeChatInlineVisualsSetting'
 import { SettingsSection } from './SettingsSection'
 import { SettingsSubsectionHeader } from './SettingsFormControls'
 import { matchesSettingsSearch } from './settings-search'
@@ -42,10 +43,7 @@ export function ChatSettingsSection({
     <SettingsSection
       id="chat"
       title={title}
-      description={translate(
-        'settings.chat.description',
-        'Choose how chats look and get their names.'
-      )}
+      description={translate('settings.chat.description', 'Choose how chats look and behave.')}
       searchEntries={searchEntries}
       forceVisible={hasUnsavedChatPromptChanges}
       bodyClassName="rounded-none border-0 bg-transparent p-0 shadow-none"
@@ -69,6 +67,13 @@ export function ChatSettingsSection({
               </Card>
             </section>
           ) : null}
+          {showDesktopOnlySettings ? (
+            <NativeChatInlineVisualsSetting
+              settings={settings}
+              updateSettings={updateSettings}
+              forceVisible={matchesSettingsSearch(query, [{ title }])}
+            />
+          ) : null}
           {showDesktopOnlySettings ? (
             <ChatNamingSetting
               key={chatPromptDiscardSignal}
diff --git a/src/renderer/src/components/settings/NativeChatExperimentalSetting.test.tsx b/src/renderer/src/components/settings/NativeChatExperimentalSetting.test.tsx
index d876e33f00c2..8e95b25a45c6 100644
--- a/src/renderer/src/components/settings/NativeChatExperimentalSetting.test.tsx
+++ b/src/renderer/src/components/settings/NativeChatExperimentalSetting.test.tsx
@@ -258,3 +258,15 @@ describe('NativeChatExperimentalSetting queue follow-ups', () => {
     expect(container.querySelector(QUEUE_TOGGLE)).toBeNull()
   })
 })
+
+describe('NativeChatExperimentalSetting inline visuals', () => {
+  it('leaves Inline visuals on the Chat page even while structured chat is enabled', () => {
+    const { queryByRole, getByRole } = renderSetting({
+      experimentalNativeChat: true,
+      openAgentTabsInChatByDefault: true,
+      experimentalStructuredNativeChat: true
+    })
+    expect(getByRole('switch', { name: 'Toggle automatic resume after a restart' })).toBeTruthy()
+    expect(queryByRole('switch', { name: 'Toggle inline visuals' })).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/settings/NativeChatInlineVisualsSetting.tsx b/src/renderer/src/components/settings/NativeChatInlineVisualsSetting.tsx
new file mode 100644
index 000000000000..4013be576c9c
--- /dev/null
+++ b/src/renderer/src/components/settings/NativeChatInlineVisualsSetting.tsx
@@ -0,0 +1,44 @@
+import type { GlobalSettings } from '../../../../shared/global-settings-types'
+import { translate } from '@/i18n/i18n'
+import { SettingsSwitchRow } from './SettingsFormControls'
+import { Card, CardContent } from '../ui/card'
+import { SearchableSetting } from './SearchableSetting'
+import { getChatInlineVisualsSearchEntry } from './chat-inline-visuals-search'
+
+type NativeChatInlineVisualsSettingProps = {
+  settings: GlobalSettings
+  updateSettings: (updates: Partial<GlobalSettings>) => void
+  forceVisible?: boolean
+}
+
+export function NativeChatInlineVisualsSetting({
+  settings,
+  updateSettings,
+  forceVisible = false
+}: NativeChatInlineVisualsSettingProps): React.JSX.Element {
+  const enabled = settings.nativeChatInlineVisuals !== false
+  const entry = getChatInlineVisualsSearchEntry()
+  return (
+    <SearchableSetting
+      {...entry}
+      id="chat-inline-visuals"
+      forceVisible={forceVisible}
+      className="max-w-none"
+    >
+      <Card>
+        <CardContent>
+          <SettingsSwitchRow
+            label={entry.title}
+            description={entry.description}
+            checked={enabled}
+            ariaLabel={translate(
+              'components.settings.nativeChat.inlineVisualsToggleLabel',
+              'Toggle inline visuals'
+            )}
+            onChange={() => updateSettings({ nativeChatInlineVisuals: !enabled })}
+          />
+        </CardContent>
+      </Card>
+    </SearchableSetting>
+  )
+}
diff --git a/src/renderer/src/components/settings/chat-inline-visuals-search.ts b/src/renderer/src/components/settings/chat-inline-visuals-search.ts
new file mode 100644
index 000000000000..cf9ac9b47437
--- /dev/null
+++ b/src/renderer/src/components/settings/chat-inline-visuals-search.ts
@@ -0,0 +1,12 @@
+import { translate } from '@/i18n/i18n'
+import { createLocalizedCatalog } from '@/i18n/localized-catalog'
+import type { SettingsSearchEntry } from './settings-search'
+
+export const getChatInlineVisualsSearchEntry = createLocalizedCatalog((): SettingsSearchEntry => ({
+  targetSectionId: 'chat-inline-visuals',
+  title: translate('components.settings.nativeChat.inlineVisualsTitle', 'Inline visuals'),
+  description: translate(
+    'components.settings.nativeChat.inlineVisualsCopy',
+    'Let the agent show charts, diagrams and mockups inside its replies. Applies to newly started chats.'
+  )
+}))
diff --git a/src/renderer/src/components/settings/native-chat-experimental-search-entry.test.ts b/src/renderer/src/components/settings/native-chat-experimental-search-entry.test.ts
index 1bedfdb164bb..7a1c28dfbda1 100644
--- a/src/renderer/src/components/settings/native-chat-experimental-search-entry.test.ts
+++ b/src/renderer/src/components/settings/native-chat-experimental-search-entry.test.ts
@@ -10,4 +10,11 @@ describe('native chat experimental search entry', () => {
   it('matches "queue" so the Queue follow-ups switch is findable', () => {
     expect(matchesSettingsSearch('queue', getNativeChatExperimentalSearchEntry())).toBe(true)
   })
+
+  it.each(['inline visuals', 'visuals'])(
+    'leaves the moved switch out of Experimental for %s',
+    (query) => {
+      expect(matchesSettingsSearch(query, getNativeChatExperimentalSearchEntry())).toBe(false)
+    }
+  )
 })
diff --git a/src/renderer/src/hooks/settings-navigation-interface-sections.ts b/src/renderer/src/hooks/settings-navigation-interface-sections.ts
index ca538b877711..8adfb8b0c8fd 100644
--- a/src/renderer/src/hooks/settings-navigation-interface-sections.ts
+++ b/src/renderer/src/hooks/settings-navigation-interface-sections.ts
@@ -1,6 +1,7 @@
 import { getAppearancePaneSearchEntries } from '@/components/settings/appearance-search'
 import { getChatAppearanceSearchEntries } from '@/components/settings/chat-appearance-search'
 import { getChatNamingSearchEntry } from '@/components/settings/chat-naming-search'
+import { getChatInlineVisualsSearchEntry } from '@/components/settings/chat-inline-visuals-search'
 import { getInputPaneSearchEntries } from '@/components/settings/input-search'
 import { getNotificationsPaneSearchEntries } from '@/components/settings/notifications-search'
 import { getShortcutsPaneSearchEntries } from '@/components/settings/shortcuts-search'
@@ -42,12 +43,14 @@ export function buildInterfaceSettingsSections({
             title: translate('settings.appearance.chat.title', 'Chat'),
             description: translate(
               'settings.chat.description',
-              'Choose how chats look and get their names.'
+              'Choose how chats look and behave.'
             ),
             icon: MessageSquare,
             searchEntries: [
               ...getChatAppearanceSearchEntries(),
-              ...(showDesktopOnlySettings ? [getChatNamingSearchEntry()] : [])
+              ...(showDesktopOnlySettings
+                ? [getChatNamingSearchEntry(), getChatInlineVisualsSearchEntry()]
+                : [])
             ],
             group: 'interface'
           }
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 97abc760cd61..3c633c934100 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -177,7 +177,7 @@
   },
   "settings": {
     "chat": {
-      "description": "Choose how chats look and get their names.",
+      "description": "Choose how chats look and behave.",
       "names": {
         "title": "Chat names",
         "description": "Use an agent to name new chats from their first message. Without a generated name, chats stay Claude Chat or Codex Chat.",
@@ -18954,6 +18954,9 @@
       },
       "nativeChat": {
         "queueFollowUpsTitle": "Queue follow-ups",
+        "inlineVisualsTitle": "Inline visuals",
+        "inlineVisualsCopy": "Let the agent show charts, diagrams and mockups inside its replies. Applies to newly started chats.",
+        "inlineVisualsToggleLabel": "Toggle inline visuals",
         "queueFollowUpsCopy": "Messages you send while the agent is working wait as cards you can steer, edit, or delete. Messages with images send right away.",
         "queueFollowUpsToggleLabel": "Toggle queue follow-ups"
       }
diff --git a/src/shared/default-global-settings.ts b/src/shared/default-global-settings.ts
index 7c0bd6afe7c5..be9ee19ab216 100644
--- a/src/shared/default-global-settings.ts
+++ b/src/shared/default-global-settings.ts
@@ -137,6 +137,7 @@ export function buildDefaultSettings(args: {
     experimentalStructuredNativeChat: false,
     nativeChatResumeWorkOnRestart: false,
     nativeChatQueueFollowUps: true,
+    nativeChatInlineVisuals: true,
     nativeChatInheritShellEnvironment: true,
     nativeChatShellEnvironmentVariables: [],
     nativeChatSessionOptions: {},
diff --git a/src/shared/global-settings-types.ts b/src/shared/global-settings-types.ts
index b310d9fca0b1..a8661a51689d 100644
--- a/src/shared/global-settings-types.ts
+++ b/src/shared/global-settings-types.ts
@@ -228,6 +228,8 @@ export type GlobalSettings = NativeChatGlobalSettings & {
   /** Chat-wide: hold a mid-turn send as an editable queued draft that goes when the turn ends
    *  (capable hosts only). Absent = on; off keeps mid-turn sends immediate. */
   nativeChatQueueFollowUps?: boolean
+  /** Teach newly started native chats to create inline visuals; absent means on. */
+  nativeChatInlineVisuals?: boolean
   /** Structured chat only: Codex/Claude children inherit the whole login-shell environment.
    *  Off passes only `nativeChatShellEnvironmentVariables` (plus a PATH/locale baseline). */
   nativeChatInheritShellEnvironment?: boolean

From b1cd85820bdb655c4979e31c6fb37289a08e66db Mon Sep 17 00:00:00 2001
From: Neil <neil@stably.ai>
Date: Wed, 7 Oct 2026 22:07:47 -0700
Subject: [PATCH 13/17] Show multiple reviews and tasks in workspace cards and
 details

---
 ...use-visible-hosted-review-refresh.test.tsx |    1 +
 .../use-visible-hosted-review-refresh.ts      |   21 +-
 src/renderer/src/assets/main.css              |   55 +
 .../activity/activity-thread-hover-card.tsx   |    4 +-
 .../open-dialog/github-item-dialog.tsx        |   10 +-
 .../pull-request-page/page/surface.tsx        |   10 +-
 .../sidebar/WorkspaceAttachmentComposer.tsx   |   47 +
 .../WorkspaceAttachmentOrigins.test.tsx       |  262 ++++
 .../sidebar/WorkspaceAttachmentOrigins.tsx    |  102 ++
 ...kspaceAttachmentSearch.resolution.test.tsx |  335 +++++
 .../sidebar/WorkspaceAttachmentSearch.tsx     |  336 +++++
 .../WorkspaceAttachmentSourceStatus.tsx       |   81 ++
 .../WorkspaceReviewChecksIndicator.tsx        |   37 +
 .../WorktreeCard.compact-hover.test.tsx       |   68 +-
 ....compact-ports-hover-independence.test.tsx |  127 +-
 .../sidebar/WorktreeCard.pr-display.test.tsx  |   48 +-
 ...treeCard.single-reference-details.test.tsx |  110 ++
 .../WorktreeCardLinkedItemsSection.test.tsx   |  220 +++
 .../WorktreeCardLinkedItemsSection.tsx        |  204 +++
 .../components/sidebar/WorktreeCardMeta.tsx   |  240 ++--
 .../sidebar/WorktreeCardMetaBadges.tsx        |  109 +-
 .../WorktreeCardMetadataStatusBadges.tsx      |   20 +-
 .../sidebar/WorktreeCardStatusSlot.test.tsx   |   76 ++
 .../sidebar/WorktreeCardStatusSlot.tsx        |   34 +-
 .../sidebar/WorktreeDisplayNameField.tsx      |    6 +-
 .../sidebar/WorktreeIssueLinkField.tsx        |  260 ----
 .../sidebar/WorktreeLinkedItemRow.tsx         |  135 ++
 .../sidebar/WorktreeLinkedItemsField.tsx      |  173 +++
 .../WorktreeMetaDialog.host-scope.test.tsx    |  155 +++
 .../sidebar/WorktreeMetaDialog.test.tsx       | 1191 +++++++----------
 .../components/sidebar/WorktreeMetaDialog.tsx |  439 +-----
 .../sidebar/WorktreeMetaDialogDraft.tsx       |  360 +++++
 .../sidebar/WorktreeReferenceStack.test.tsx   |   86 ++
 .../sidebar/WorktreeReferenceStack.tsx        |  169 +++
 .../sidebar/WorktreeReviewLinkField.tsx       |   60 -
 .../use-workspace-reference-details.test.tsx  |  296 ++++
 .../use-workspace-reference-details.ts        |   69 +
 .../sidebar/use-worktree-card-controller.ts   |   17 +
 .../sidebar/use-worktree-card-foundation.ts   |   16 +
 .../use-worktree-card-lifecycle-effects.ts    |   22 +-
 .../use-worktree-card-linked-details.ts       |   47 +-
 .../use-worktree-card-review-details.ts       |   27 +-
 .../use-worktree-card-secondary-details.ts    |   21 +-
 .../sidebar/use-worktree-issue-link.ts        |  280 ----
 .../sidebar/use-worktree-meta-workspace.ts    |   97 +-
 .../sidebar/use-worktree-sleep-state.ts       |   22 +-
 .../workspace-attachment-source-label.test.ts |  168 +++
 .../workspace-attachment-source-label.ts      |   89 ++
 ...workspace-attachment-source-result.test.ts |  177 +++
 .../workspace-attachment-source-result.ts     |  103 ++
 .../workspace-hover-attachments.test.ts       |  112 ++
 .../sidebar/workspace-hover-attachments.ts    |   96 ++
 .../workspace-reference-detail-read.test.ts   |  231 ++++
 .../workspace-reference-detail-read.ts        |  147 ++
 .../sidebar/workspace-reference-details.ts    |  139 ++
 ...orkspace-reference-refresh-targets.test.ts |  167 +++
 .../workspace-reference-refresh-targets.ts    |   89 ++
 .../workspace-reference-review-source.ts      |   34 +
 .../worktree-attachment-editing.test.ts       |   72 +
 .../sidebar/worktree-attachment-editing.ts    |  262 ++++
 .../sidebar/worktree-card-meta-types.ts       |    9 +
 .../sidebar/worktree-card-parent-content.tsx  |   12 +-
 .../sidebar/worktree-card-presentation.tsx    |  100 +-
 .../sidebar/worktree-issue-displacement.ts    |   48 -
 .../sidebar/worktree-meta-dialog-owner.ts     |   16 +
 .../sidebar/worktree-meta-updates.test.ts     |  399 ------
 .../sidebar/worktree-meta-updates.ts          |  309 -----
 .../sidebar/worktree-review-helpers.tsx       |   18 +-
 .../src/components/task-page/github/Rows.tsx  |    3 +-
 src/renderer/src/components/ui/command.tsx    |   48 +-
 src/renderer/src/components/ui/hover-card.tsx |   19 +-
 .../use-task-page-workspace-actions.ts        |    3 +-
 .../worktree-jump-palette-create-worktree.ts  |   12 +-
 .../src/i18n/en-runtime-required.json         |  105 +-
 .../src/lib/fix-checks-agent-launch.ts        |    7 +-
 ...hub-work-item-workspace-attachment.test.ts |   46 +
 .../github-work-item-workspace-attachment.ts  |   61 +-
 .../src/lib/hosted-review-repo-read.ts        |   26 +
 .../linear-issue-workspace-attachment.test.ts |   30 +
 .../lib/linear-issue-workspace-attachment.ts  |   56 +-
 .../worktree-palette-attachment-urls.test.ts  |   83 ++
 .../src/lib/worktree-palette-document.ts      |    7 +
 .../src/lib/worktree-palette-evidence.ts      |   27 +-
 .../lib/worktree-palette-gitlab-url-match.ts  |   54 +-
 .../src/lib/worktree-palette-search.test.ts   |   22 +
 .../lib/worktree-palette-task-url-match.ts    |  109 +-
 ...le-hosted-review-refresh-scheduler.test.ts |   47 +-
 ...visible-hosted-review-refresh-scheduler.ts |   29 +-
 ...ible-hosted-review-refresh-targets.test.ts |   40 +
 .../visible-hosted-review-refresh-targets.ts  |  113 +-
 .../src/store/github/worktree-refresh.ts      |    4 +-
 .../store/slices/hosted-review-cache-state.ts |    3 +
 .../src/store/slices/hosted-review.ts         |   50 +-
 .../linear-source-context-cache-scope.test.ts |   68 +
 .../src/store/slices/linear/linear-cache.ts   |    6 +-
 .../linear/linear-issue-cache-actions.ts      |    4 +-
 .../linear/linear-issue-detail-actions.ts     |    4 +-
 .../linear/linear-issue-list-actions.ts       |    8 +-
 .../slices/linear/linear-slice-contract.ts    |    8 +-
 99 files changed, 7194 insertions(+), 3210 deletions(-)
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentComposer.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.resolution.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceAttachmentSourceStatus.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorkspaceReviewChecksIndicator.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeCard.single-reference-details.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.tsx
 delete mode 100644 src/renderer/src/components/sidebar/WorktreeIssueLinkField.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeLinkedItemRow.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeLinkedItemsField.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeMetaDialog.host-scope.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeMetaDialogDraft.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeReferenceStack.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/WorktreeReferenceStack.tsx
 delete mode 100644 src/renderer/src/components/sidebar/WorktreeReviewLinkField.tsx
 create mode 100644 src/renderer/src/components/sidebar/use-workspace-reference-details.test.tsx
 create mode 100644 src/renderer/src/components/sidebar/use-workspace-reference-details.ts
 delete mode 100644 src/renderer/src/components/sidebar/use-worktree-issue-link.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-attachment-source-label.test.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-attachment-source-label.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-attachment-source-result.test.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-attachment-source-result.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-hover-attachments.test.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-hover-attachments.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-detail-read.test.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-detail-read.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-details.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-refresh-targets.test.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-refresh-targets.ts
 create mode 100644 src/renderer/src/components/sidebar/workspace-reference-review-source.ts
 create mode 100644 src/renderer/src/components/sidebar/worktree-attachment-editing.test.ts
 create mode 100644 src/renderer/src/components/sidebar/worktree-attachment-editing.ts
 delete mode 100644 src/renderer/src/components/sidebar/worktree-issue-displacement.ts
 create mode 100644 src/renderer/src/components/sidebar/worktree-meta-dialog-owner.ts
 delete mode 100644 src/renderer/src/components/sidebar/worktree-meta-updates.test.ts
 delete mode 100644 src/renderer/src/components/sidebar/worktree-meta-updates.ts
 create mode 100644 src/renderer/src/lib/hosted-review-repo-read.ts
 create mode 100644 src/renderer/src/lib/worktree-palette-attachment-urls.test.ts

diff --git a/src/renderer/src/app-shell/use-visible-hosted-review-refresh.test.tsx b/src/renderer/src/app-shell/use-visible-hosted-review-refresh.test.tsx
index f1936bfe77a2..c876c5f4a08e 100644
--- a/src/renderer/src/app-shell/use-visible-hosted-review-refresh.test.tsx
+++ b/src/renderer/src/app-shell/use-visible-hosted-review-refresh.test.tsx
@@ -15,6 +15,7 @@ vi.mock('@/store', () => ({
 vi.mock('@/lib/web-client-location', () => ({ isWebClientLocation: mocks.web }))
 vi.mock('@/store/github/visible-hosted-review-refresh-targets', () => ({
   visibleHostedReviewRefreshInputsChanged: () => true,
+  getVisibleHostedReviewWorkspaces: () => [],
   getVisibleHostedReviewRefreshTargets: () => [
     {
       key: 'review',
diff --git a/src/renderer/src/app-shell/use-visible-hosted-review-refresh.ts b/src/renderer/src/app-shell/use-visible-hosted-review-refresh.ts
index 033a3657c629..455ee69d12ab 100644
--- a/src/renderer/src/app-shell/use-visible-hosted-review-refresh.ts
+++ b/src/renderer/src/app-shell/use-visible-hosted-review-refresh.ts
@@ -3,6 +3,7 @@ import { useAppStore } from '@/store'
 import { isWindowVisible } from '@/lib/window-visibility-interval'
 import { isWebClientLocation } from '@/lib/web-client-location'
 import { createVisibleHostedReviewRefreshScheduler } from '@/store/github/visible-hosted-review-refresh-scheduler'
+import { getWorkspaceReferenceRefreshTargets } from '@/components/sidebar/workspace-reference-refresh-targets'
 import {
   getVisibleHostedReviewRefreshTargets,
   visibleHostedReviewRefreshInputsChanged
@@ -14,13 +15,19 @@ export function useVisibleHostedReviewRefresh({ enabled }: { enabled: boolean })
       return
     }
     const scheduler = createVisibleHostedReviewRefreshScheduler()
-    const update = (): void =>
-      scheduler.update(
-        getVisibleHostedReviewRefreshTargets(useAppStore.getState(), useAppStore.getState, {
-          selectedOnly: isWebClientLocation()
-        })
-      )
-    const visibilityChanged = (): void => scheduler.setVisible(isWindowVisible())
+    const update = (): void => {
+      const state = useAppStore.getState()
+      const selectedOnly = isWebClientLocation()
+      scheduler.update([
+        ...getVisibleHostedReviewRefreshTargets(state, useAppStore.getState, { selectedOnly }),
+        ...getWorkspaceReferenceRefreshTargets(state, { selectedOnly })
+      ])
+    }
+    const visibilityChanged = (): void => {
+      scheduler.setVisible(false)
+      update()
+      scheduler.setVisible(isWindowVisible())
+    }
     const unsubscribe = useAppStore.subscribe((state, previous) => {
       if (visibleHostedReviewRefreshInputsChanged(state, previous)) {
         update()
diff --git a/src/renderer/src/assets/main.css b/src/renderer/src/assets/main.css
index 261d7d2b0fbf..cb5f526fe999 100644
--- a/src/renderer/src/assets/main.css
+++ b/src/renderer/src/assets/main.css
@@ -3340,3 +3340,58 @@ html.native-shell .app-layout {
     inset 0 1px 0 0 color-mix(in srgb, var(--foreground) 5%, transparent),
     0 10px 24px rgba(0, 0, 0, 0.18);
 }
+
+.workspace-reference-stack {
+  isolation: isolate;
+  position: relative;
+  display: inline-flex;
+  width: 14px;
+  height: 14px;
+  flex-shrink: 0;
+  color: var(--muted-foreground);
+}
+
+.workspace-reference-stack-front,
+.workspace-reference-stack-ghost {
+  position: absolute;
+  inset: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.workspace-reference-stack-front {
+  z-index: 2;
+}
+
+.workspace-reference-stack-ghost[data-depth='1'] {
+  transform: translate(-1.5px, 2px);
+  opacity: 0.45;
+  z-index: 1;
+}
+
+.workspace-reference-stack-ghost[data-depth='2'] {
+  transform: translate(-3px, 4px);
+  opacity: 0.25;
+}
+
+.workspace-reference-stack svg {
+  width: 14px;
+  height: 14px;
+}
+
+.workspace-reference-stack-count {
+  position: absolute;
+  top: -8px;
+  right: -5px;
+  z-index: 3;
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 11px;
+  color: var(--worktree-sidebar-foreground);
+  text-shadow: 0px 1px 1px var(--background);
+}
+
+.workspace-reference-stack-count[data-multiple-digits='true'] {
+  letter-spacing: -0.02em;
+}
diff --git a/src/renderer/src/components/activity/activity-thread-hover-card.tsx b/src/renderer/src/components/activity/activity-thread-hover-card.tsx
index 064235f175ec..849d8f92e25f 100644
--- a/src/renderer/src/components/activity/activity-thread-hover-card.tsx
+++ b/src/renderer/src/components/activity/activity-thread-hover-card.tsx
@@ -126,7 +126,9 @@ function ActivityThreadHoverCardContent({
     issueCacheKey: review.issueCacheKey,
     fetchIssue: foundation.fetchIssue,
     showLinearIssue: true,
-    fetchLinearIssue: foundation.fetchLinearIssue
+    fetchLinearIssue: foundation.fetchLinearIssue,
+    linearSourceContext: review.linearSourceContext,
+    linearWorkspaceId: review.linearWorkspaceId
   })
 
   const secondary = useWorktreeCardSecondaryDetails({
diff --git a/src/renderer/src/components/github-item-dialog/open-dialog/github-item-dialog.tsx b/src/renderer/src/components/github-item-dialog/open-dialog/github-item-dialog.tsx
index f07fe236c70d..b26fd971b116 100644
--- a/src/renderer/src/components/github-item-dialog/open-dialog/github-item-dialog.tsx
+++ b/src/renderer/src/components/github-item-dialog/open-dialog/github-item-dialog.tsx
@@ -38,7 +38,12 @@ export default function GitHubItemDialog({
   const issueAttachedWorkspace = useMemo(
     () =>
       workItem?.type === 'issue'
-        ? findGithubIssueWorkspaceAttachment(allWorktrees, effectiveRepoId, workItem.number)
+        ? findGithubIssueWorkspaceAttachment(
+            allWorktrees,
+            effectiveRepoId,
+            workItem.number,
+            workItem.url
+          )
         : null,
     [allWorktrees, effectiveRepoId, workItem]
   )
@@ -51,7 +56,8 @@ export default function GitHubItemDialog({
       const currentAttached = findGithubIssueWorkspaceAttachment(
         useAppStore.getState().allWorktrees(),
         effectiveRepoId,
-        item.number
+        item.number,
+        item.url
       )
       if (!currentAttached) {
         onUse(item)
diff --git a/src/renderer/src/components/pull-request-page/page/surface.tsx b/src/renderer/src/components/pull-request-page/page/surface.tsx
index ffa5f401e2b9..6352278add42 100644
--- a/src/renderer/src/components/pull-request-page/page/surface.tsx
+++ b/src/renderer/src/components/pull-request-page/page/surface.tsx
@@ -65,7 +65,12 @@ export default function PullRequestPage({
   const attachedWorkspace = useMemo(
     () =>
       workItem?.type === 'pr'
-        ? findGithubPrWorkspaceAttachment(allWorktrees, effectiveRepoId, workItem.number)
+        ? findGithubPrWorkspaceAttachment(
+            allWorktrees,
+            effectiveRepoId,
+            workItem.number,
+            workItem.url
+          )
         : null,
     [allWorktrees, effectiveRepoId, workItem]
   )
@@ -125,7 +130,8 @@ export default function PullRequestPage({
     const currentAttached = findGithubPrWorkspaceAttachment(
       useAppStore.getState().allWorktrees(),
       targetRepoId,
-      workItem.number
+      workItem.number,
+      workItem.url
     )
     if (!currentAttached) {
       handleUseWorkItem()
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentComposer.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentComposer.tsx
new file mode 100644
index 000000000000..da8b6114450d
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentComposer.tsx
@@ -0,0 +1,47 @@
+import React, { useState } from 'react'
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import type { AttachmentInputKind } from './worktree-attachment-editing'
+import { WorkspaceAttachmentSearch } from './WorkspaceAttachmentSearch'
+
+export type WorkspaceAttachmentComposerProps = {
+  items: readonly WorkspaceAttachment[]
+  repo?: Repo
+  workspace?: Worktree
+  disabled: boolean
+  initialKind: AttachmentInputKind
+  initialInput?: string
+  inputRef: React.RefObject<HTMLInputElement | null>
+  onAdd: (item: WorkspaceAttachment) => boolean
+  onSave: () => void
+  getScopeError: (item: WorkspaceAttachment) => string | null
+  error: string | null
+  onQueryChange: () => void
+}
+
+export function WorkspaceAttachmentComposer(
+  props: WorkspaceAttachmentComposerProps
+): React.JSX.Element {
+  const [query, setQuery] = useState(props.initialInput ?? '')
+  const [kind, setKind] = useState(props.initialKind)
+  const [retryGeneration, setRetryGeneration] = useState(0)
+  return (
+    <div data-workspace-reference-search="">
+      <WorkspaceAttachmentSearch
+        key={retryGeneration}
+        {...props}
+        onRetry={() => {
+          setRetryGeneration((generation) => generation + 1)
+          requestAnimationFrame(() => props.inputRef.current?.focus())
+        }}
+        query={query}
+        onQueryChange={(value) => {
+          setQuery(value)
+          props.onQueryChange()
+        }}
+        kind={kind}
+        onKindChange={setKind}
+      />
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.test.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.test.tsx
new file mode 100644
index 000000000000..799c1586c614
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.test.tsx
@@ -0,0 +1,262 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Tab } from '../../../../shared/tab-types'
+import type {
+  WorkspaceAttachment,
+  WorkspaceAttachmentOrigin
+} from '../../../../shared/worktree/types'
+import { makePaneKey } from '../../../../shared/stable-pane-id'
+import { singlePaneLayoutSnapshot } from '../../store/slices/terminal-helpers'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { WorktreeLinkedItemRow } from './WorktreeLinkedItemRow'
+import { makeWorktree, makeTerminalTab } from '../../store/slices/worktrees-slice-test-fixtures'
+import { WorkspaceAttachmentOrigins } from './WorkspaceAttachmentOrigins'
+
+const mocks = vi.hoisted(() => ({
+  state: {
+    unifiedTabsByWorktree: {},
+    terminalLayoutsByTabId: {},
+    tabsByWorktree: {},
+    agentStatusByPaneKey: {},
+    setActiveWorktree: vi.fn(() => true),
+    activateTab: vi.fn()
+  },
+  activateTabAndFocusPane: vi.fn()
+}))
+vi.mock('@/lib/activate-tab-and-focus-pane', () => ({
+  activateTabAndFocusPane: mocks.activateTabAndFocusPane
+}))
+vi.mock('@/store', () => ({
+  useAppStore: Object.assign(
+    (selector: (state: typeof mocks.state) => unknown) => selector(mocks.state),
+    { getState: () => mocks.state }
+  )
+}))
+vi.mock('@/attention/notification-subject-owner', () => ({
+  resolveNotificationTabOwner: (_state: unknown, tab: Tab) => ({
+    executionHostId: tab.executionHostId ?? 'local',
+    runtimeEnvironmentId: null
+  })
+}))
+const workspace = makeWorktree({ id: 'repo::/feature', repoId: 'repo', hostId: 'local' })
+const reference: WorkspaceAttachment = { provider: 'github', type: 'pr', number: 23 }
+const tab = (id: string): Tab => ({
+  id,
+  entityId: id,
+  groupId: 'group',
+  worktreeId: workspace.id,
+  executionHostId: 'local',
+  contentType: 'agent-session',
+  label: id,
+  customLabel: null,
+  color: null,
+  sortOrder: 0,
+  createdAt: 0,
+  agentSessionAgent: 'codex'
+})
+afterEach(() => {
+  cleanup()
+  vi.clearAllMocks()
+})
+function setup() {
+  mocks.state.unifiedTabsByWorktree = {
+    [workspace.id]: [
+      tab('Session A'),
+      tab('Session B'),
+      { ...tab('Foreign session'), executionHostId: 'ssh:other' }
+    ]
+  }
+}
+describe('reference session associations', () => {
+  it('reveals automatic observations without checks selection or manual assignment controls', () => {
+    setup()
+    const onRemove = vi.fn()
+    const parentKeyDown = vi.fn()
+    render(
+      <TooltipProvider>
+        <div onKeyDown={parentKeyDown}>
+          <WorktreeLinkedItemRow
+            item={{
+              ...reference,
+              title: 'Observed review',
+              origins: [{ kind: 'observed', tabId: 'Session B', hostId: 'local' }]
+            }}
+            workspace={workspace}
+            disabled={false}
+            onRemove={onRemove}
+          />
+        </div>
+      </TooltipProvider>
+    )
+    expect(screen.getByText('PR #23')).toBeTruthy()
+    expect(screen.getByText('Observed review')).toBeTruthy()
+    expect(screen.queryByRole('checkbox')).toBeNull()
+    expect(screen.queryByText('Used for checks')).toBeNull()
+    expect(screen.queryByRole('button', { name: /Use .* for checks/ })).toBeNull()
+    const disclosure = screen.getByRole('button', { name: 'Sessions & terminals for PR #23 · 1' })
+    fireEvent.keyDown(disclosure, { key: 'Enter' })
+    expect(parentKeyDown).not.toHaveBeenCalled()
+    fireEvent.click(disclosure)
+    expect(screen.getByRole('button', { name: 'Seen in Session B' })).toBeTruthy()
+    expect(screen.queryByText('Linked to Session A')).toBeNull()
+    expect(screen.queryByRole('checkbox')).toBeNull()
+    fireEvent.click(screen.getByRole('button', { name: 'Seen in Session B' }))
+    expect(mocks.state.activateTab).toHaveBeenCalledWith('Session B', { worktreeId: workspace.id })
+    fireEvent.click(screen.getByRole('button', { name: 'Unlink PR #23' }))
+    expect(onRemove).toHaveBeenCalledOnce()
+  })
+  it('shows no session disclosure for a reference without automatic observations', () => {
+    setup()
+    render(
+      <TooltipProvider>
+        <WorktreeLinkedItemRow
+          item={reference}
+          workspace={workspace}
+          disabled={false}
+          onRemove={vi.fn()}
+        />
+      </TooltipProvider>
+    )
+    expect(screen.queryByRole('button', { name: /Sessions & terminals/ })).toBeNull()
+    expect(screen.queryByRole('checkbox')).toBeNull()
+  })
+  it('opens a related live tab and describes evidence without implying authorship', () => {
+    setup()
+    render(
+      <WorkspaceAttachmentOrigins
+        item={{
+          ...reference,
+          origins: [
+            {
+              kind: 'observed',
+              tabId: 'Session A',
+              label: 'Session A',
+              hostId: 'local',
+              sessionId: 'session-provider-id'
+            }
+          ]
+        }}
+        workspace={workspace}
+      />
+    )
+    fireEvent.click(screen.getByRole('button', { name: 'Seen in Session A' }))
+    expect(mocks.state.setActiveWorktree).toHaveBeenCalledWith(workspace.id, 'local')
+    expect(mocks.state.activateTab).toHaveBeenCalledWith('Session A', { worktreeId: workspace.id })
+  })
+
+  it.each([true, false])(
+    'focuses a recorded pane only while it remains in the layout (present=%s)',
+    (present) => {
+      setup()
+      const leafId = '11111111-1111-4111-8111-111111111111'
+      const otherLeaf = '22222222-2222-4222-8222-222222222222'
+      mocks.state.unifiedTabsByWorktree = {
+        [workspace.id]: [{ ...tab('Terminal'), contentType: 'terminal' }]
+      }
+      mocks.state.tabsByWorktree = {
+        [workspace.id]: [makeTerminalTab({ id: 'Terminal', worktreeId: workspace.id })]
+      }
+      mocks.state.terminalLayoutsByTabId = {
+        Terminal: {
+          ...singlePaneLayoutSnapshot(otherLeaf),
+          root: present
+            ? {
+                type: 'split',
+                direction: 'horizontal',
+                ratio: 0.5,
+                first: { type: 'leaf', leafId },
+                second: { type: 'leaf', leafId: otherLeaf }
+              }
+            : { type: 'leaf', leafId: otherLeaf }
+        }
+      }
+      render(
+        <WorkspaceAttachmentOrigins
+          workspace={workspace}
+          item={{
+            ...reference,
+            origins: [
+              {
+                kind: 'observed',
+                tabId: 'Terminal',
+                hostId: 'local',
+                paneKey: makePaneKey('Terminal', leafId)
+              }
+            ]
+          }}
+        />
+      )
+      fireEvent.click(screen.getByRole('button', { name: 'Seen in Terminal' }))
+      expect(mocks.state.activateTab).toHaveBeenCalledWith('Terminal', { worktreeId: workspace.id })
+      if (present) {
+        expect(mocks.activateTabAndFocusPane).toHaveBeenCalledWith('Terminal', leafId)
+      } else {
+        expect(mocks.activateTabAndFocusPane).not.toHaveBeenCalled()
+      }
+    }
+  )
+})
+
+const localTab: Tab = { ...tab('same-tab'), contentType: 'terminal', label: 'Current terminal' }
+const foreignOrigin: WorkspaceAttachmentOrigin = {
+  kind: 'observed',
+  tabId: localTab.id,
+  hostId: 'ssh:other',
+  label: 'Other host terminal'
+}
+describe('session association host and keyboard regressions', () => {
+  beforeEach(() => {
+    mocks.state.unifiedTabsByWorktree = { [workspace.id]: [localTab] }
+  })
+  it('keeps another host observation unavailable even when a live tab has the same id', () => {
+    render(
+      <WorkspaceAttachmentOrigins
+        workspace={workspace}
+        item={{ provider: 'github', type: 'pr', number: 23, origins: [foreignOrigin] }}
+      />
+    )
+    expect(screen.queryByRole('button')).toBeNull()
+    expect(screen.getByText(/Other host terminal/).textContent).toContain('Tab unavailable')
+  })
+  it.each([
+    ['Escape', false, false, 1],
+    ['Enter', true, false, 1],
+    ['Enter', false, true, 1],
+    ['Enter', false, false, 0]
+  ])('handles parent dialog shortcut %s meta=%s ctrl=%s', (key, metaKey, ctrlKey, calls) => {
+    const parent = vi.fn()
+    render(
+      <div onKeyDown={parent}>
+        <WorkspaceAttachmentOrigins
+          workspace={workspace}
+          item={{
+            ...reference,
+            origins: [{ kind: 'observed', tabId: localTab.id, hostId: 'local' }]
+          }}
+        />
+      </div>
+    )
+    fireEvent.keyDown(screen.getByRole('button', { name: 'Seen in Current terminal' }), {
+      key,
+      metaKey,
+      ctrlKey
+    })
+    expect(parent).toHaveBeenCalledTimes(calls)
+  })
+  it('uses the live tab name while preserving evidence semantics', () => {
+    render(
+      <WorkspaceAttachmentOrigins
+        workspace={workspace}
+        item={{
+          provider: 'github',
+          type: 'pr',
+          number: 23,
+          origins: [{ kind: 'observed', tabId: localTab.id, hostId: 'local', label: 'Old name' }]
+        }}
+      />
+    )
+    expect(screen.getByRole('button', { name: 'Seen in Current terminal' })).toBeTruthy()
+    expect(screen.queryByText('Seen in Old name')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.tsx
new file mode 100644
index 000000000000..6953f23ba744
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentOrigins.tsx
@@ -0,0 +1,102 @@
+import React from 'react'
+import { useAppStore } from '@/store'
+import { Button } from '@/components/ui/button'
+import { translate } from '@/i18n/i18n'
+import { resolveNotificationTabOwner } from '@/attention/notification-subject-owner'
+import { terminalLayoutContainsLeaf } from '../../../../shared/workspace-session-pane-ownership'
+import { activateTabAndFocusPane } from '@/lib/activate-tab-and-focus-pane'
+import { parsePaneKey } from '../../../../shared/stable-pane-id'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import type { Tab } from '../../../../shared/tab-types'
+import { getWorkspaceAttachmentOriginKey } from '../../../../shared/workspace-attachment-origins'
+
+const EMPTY_TABS: Tab[] = []
+
+function useReferenceTabs(workspace: Worktree): Tab[] {
+  const tabs = useAppStore((s) => s.unifiedTabsByWorktree?.[workspace.id] ?? EMPTY_TABS)
+  const state = useAppStore.getState()
+  return tabs.filter((tab) => {
+    if (tab.contentType !== 'terminal' && tab.contentType !== 'agent-session') {
+      return false
+    }
+    const owner = resolveNotificationTabOwner(state, tab)
+    return owner !== null && owner.executionHostId === (workspace.hostId ?? 'local')
+  })
+}
+
+export function WorkspaceAttachmentOrigins({
+  item,
+  workspace
+}: {
+  item: WorkspaceAttachment
+  workspace: Worktree
+}): React.JSX.Element | null {
+  const tabs = useReferenceTabs(workspace)
+  const origins = item.origins?.filter((origin) => origin.kind === 'observed') ?? []
+  if (!origins.length) {
+    return null
+  }
+  return (
+    <div className="flex flex-wrap items-center gap-1 pl-5">
+      {origins.map((origin) => {
+        const tab = tabs.find(
+          (candidate) =>
+            candidate.id === origin.tabId &&
+            (origin.hostId ?? 'local') === (workspace.hostId ?? 'local')
+        )
+        const label =
+          tab?.customLabel ||
+          tab?.label ||
+          origin.label ||
+          origin.agent ||
+          translate('workspace.links.terminal', 'Terminal')
+        const description = translate('workspace.links.seenIn', 'Seen in {{label}}', { label })
+        return tab ? (
+          <Button
+            key={getWorkspaceAttachmentOriginKey(origin)}
+            type="button"
+            variant="ghost"
+            size="xs"
+            title={origin.sessionId ? `${description} · ${origin.sessionId}` : description}
+            onKeyDown={(event) => {
+              if (event.key === 'Enter' && !event.metaKey && !event.ctrlKey) {
+                event.stopPropagation()
+              }
+            }}
+            onClick={(event) => {
+              event.stopPropagation()
+              const state = useAppStore.getState()
+              if (!state.setActiveWorktree(workspace.id, workspace.hostId)) {
+                return
+              }
+              state.activateTab(tab.id, { worktreeId: workspace.id })
+              const pane = origin.paneKey ? parsePaneKey(origin.paneKey) : null
+              if (
+                tab.contentType === 'terminal' &&
+                pane &&
+                pane.tabId === tab.entityId &&
+                state.tabsByWorktree[workspace.id]?.some((entry) => entry.id === tab.entityId) &&
+                terminalLayoutContainsLeaf(
+                  state.terminalLayoutsByTabId[tab.entityId]?.root,
+                  pane.leafId
+                )
+              ) {
+                activateTabAndFocusPane(tab.entityId, pane.leafId)
+              }
+            }}
+          >
+            {description}
+          </Button>
+        ) : (
+          <span
+            key={getWorkspaceAttachmentOriginKey(origin)}
+            className="text-[11px] text-muted-foreground"
+            title={origin.sessionId}
+          >
+            {description} · {translate('workspace.links.unavailableTab', 'Tab unavailable')}
+          </span>
+        )
+      })}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.resolution.test.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.resolution.test.tsx
new file mode 100644
index 000000000000..62522ad2651b
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.resolution.test.tsx
@@ -0,0 +1,335 @@
+// @vitest-environment happy-dom
+import React, { createRef, type ReactNode } from 'react'
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import type { JiraConnectionStatus, JiraIssue, JiraSite } from '../../../../shared/jira-types'
+import type { LinearIssue } from '../../../../shared/linear/issue-types'
+import type { LinearConnectionStatus } from '../../../../shared/linear/workspace-types'
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import type { JiraUrlSourceState } from '../new-workspace/use-jira-url-source'
+import type * as JiraUrlSourceModule from '../new-workspace/use-jira-url-source'
+import type * as JiraSourceConnectionModule from '../new-workspace/use-jira-source-connection'
+import { bindJiraIssueSourceContext } from '../new-workspace/use-jira-url-source'
+import { getWorkspaceAttachmentSourceContext } from './workspace-attachment-source-result'
+import { WorkspaceAttachmentComposer } from './WorkspaceAttachmentComposer'
+
+const sourceMock = vi.hoisted(() => {
+  const jiraState: Omit<JiraUrlSourceState, 'retry' | 'selectAccount'> = {
+    intent: false,
+    loading: false,
+    issue: null,
+    boundSourceContext: null,
+    accountChoices: [],
+    errorKind: null
+  }
+  const jiraStatus: JiraConnectionStatus = { connected: false, viewer: null, sites: [] }
+  const linearStatus: LinearConnectionStatus = { connected: false, viewer: null }
+  return {
+    jiraState,
+    jiraStatus,
+    linearStatus,
+    retryJira: vi.fn(),
+    selectAccount: vi.fn(),
+    readLinearStatus: vi.fn<() => Promise<LinearConnectionStatus>>()
+  }
+})
+vi.mock('../new-workspace/use-jira-url-source', async (importOriginal) => ({
+  ...(await importOriginal<typeof JiraUrlSourceModule>()),
+  useJiraUrlSource: () => ({
+    ...sourceMock.jiraState,
+    retry: sourceMock.retryJira,
+    selectAccount: sourceMock.selectAccount
+  })
+}))
+vi.mock('../new-workspace/use-jira-source-connection', async (importOriginal) => ({
+  ...(await importOriginal<typeof JiraSourceConnectionModule>()),
+  useJiraSourceConnection: () => ({ status: sourceMock.jiraStatus, loaded: true })
+}))
+vi.mock('@/runtime/runtime-linear-client', () => ({ linearStatus: sourceMock.readLinearStatus }))
+vi.mock('@/components/ui/tooltip', () => ({
+  Tooltip: ({ children }: { children?: ReactNode }) => <>{children}</>,
+  TooltipContent: () => null,
+  TooltipTrigger: ({ children }: { children?: ReactNode }) => <>{children}</>
+}))
+
+const initialState = useAppStore.getInitialState()
+const repo: Repo = {
+  id: 'repo',
+  path: '/repo',
+  displayName: 'orca',
+  badgeColor: '',
+  addedAt: 1,
+  executionHostId: 'ssh:dev',
+  gitRemoteIdentity: {
+    canonicalKey: 'github.com/acme/orca',
+    remoteName: 'origin',
+    remoteUrl: 'https://github.com/acme/orca.git'
+  }
+}
+const jiraUrl = 'https://company.atlassian.net/browse/ORCA-123'
+const linearUrl = 'https://linear.app/acme/issue/ORCA-123/fix-it'
+const site: JiraSite = {
+  id: 'site-2',
+  siteUrl: 'https://company.atlassian.net',
+  email: 'chosen@example.com',
+  displayName: 'Chosen account',
+  accountId: 'account-2'
+}
+const jiraIssue: JiraIssue = {
+  id: 'issue-123',
+  key: 'ORCA-123',
+  title: 'Fix it',
+  url: jiraUrl,
+  siteId: site.id,
+  project: { id: 'project-jira', key: 'ORCA', name: 'Orca' },
+  issueType: { id: 'bug', name: 'Bug' },
+  status: { id: 'open', name: 'Open', categoryKey: 'new', categoryName: 'To do' },
+  labels: [],
+  createdAt: '',
+  updatedAt: ''
+}
+const linearIssue: LinearIssue = {
+  id: 'linear-123',
+  identifier: 'ORCA-123',
+  title: 'Fix it',
+  url: linearUrl,
+  workspaceId: 'acme-workspace',
+  workspaceName: 'Acme',
+  state: { name: 'Todo', type: 'unstarted', color: '' },
+  team: { id: 'team', name: 'Orca', key: 'ORCA' },
+  labels: [],
+  labelIds: [],
+  priority: 0,
+  updatedAt: ''
+}
+const connectedLinear: LinearConnectionStatus = {
+  connected: true,
+  viewer: null,
+  activeWorkspaceId: 'acme-workspace',
+  workspaces: [
+    {
+      id: 'acme-workspace',
+      organizationId: 'acme',
+      organizationName: 'Acme',
+      organizationUrlKey: 'acme',
+      displayName: 'Account',
+      email: null
+    }
+  ]
+}
+const onAdd = vi.fn<(item: WorkspaceAttachment) => boolean>(() => true)
+const fetchLinearIssue = vi.fn<() => Promise<LinearIssue | null>>()
+
+function composer(value: string): React.JSX.Element {
+  return (
+    <WorkspaceAttachmentComposer
+      items={[]}
+      repo={repo}
+      disabled={false}
+      initialKind="github-issue"
+      initialInput={value}
+      inputRef={createRef()}
+      onAdd={onAdd}
+      onSave={vi.fn()}
+      getScopeError={() => null}
+      error={null}
+      onQueryChange={vi.fn()}
+    />
+  )
+}
+function input(): HTMLElement {
+  return screen.getByRole('combobox', { name: 'Search references' })
+}
+function direct(): HTMLElement {
+  return screen.getByRole('option', { name: /^Add ORCA-123/ })
+}
+function enter(): void {
+  fireEvent.keyDown(input(), { key: 'Enter' })
+}
+
+describe('workspace reference URL resolution and recovery', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    useAppStore.setState(initialState, true)
+    useAppStore.setState({
+      fetchWorkItems: vi.fn(async () => []),
+      getCachedWorkItems: vi.fn(() => []),
+      refreshPreflightStatus: vi.fn(async () => {}),
+      checkLinearConnection: vi.fn(async () => {}),
+      linearStatusChecked: true,
+      fetchLinearIssue,
+      searchLinearIssues: vi.fn(async () => []),
+      listLinearIssues: vi.fn(async () => ({ items: [] }))
+    })
+    Object.assign(sourceMock.jiraState, {
+      intent: false,
+      loading: false,
+      issue: null,
+      boundSourceContext: null,
+      accountChoices: [],
+      errorKind: null
+    })
+    sourceMock.jiraStatus = { connected: false, viewer: null, sites: [] }
+    sourceMock.linearStatus = { connected: false, viewer: null }
+    sourceMock.readLinearStatus.mockImplementation(async () => sourceMock.linearStatus)
+    fetchLinearIssue.mockResolvedValue(null)
+    Element.prototype.scrollIntoView = vi.fn()
+  })
+  afterEach(cleanup)
+
+  it('blocks pasted Jira URLs while loading, including plain Enter', () => {
+    Object.assign(sourceMock.jiraState, { intent: true, loading: true })
+    render(composer(jiraUrl))
+    expect(direct().getAttribute('data-disabled')).toBe('true')
+    expect(screen.getByRole('status').textContent).toContain('Loading Jira issue')
+    enter()
+    expect(onAdd).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    ['disconnected', 'Connect Jira in Settings'],
+    ['site-not-connected', 'This Jira site is not connected'],
+    ['read-failed', 'Couldn’t load this Jira issue'],
+    ['update-runtime', 'Update the remote runtime']
+  ] as const)(
+    'shows %s guidance and retries without discarding the query',
+    (errorKind, message) => {
+      Object.assign(sourceMock.jiraState, { intent: true, errorKind })
+      render(composer(jiraUrl))
+      expect(screen.getByRole('status').textContent).toContain(message)
+      expect(direct().getAttribute('data-disabled')).toBe('true')
+      enter()
+      fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+      expect(sourceMock.retryJira).toHaveBeenCalledOnce()
+      expect(input()).toHaveProperty('value', jiraUrl)
+      expect(onAdd).not.toHaveBeenCalled()
+    }
+  )
+
+  it('requires an account choice and attaches the resolved Jira account on the execution host', async () => {
+    const otherSite = { ...site, id: 'site-1', email: 'other@example.com' }
+    sourceMock.jiraStatus = { connected: true, viewer: null, sites: [otherSite, site] }
+    Object.assign(sourceMock.jiraState, { intent: true, accountChoices: [otherSite, site] })
+    const view = render(composer(jiraUrl))
+    expect(direct().getAttribute('data-disabled')).toBe('true')
+    expect(screen.getByRole('status').textContent).toContain('Choose a Jira account')
+    fireEvent.click(screen.getByRole('option', { name: /chosen@example.com/ }))
+    expect(sourceMock.selectAccount).toHaveBeenCalledWith(site.id)
+    const context = getWorkspaceAttachmentSourceContext('jira', repo, undefined)
+    if (!context) {
+      throw new Error('Expected Jira source context')
+    }
+    Object.assign(sourceMock.jiraState, {
+      accountChoices: [],
+      issue: jiraIssue,
+      boundSourceContext: bindJiraIssueSourceContext(context, site, jiraIssue)
+    })
+    view.rerender(composer(jiraUrl))
+    await waitFor(() => expect(direct().getAttribute('data-disabled')).not.toBe('true'))
+    enter()
+    expect(onAdd).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider: 'jira',
+        title: 'Fix it',
+        taskSourceContext: expect.objectContaining({
+          hostId: 'ssh:dev',
+          accountLabel: site.email,
+          providerIdentity: expect.objectContaining({ siteId: site.id })
+        })
+      })
+    )
+  })
+
+  it('waits for remote Linear connection and issue lookup before attaching the bound workspace', async () => {
+    let finishStatus: ((status: LinearConnectionStatus) => void) | undefined
+    let finishIssue: ((issue: LinearIssue) => void) | undefined
+    sourceMock.readLinearStatus.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishStatus = resolve
+        })
+    )
+    fetchLinearIssue.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishIssue = resolve
+        })
+    )
+    render(composer(linearUrl))
+    expect(screen.getByRole('status').textContent).toContain('Loading Linear issue')
+    enter()
+    expect(onAdd).not.toHaveBeenCalled()
+    await act(async () => finishStatus?.(connectedLinear))
+    await waitFor(() => expect(fetchLinearIssue).toHaveBeenCalled())
+    expect(direct().getAttribute('data-disabled')).toBe('true')
+    enter()
+    expect(onAdd).not.toHaveBeenCalled()
+    await act(async () => finishIssue?.(linearIssue))
+    await waitFor(() => expect(direct().getAttribute('data-disabled')).not.toBe('true'))
+    enter()
+    expect(onAdd).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider: 'linear',
+        linearWorkspaceId: 'acme-workspace',
+        title: 'Fix it',
+        taskSourceContext: expect.objectContaining({
+          hostId: 'ssh:dev',
+          providerIdentity: expect.objectContaining({ workspaceId: 'acme-workspace' })
+        })
+      })
+    )
+  })
+
+  it('recovers from disconnected Linear without replacing the draft or pasted query', async () => {
+    render(composer(linearUrl))
+    await screen.findByText('Connect Linear in Settings to link this issue.')
+    enter()
+    expect(onAdd).not.toHaveBeenCalled()
+    sourceMock.linearStatus = connectedLinear
+    fetchLinearIssue.mockResolvedValue(linearIssue)
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    expect(input()).toHaveProperty('value', linearUrl)
+    await waitFor(() => expect(direct().getAttribute('data-disabled')).not.toBe('true'))
+    enter()
+    expect(onAdd).toHaveBeenCalledOnce()
+  })
+
+  it('keeps failed Linear URL lookup blocked and retries the same URL', async () => {
+    sourceMock.linearStatus = connectedLinear
+    render(composer(linearUrl))
+    await screen.findByText(
+      'Couldn’t load this Linear issue. Check the URL and connected workspace.'
+    )
+    expect(direct().getAttribute('data-disabled')).toBe('true')
+    enter()
+    expect(onAdd).not.toHaveBeenCalled()
+    fetchLinearIssue.mockResolvedValue(linearIssue)
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    await waitFor(() => expect(direct().getAttribute('data-disabled')).not.toBe('true'))
+    enter()
+    expect(onAdd).toHaveBeenCalledOnce()
+  })
+
+  it('retains explicit bare task identifiers as manual attachments', () => {
+    render(
+      <WorkspaceAttachmentComposer
+        items={[]}
+        repo={repo}
+        disabled={false}
+        initialKind="linear-issue"
+        initialInput="ORCA-123"
+        inputRef={createRef()}
+        onAdd={onAdd}
+        onSave={vi.fn()}
+        getScopeError={() => null}
+        error={null}
+        onQueryChange={vi.fn()}
+      />
+    )
+    expect(direct().getAttribute('data-disabled')).not.toBe('true')
+    enter()
+    expect(onAdd).toHaveBeenCalledOnce()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.tsx
new file mode 100644
index 000000000000..7c5fb9fa48c8
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentSearch.tsx
@@ -0,0 +1,336 @@
+import React, { useCallback, useId, useMemo, useState } from 'react'
+import { ChevronDown, Loader2, Plus, X } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { Command, CommandInput, CommandItem } from '@/components/ui/command'
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuTrigger
+} from '@/components/ui/dropdown-menu'
+import { translate } from '@/i18n/i18n'
+import { isScreenSubmitShortcut } from '@/lib/screen-submit-shortcut'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import type { RowEntry } from '../new-workspace/smart-workspace-name-field-model'
+import type { SmartNameMode } from '../../../../shared/new-workspace/smart-workspace-source-results'
+import { useWorkItemSourceSearch } from '../new-workspace/use-work-item-source-search'
+import { SmartWorkspaceSourceTabs } from '../new-workspace/SmartWorkspaceSourceTabs'
+import { SmartWorkspaceSourceResultList } from '../new-workspace/SmartWorkspaceSourceResultList'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import {
+  ATTACHMENT_INPUT_KINDS,
+  isAttachmentInputKind,
+  parseWorkspaceAttachmentInput,
+  workspaceAttachmentLabel,
+  type AttachmentInputKind
+} from './worktree-attachment-editing'
+import {
+  getWorkspaceAttachmentSourceContext,
+  matchesWorkspaceAttachmentQuery,
+  isWorkspaceAttachmentLinked
+} from './workspace-attachment-source-result'
+
+import type { WorkspaceAttachmentComposerProps } from './WorkspaceAttachmentComposer'
+import { WorkspaceAttachmentSourceStatus } from './WorkspaceAttachmentSourceStatus'
+
+export function WorkspaceAttachmentSearch({
+  query,
+  onQueryChange,
+  kind,
+  onKindChange,
+  onRetry,
+  ...props
+}: Omit<WorkspaceAttachmentComposerProps, 'onQueryChange'> & {
+  query: string
+  onQueryChange: (value: string) => void
+  kind: AttachmentInputKind
+  onKindChange: (kind: AttachmentInputKind) => void
+  onRetry: () => void
+}): React.JSX.Element {
+  const [selection, setSelection] = useState('')
+  const inputId = useId()
+  const contexts = useMemo(
+    () => ({
+      github: getWorkspaceAttachmentSourceContext('github', props.repo, props.workspace),
+      gitlab: getWorkspaceAttachmentSourceContext('gitlab', props.repo, props.workspace),
+      linear: getWorkspaceAttachmentSourceContext('linear', props.repo, props.workspace),
+      jira: getWorkspaceAttachmentSourceContext('jira', props.repo, props.workspace)
+    }),
+    [props.repo, props.workspace]
+  )
+  const repos = useMemo(() => (props.repo ? [props.repo] : []), [props.repo])
+  const add = (item: WorkspaceAttachment): void => {
+    if (!props.onAdd(item)) {
+      return
+    }
+    onQueryChange('')
+    setSelection('')
+    props.inputRef.current?.focus()
+  }
+  const changeMode = useCallback(
+    (mode: SmartNameMode): void => {
+      if (mode === 'linear') {
+        onKindChange('linear-issue')
+      } else if (mode === 'jira') {
+        onKindChange('jira-issue')
+      } else if (mode === 'gitlab') {
+        onKindChange(kind === 'gitlab-issue' ? 'gitlab-issue' : 'gitlab-mr')
+      } else if (mode === 'github' && kind !== 'github-pr' && kind !== 'github-issue') {
+        onKindChange('github-issue')
+      }
+    },
+    [kind, onKindChange]
+  )
+  const controller = useWorkItemSourceSearch({
+    repos,
+    disabled: props.disabled,
+    repoId: props.repo?.id ?? '',
+    value: query,
+    branchesEnabled: false,
+    repoBackedSourcesDisabled: !props.repo,
+    crossRepoSwitchTarget: 'task-source',
+    githubSourceContext: contexts.github,
+    linearSourceContext: contexts.linear,
+    gitlabSourceContext: contexts.gitlab,
+    jiraSourceContext: contexts.jira
+  })
+  const toAttachment = controller.resolveRow
+  const linked = (row: RowEntry): boolean => {
+    const item = toAttachment(row)
+    return item ? isWorkspaceAttachmentLinked(props.items, item) : false
+  }
+  const selectRow = (row: RowEntry): void => {
+    if (controller.isQueryStale) {
+      return
+    }
+    if (row.kind === 'jira-account') {
+      controller.selectJiraAccount(row.site.id)
+      return
+    }
+    const item = toAttachment(row)
+    if (item && !isWorkspaceAttachmentLinked(props.items, item)) {
+      add(item)
+    }
+  }
+  const rows = controller.rows
+  const parsedDirect = parseWorkspaceAttachmentInput(query, kind)
+  const resolvedDirectRow =
+    !controller.isQueryStale && parsedDirect
+      ? rows.find((row) => {
+          const item = toAttachment(row)
+          return item ? matchesWorkspaceAttachmentQuery(parsedDirect, item) : false
+        })
+      : null
+  const direct = resolvedDirectRow
+    ? (toAttachment(resolvedDirectRow) ?? parsedDirect)
+    : parsedDirect
+  const directLinked = direct ? isWorkspaceAttachmentLinked(props.items, direct) : false
+  const scopeError = direct ? props.getScopeError(direct) : null
+  const directValue = direct ? `attachment-direct:${getWorkspaceAttachmentKey(direct)}` : ''
+  const ambiguousNumber = /^#?\d+$/.test(query.trim())
+  const taskUrlProvider =
+    /^https?:\/\//i.test(query.trim()) &&
+    (parsedDirect?.provider === 'linear' || parsedDirect?.provider === 'jira')
+      ? parsedDirect.provider
+      : null
+  const directEnabled = Boolean(
+    direct &&
+    !props.disabled &&
+    !directLinked &&
+    !scopeError &&
+    !controller.blockingTaskUrlResolution &&
+    (!taskUrlProvider || resolvedDirectRow) &&
+    (taskUrlProvider !== 'jira' ||
+      (!controller.jiraSource.loading && !controller.jiraSource.errorKind)) &&
+    !controller.unresolvedLinearUrlIntent &&
+    (!ambiguousNumber || (!controller.isQueryStale && !controller.loading))
+  )
+  const actionableRows = controller.isQueryStale ? [] : rows.filter((row) => !linked(row))
+  const commandValue =
+    selection === directValue && directEnabled
+      ? directValue
+      : actionableRows.some((row) => row.value === selection)
+        ? selection
+        : directEnabled
+          ? directValue
+          : (actionableRows[0]?.value ?? '')
+  return (
+    <Command
+      label={translate('workspace.links.searchLabel', 'Search references')}
+      value={commandValue}
+      onValueChange={setSelection}
+      shouldFilter={false}
+      surface="inline"
+      className="min-h-0"
+    >
+      <div className="shrink-0 space-y-2">
+        <label htmlFor={inputId} className="text-xs font-medium">
+          {translate('workspace.links.addReference', 'Add reference')}
+        </label>
+        <SmartWorkspaceSourceTabs
+          model={controller}
+          inputRef={props.inputRef}
+          onModeChange={(mode) => {
+            controller.setMode(mode)
+            changeMode(mode)
+            requestAnimationFrame(() => props.inputRef.current?.focus({ preventScroll: true }))
+          }}
+        />
+        <CommandInput
+          ref={props.inputRef}
+          id={inputId}
+          value={query}
+          placeholder={translate(
+            'workspace.links.searchReferences',
+            'Search reviews and tasks, or paste a link'
+          )}
+          variant="framed"
+          disabled={props.disabled}
+          trailing={
+            <div className="flex items-center gap-1">
+              {controller.showSearchSpinner ? (
+                <Loader2 className="size-3.5 animate-spin text-muted-foreground" />
+              ) : null}
+              {query ? (
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="icon-xs"
+                  aria-label={translate('workspace.links.clearSearch', 'Clear search')}
+                  onClick={() => {
+                    onQueryChange('')
+                    setSelection('')
+                    props.inputRef.current?.focus()
+                  }}
+                >
+                  <X />
+                </Button>
+              ) : null}
+            </div>
+          }
+          aria-invalid={Boolean(scopeError || props.error) || undefined}
+          onValueChange={(value) => {
+            onQueryChange(value)
+            setSelection('')
+          }}
+          onCompositionStart={(event) => {
+            event.currentTarget.dataset.imeComposing = 'true'
+          }}
+          onCompositionEnd={(event) => {
+            delete event.currentTarget.dataset.imeComposing
+          }}
+          onBlur={(event) => {
+            delete event.currentTarget.dataset.imeComposing
+          }}
+          onKeyDown={(event) => {
+            if (event.key === 'Escape' && query) {
+              event.preventDefault()
+              event.stopPropagation()
+              onQueryChange('')
+              setSelection('')
+              return
+            }
+            if (isScreenSubmitShortcut(event)) {
+              event.preventDefault()
+              event.stopPropagation()
+              props.onSave()
+              return
+            }
+            if (event.key === 'Enter') {
+              event.preventDefault()
+              event.stopPropagation()
+              if (!query.trim()) {
+                return
+              }
+              if (commandValue === directValue && direct && directEnabled) {
+                add(direct)
+              } else {
+                const selected = actionableRows.find((row) => row.value === commandValue)
+                if (selected) {
+                  selectRow(selected)
+                }
+              }
+            }
+          }}
+        />
+      </div>
+      {query.trim() ? (
+        <div className="mt-2 flex max-h-60 min-h-0 shrink flex-col overflow-hidden">
+          <SmartWorkspaceSourceResultList
+            model={controller}
+            onSelect={selectRow}
+            isLinked={linked}
+            isRowDisabled={() => props.disabled || controller.isQueryStale}
+            emptyHint={translate(
+              'workspace.links.noReferences',
+              'No matching references. Try a title, number, or URL.'
+            )}
+            beforeResults={
+              direct ? (
+                <div className="border-b border-border p-1">
+                  <CommandItem
+                    value={directValue}
+                    selection="palette"
+                    disabled={!directEnabled}
+                    onSelect={() => add(direct)}
+                  >
+                    <Plus className="size-3.5" />
+                    <span>
+                      {translate('workspace.links.addItem', 'Add {{label}}', {
+                        label: workspaceAttachmentLabel(direct)
+                      })}
+                    </span>
+                    {directLinked ? (
+                      <span className="ml-auto text-xs text-muted-foreground">
+                        {translate('workspace.links.linkedResult', 'Linked')}
+                      </span>
+                    ) : null}
+                  </CommandItem>
+                </div>
+              ) : null
+            }
+          />
+        </div>
+      ) : null}
+      {query.trim() ? (
+        <div className="mt-2 flex shrink-0 items-center justify-between gap-3">
+          <WorkspaceAttachmentSourceStatus
+            controller={controller}
+            taskUrlProvider={taskUrlProvider}
+            resolved={Boolean(resolvedDirectRow)}
+            error={props.error ?? scopeError}
+            onRetry={onRetry}
+          />
+          {/^[#!]?\d+$|^[a-z][a-z0-9]*-\d+$/i.test(query.trim()) ? (
+            <DropdownMenu modal={false}>
+              <DropdownMenuTrigger asChild>
+                <Button type="button" variant="ghost" size="xs">
+                  <ChevronDown className="size-3" />
+                  {translate('workspace.links.referenceType', 'Reference type')}
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="end">
+                <DropdownMenuRadioGroup
+                  value={kind}
+                  onValueChange={(value) => {
+                    if (isAttachmentInputKind(value)) {
+                      controller.setMode('smart')
+                      onKindChange(value)
+                    }
+                  }}
+                >
+                  {ATTACHMENT_INPUT_KINDS.map((option) => (
+                    <DropdownMenuRadioItem key={option.value} value={option.value}>
+                      {option.label()}
+                    </DropdownMenuRadioItem>
+                  ))}
+                </DropdownMenuRadioGroup>
+              </DropdownMenuContent>
+            </DropdownMenu>
+          ) : null}
+        </div>
+      ) : null}
+    </Command>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorkspaceAttachmentSourceStatus.tsx b/src/renderer/src/components/sidebar/WorkspaceAttachmentSourceStatus.tsx
new file mode 100644
index 000000000000..c8239f8f9500
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceAttachmentSourceStatus.tsx
@@ -0,0 +1,81 @@
+import type React from 'react'
+import { Button } from '@/components/ui/button'
+import { translate } from '@/i18n/i18n'
+import { getJiraSourceStatusMessage } from '../new-workspace/jira-source-status-message'
+import type { WorkItemSourceSearch } from '../new-workspace/use-work-item-source-search'
+
+export function WorkspaceAttachmentSourceStatus({
+  controller,
+  taskUrlProvider,
+  resolved,
+  error,
+  onRetry
+}: {
+  controller: WorkItemSourceSearch
+  taskUrlProvider: 'linear' | 'jira' | null
+  resolved: boolean
+  error: string | null
+  onRetry: () => void
+}): React.JSX.Element {
+  let message =
+    error ?? translate('workspace.links.inlineSearchHint', 'Select a result to attach it.')
+  let retry: (() => void) | null = null
+  if (!error && taskUrlProvider === 'jira') {
+    if (controller.jiraSource.intent) {
+      message = getJiraSourceStatusMessage(controller.jiraSource)
+      if (controller.jiraSource.errorKind) {
+        retry = controller.jiraSource.retry
+      }
+    } else {
+      message = translate(
+        'workspace.links.jiraModeRequired',
+        'Select Smart or Jira to load this issue.'
+      )
+      retry = () => controller.setMode('jira')
+    }
+  } else if (!error && taskUrlProvider === 'linear' && !resolved) {
+    if (!controller.linearUrlIntentOwnsInput) {
+      message = translate(
+        'workspace.links.linearModeRequired',
+        'Select Smart or Linear to load this issue.'
+      )
+      retry = () => controller.setMode('linear')
+    } else if (!controller.linearStatusChecked) {
+      message = translate('workspace.links.loadingLinear', 'Loading Linear issue…')
+    } else if (!controller.linearStatus.connected) {
+      message = translate(
+        'workspace.links.linearConnectRequired',
+        'Connect Linear in Settings to link this issue.'
+      )
+      retry = onRetry
+    } else if (controller.unresolvedLinearUrlIntent || controller.linearLoading) {
+      message = translate('workspace.links.loadingLinear', 'Loading Linear issue…')
+    } else {
+      message = translate(
+        'workspace.links.linearReadFailed',
+        'Couldn’t load this Linear issue. Check the URL and connected workspace.'
+      )
+      retry = onRetry
+    }
+  }
+  return (
+    <div
+      role="status"
+      aria-live="polite"
+      className="flex min-w-0 items-center gap-2 text-xs text-muted-foreground"
+    >
+      <span>{message}</span>
+      {retry ? (
+        <Button
+          type="button"
+          variant="link"
+          size="xs"
+          disabled={controller.disabled}
+          onClick={retry}
+        >
+          {translate('workspace.links.retrySource', 'Retry')}
+        </Button>
+      ) : null}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorkspaceReviewChecksIndicator.tsx b/src/renderer/src/components/sidebar/WorkspaceReviewChecksIndicator.tsx
new file mode 100644
index 000000000000..ac8cab6f8a37
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorkspaceReviewChecksIndicator.tsx
@@ -0,0 +1,37 @@
+import React from 'react'
+import { cn } from '@/lib/utils'
+import { translate } from '@/i18n/i18n'
+import type { WorkspaceReviewChecksSummary } from '../../../../shared/workspace-review-checks'
+import { PullRequestIcon } from './WorktreeCardHelpers'
+import { getReviewChecksTone } from './worktree-review-helpers'
+
+export function workspaceReviewChecksLabel(summary: WorkspaceReviewChecksSummary): string {
+  const status =
+    summary.state === 'failure'
+      ? translate('workspace.links.checksFailed', 'Failed')
+      : summary.state === 'pending'
+        ? translate('workspace.links.checksPending', 'Pending')
+        : summary.state === 'success'
+          ? translate('workspace.links.checksPassing', 'Passing')
+          : summary.state === 'unknown'
+            ? translate('workspace.links.checksUnknown', 'Unknown')
+            : translate('workspace.links.checksNeutral', 'Neutral')
+  return translate('workspace.links.allReviewChecks', 'Reviews: {{count}} · Checks: {{status}}', {
+    count: summary.total,
+    status
+  })
+}
+
+export function WorkspaceReviewChecksIndicator({
+  summary,
+  className
+}: {
+  summary: WorkspaceReviewChecksSummary
+  className?: string
+}): React.JSX.Element {
+  const tone =
+    summary.state === 'failure' || summary.state === 'pending' || summary.state === 'success'
+      ? getReviewChecksTone(summary.state)
+      : null
+  return <PullRequestIcon className={cn(className, tone ?? 'text-muted-foreground')} />
+}
diff --git a/src/renderer/src/components/sidebar/WorktreeCard.compact-hover.test.tsx b/src/renderer/src/components/sidebar/WorktreeCard.compact-hover.test.tsx
index 6b9b85152107..09517679688c 100644
--- a/src/renderer/src/components/sidebar/WorktreeCard.compact-hover.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCard.compact-hover.test.tsx
@@ -31,38 +31,42 @@ let settings: Partial<GlobalSettings> | null = { compactWorktreeCards: true }
 let agentActivityDisplayMode: 'compact' | 'full' | undefined
 let mockInlineAgentRows: DashboardAgentRowData[] = []
 
-vi.mock('@/store', () => ({
-  useAppStore: (selector: (state: unknown) => unknown) =>
-    selector({
-      browserTabsByWorktree: {},
-      agentActivityDisplayMode,
-      createBrowserTab: vi.fn(),
-      deleteStateByWorktreeId: {},
-      fetchHostedReviewForBranch,
-      fetchIssue,
-      fetchLinearIssue,
-      gitConflictOperationByWorktree: {},
-      hostedReviewCache,
-      issueCache,
-      linearIssueCache: {},
-      openModal,
-      openTaskPage,
-      projectGroups,
-      ptyIdsByTabId: {},
-      recordFeatureInteraction,
-      remoteBranchConflictByWorktreeId: {},
-      setRemoteBrowserPageHandle: vi.fn(),
-      replaceWorkspacePortScans,
-      setWorkspacePortScanRefreshing,
-      settings,
-      sshConnectionStates: new Map(),
-      sshTargetLabels: new Map(),
-      tabsByWorktree: {},
-      updateWorktreeMeta,
-      workspacePortScan,
-      worktreeCardProperties
+vi.mock('@/store', () => {
+  const getState = () => ({
+    browserTabsByWorktree: {},
+    agentActivityDisplayMode,
+    createBrowserTab: vi.fn(),
+    deleteStateByWorktreeId: {},
+    fetchHostedReviewForBranch,
+    fetchIssue,
+    fetchLinearIssue,
+    gitConflictOperationByWorktree: {},
+    hostedReviewCache,
+    issueCache,
+    linearIssueCache: {},
+    openModal,
+    openTaskPage,
+    projectGroups,
+    ptyIdsByTabId: {},
+    recordFeatureInteraction,
+    remoteBranchConflictByWorktreeId: {},
+    setRemoteBrowserPageHandle: vi.fn(),
+    replaceWorkspacePortScans,
+    setWorkspacePortScanRefreshing,
+    settings,
+    sshConnectionStates: new Map(),
+    sshTargetLabels: new Map(),
+    tabsByWorktree: {},
+    updateWorktreeMeta,
+    workspacePortScan,
+    worktreeCardProperties
+  })
+  return {
+    useAppStore: Object.assign((selector: (state: unknown) => unknown) => selector(getState()), {
+      getState
     })
-}))
+  }
+})
 
 vi.mock('@/components/ui/hover-card', () => ({
   HoverCard: ({ children, openDelay }: { children: ReactNode; openDelay?: number }) => (
@@ -293,7 +297,7 @@ describe('WorktreeCard compact hover details', () => {
     expect(markup).toContain('data-hover-open-delay="100"')
     expectIdentityBodyIsHoverTrigger(markup)
     expect(markup).toContain('Issue #123')
-    expect(markup).toContain('Linear ENG-123')
+    expect(markup).toContain('ENG-123 · Linear')
     expect(markup).toContain('Reviewer handoff note')
     expect(markup).toContain('Live Ports')
     expect(markup).toContain('58941')
diff --git a/src/renderer/src/components/sidebar/WorktreeCard.compact-ports-hover-independence.test.tsx b/src/renderer/src/components/sidebar/WorktreeCard.compact-ports-hover-independence.test.tsx
index 4720e015bf8a..dd324b3e1534 100644
--- a/src/renderer/src/components/sidebar/WorktreeCard.compact-ports-hover-independence.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCard.compact-ports-hover-independence.test.tsx
@@ -22,41 +22,44 @@ const cacheTimerMocks = vi.hoisted(() => ({
 let worktreeCardProperties: WorktreeCardProperty[] = ['status', 'ports']
 let settings: Partial<GlobalSettings> | null = { compactWorktreeCards: true }
 
-vi.mock('@/store', () => ({
-  useAppStore: (selector: (state: unknown) => unknown) =>
-    selector({
-      browserTabsByWorktree: {},
-      agentActivityDisplayMode: undefined,
-      createBrowserTab: vi.fn(),
-      deleteStateByWorktreeId: {},
-      fetchHostedReviewForBranch,
-      fetchIssue,
-      fetchLinearIssue,
-      gitConflictOperationByWorktree: {},
-      hostedReviewCache: {},
-      issueCache: {},
-      linearIssueCache: {},
-      openModal: vi.fn(),
-      openTaskPage: vi.fn(),
-      projectGroups: [],
-      ptyIdsByTabId: {},
-      recordFeatureInteraction: vi.fn(),
-      remoteBranchConflictByWorktreeId: {},
-      setRemoteBrowserPageHandle: vi.fn(),
-      replaceWorkspacePortScans,
-      setWorkspacePortScanRefreshing,
-      settings,
-      sshConnectionStates: new Map(),
-      sshTargetLabels: new Map(),
-      tabsByWorktree: {},
-      updateWorktreeMeta: vi.fn(),
-      workspacePortScan,
-      worktreeCardProperties
+vi.mock('@/store', () => {
+  const getState = () => ({
+    browserTabsByWorktree: {},
+    agentActivityDisplayMode: undefined,
+    createBrowserTab: vi.fn(),
+    deleteStateByWorktreeId: {},
+    fetchHostedReviewForBranch,
+    fetchIssue,
+    fetchLinearIssue,
+    gitConflictOperationByWorktree: {},
+    hostedReviewCache: {},
+    issueCache: {},
+    linearIssueCache: {},
+    openModal: vi.fn(),
+    openTaskPage: vi.fn(),
+    projectGroups: [],
+    ptyIdsByTabId: {},
+    recordFeatureInteraction: vi.fn(),
+    remoteBranchConflictByWorktreeId: {},
+    setRemoteBrowserPageHandle: vi.fn(),
+    replaceWorkspacePortScans,
+    setWorkspacePortScanRefreshing,
+    settings,
+    sshConnectionStates: new Map(),
+    sshTargetLabels: new Map(),
+    tabsByWorktree: {},
+    updateWorktreeMeta: vi.fn(),
+    workspacePortScan,
+    worktreeCardProperties
+  })
+  return {
+    useAppStore: Object.assign((selector: (state: unknown) => unknown) => selector(getState()), {
+      getState
     })
-}))
+  }
+})
 
-// Why: the real Radix HoverCard is controlled by each root's `open`/`onOpenChange`; expose them so the test can
-// prove the compact title root and the ports root track independent open-state controllers.
+// Expose hover controls to verify compact identity and metadata have one owner.
 const openChangeByRoot = new Map<HTMLElement, (open: boolean) => void>()
 vi.mock('@/components/ui/hover-card', () => ({
   HoverCard: ({
@@ -207,7 +210,7 @@ function rootContaining(selector: string): HTMLElement {
   return root
 }
 
-describe('WorktreeCard compact ports hover independence', () => {
+describe('WorktreeCard compact hover ownership', () => {
   let container: HTMLDivElement
   let root: Root
 
@@ -229,8 +232,26 @@ describe('WorktreeCard compact ports hover independence', () => {
     container.remove()
   })
 
-  it('does not force the compact title hover open when the live-ports hover opens', async () => {
-    const worktree = makeWorktree()
+  it('uses one full identity anchor for compact title, metadata, and live ports', async () => {
+    const worktree = makeWorktree({
+      linkedItems: [
+        {
+          provider: 'github',
+          type: 'pr',
+          number: 57,
+          title: 'Review',
+          url: 'https://github.com/acme/orca/pull/57'
+        },
+        {
+          provider: 'linear',
+          type: 'issue',
+          number: 0,
+          identifier: 'ENG-2',
+          title: 'Task',
+          url: 'https://linear.app/acme/issue/ENG-2/task'
+        }
+      ]
+    })
     workspacePortScan = makePortScan(worktree)
     const { default: WorktreeCard } = await import('./WorktreeCard')
 
@@ -238,22 +259,30 @@ describe('WorktreeCard compact ports hover independence', () => {
       root.render(<WorktreeCard worktree={worktree} repo={makeRepo()} isActive={false} />)
     })
 
-    // Compact mode renders two hover roots: the title-wrapper root and the plug/ports root.
     const titleRoot = rootContaining('[data-worktree-title-inline-rename]')
     const portsRoot = rootContaining('[aria-label="1 live port"]')
-    expect(titleRoot).not.toBe(portsRoot)
-    expect(titleRoot.dataset.open).toBe('false')
-    expect(portsRoot.dataset.open).toBe('false')
-
-    // Opening the ports hover must not drag the (separately anchored, wider) title card open — that cross-root
-    // force-open was the flicker loop in #9304.
-    const openPorts = openChangeByRoot.get(portsRoot)
-    expect(openPorts).toBeTypeOf('function')
+    const metadataRoot = rootContaining('[aria-label="Workspace metadata"]')
+    expect(titleRoot).toBe(portsRoot)
+    expect(titleRoot).toBe(metadataRoot)
+    expect(container.querySelectorAll('[data-hovercard-root]')).toHaveLength(1)
+    expect(container.querySelectorAll('[data-hover-card-content]')).toHaveLength(1)
+    expect(
+      container
+        .querySelector('[data-worktree-card-hover-trigger]')
+        ?.hasAttribute('data-hover-card-trigger')
+    ).toBe(true)
+    const open = openChangeByRoot.get(titleRoot)
     act(() => {
-      openPorts?.(true)
+      open?.(true)
     })
-
-    expect(portsRoot.dataset.open).toBe('true')
-    expect(titleRoot.dataset.open).toBe('false')
+    expect(container.querySelectorAll('[data-open="true"]')).toHaveLength(1)
+    act(() => {
+      open?.(false)
+      open?.(true)
+    })
+    expect(container.querySelectorAll('[data-open="true"]')).toHaveLength(1)
+    expect(titleRoot.textContent).toContain('Reviews · 1')
+    expect(titleRoot.textContent).toContain('Issues & tasks · 1')
+    expect(titleRoot.textContent).toContain('58941')
   })
 })
diff --git a/src/renderer/src/components/sidebar/WorktreeCard.pr-display.test.tsx b/src/renderer/src/components/sidebar/WorktreeCard.pr-display.test.tsx
index 18f01fe92b6e..7b03b8ad777a 100644
--- a/src/renderer/src/components/sidebar/WorktreeCard.pr-display.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCard.pr-display.test.tsx
@@ -23,29 +23,33 @@ let prCache: Record<string, unknown> = {}
 let workspacePortScan: WorkspacePortScanResult | null = null
 let settings: Partial<GlobalSettings> | null = null
 
-vi.mock('@/store', () => ({
-  useAppStore: (selector: (state: unknown) => unknown) =>
-    selector({
-      deleteStateByWorktreeId: {},
-      fetchHostedReviewForBranch,
-      fetchIssue,
-      fetchLinearIssue,
-      gitConflictOperationByWorktree: {},
-      hostedReviewCache,
-      issueCache,
-      linearIssueCache: {},
-      openModal,
-      prCache,
-      projectGroups: [],
-      remoteBranchConflictByWorktreeId: {},
-      settings,
-      sshConnectionStates: new Map(),
-      sshTargetLabels: new Map(),
-      updateWorktreeMeta,
-      workspacePortScan,
-      worktreeCardProperties
+vi.mock('@/store', () => {
+  const getState = () => ({
+    deleteStateByWorktreeId: {},
+    fetchHostedReviewForBranch,
+    fetchIssue,
+    fetchLinearIssue,
+    gitConflictOperationByWorktree: {},
+    hostedReviewCache,
+    issueCache,
+    linearIssueCache: {},
+    openModal,
+    prCache,
+    projectGroups: [],
+    remoteBranchConflictByWorktreeId: {},
+    settings,
+    sshConnectionStates: new Map(),
+    sshTargetLabels: new Map(),
+    updateWorktreeMeta,
+    workspacePortScan,
+    worktreeCardProperties
+  })
+  return {
+    useAppStore: Object.assign((selector: (state: unknown) => unknown) => selector(getState()), {
+      getState
     })
-}))
+  }
+})
 
 vi.mock('@/lib/worktree-activation', () => ({
   activateAndRevealWorktree: vi.fn()
diff --git a/src/renderer/src/components/sidebar/WorktreeCard.single-reference-details.test.tsx b/src/renderer/src/components/sidebar/WorktreeCard.single-reference-details.test.tsx
new file mode 100644
index 000000000000..751d3bdb68aa
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeCard.single-reference-details.test.tsx
@@ -0,0 +1,110 @@
+// @vitest-environment happy-dom
+import type { ReactNode } from 'react'
+import { render, renderHook, screen, cleanup } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { WorktreeCardDetailsHover } from './WorktreeCardMeta'
+import { useWorktreeCardReviewDetails } from './use-worktree-card-review-details'
+import { useWorktreeCardLinkedDetails } from './use-worktree-card-linked-details'
+import {
+  referenceWorkspace,
+  referenceRepo,
+  referenceLinearIssue
+} from './workspace-reference-fixtures.test-support'
+import { normalizeTaskSourceContext } from '../../../../shared/task-source-context'
+import { getLinearReadScope, scopedLinearCacheKey } from '@/store/slices/linear/linear-slice-scope'
+
+const cache = vi.hoisted(() => ({ entries: {} }))
+vi.mock('@/store', () => ({
+  useAppStore: (selector: (state: unknown) => unknown) =>
+    selector({
+      hostedReviewCache: {},
+      prCache: {},
+      issueCache: {},
+      linearIssueCache: cache.entries
+    })
+}))
+vi.mock('@/components/ui/hover-card', () => ({
+  HoverCard: ({ children }: { children: ReactNode }) => <>{children}</>,
+  HoverCardTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,
+  HoverCardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>
+}))
+vi.mock('@/components/ui/tooltip', () => ({
+  Tooltip: ({ children }: { children: ReactNode }) => <>{children}</>,
+  TooltipTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,
+  TooltipContent: () => null
+}))
+vi.mock('@/components/SelectedTextCopyMenu', () => ({
+  SelectedTextCopyMenu: ({ children }: { children: ReactNode }) => <div>{children}</div>
+}))
+vi.mock('./workspace-delete-quick-action', () => ({
+  useWorkspaceDeleteModifierPressed: () => false
+}))
+afterEach(cleanup)
+
+describe('single linked reference rich hover details', () => {
+  it('reuses source-bound Linear details when an exact workspace read is outside the legacy all-workspaces cache slot', () => {
+    const source = normalizeTaskSourceContext({
+      provider: 'linear',
+      projectId: 'project',
+      hostId: 'runtime:owner',
+      providerIdentity: { provider: 'linear', workspaceId: 'workspace' }
+    })
+    const item = {
+      provider: 'linear' as const,
+      type: 'issue' as const,
+      number: 0,
+      identifier: 'ENG-1',
+      url: 'https://linear.app/acme/issue/ENG-1/task',
+      taskSourceContext: source ?? undefined
+    }
+    const workspace = {
+      ...referenceWorkspace,
+      linkedPR: null,
+      linkedLinearIssue: 'ENG-1',
+      linkedItems: [item],
+      linkedTaskSourceContext: source
+    }
+    const issue = referenceLinearIssue()
+    cache.entries = {
+      [scopedLinearCacheKey(getLinearReadScope(null, source), 'workspace::ENG-1')]: {
+        data: issue,
+        fetchedAt: Date.now()
+      }
+    }
+    const legacy = renderHook(() => {
+      const review = useWorktreeCardReviewDetails({
+        worktree: workspace,
+        repo: referenceRepo,
+        settings: null,
+        projectGroups: [],
+        cardProps: ['linear-issue'],
+        newCardStyle: false
+      })
+      return {
+        review,
+        linked: useWorktreeCardLinkedDetails({
+          worktree: workspace,
+          newCardStyle: false,
+          deleteState: undefined,
+          ...review
+        })
+      }
+    })
+    expect(legacy.result.current.review.linearIssueEntry?.data).toEqual(issue)
+    const { container } = render(
+      <WorktreeCardDetailsHover
+        workspace={workspace}
+        issue={null}
+        linearIssue={legacy.result.current.linked.linearIssueDisplay}
+        review={null}
+        comment={null}
+      >
+        <span>Workspace</span>
+      </WorktreeCardDetailsHover>
+    )
+    expect(screen.getByText('Task')).toBeTruthy()
+    expect(screen.getByText('State: In Progress')).toBeTruthy()
+    expect(screen.queryByText('Loading Linear issue...')).toBeNull()
+    expect(container.querySelector('[data-workspace-hover-reference]')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.test.tsx b/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.test.tsx
new file mode 100644
index 000000000000..eb70753efa9f
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.test.tsx
@@ -0,0 +1,220 @@
+// @vitest-environment happy-dom
+import type { ReactNode } from 'react'
+import { render, screen, fireEvent, cleanup } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { WorktreeCardDetailsHover } from './WorktreeCardMeta'
+import type { Worktree, WorkspaceAttachment } from '../../../../shared/worktree/types'
+import { makeWorktree } from '../../store/slices/worktrees-slice-test-fixtures'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { useWorktreeCardDetailsHoverControl } from './worktree-card-details-hover-state'
+import type { WorkspaceReferenceDetailsMap } from './workspace-reference-details'
+
+vi.mock('@/components/ui/tooltip', () => ({
+  Tooltip: ({ children }: { children: ReactNode }) => <>{children}</>,
+  TooltipTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,
+  TooltipContent: () => null
+}))
+vi.mock('@/components/SelectedTextCopyMenu', () => ({
+  SelectedTextCopyMenu: ({ children }: { children: ReactNode }) => <div>{children}</div>
+}))
+vi.mock('@/components/ui/hover-card', () => ({
+  HoverCard: ({
+    children,
+    open,
+    onOpenChange
+  }: {
+    children: ReactNode
+    open: boolean
+    onOpenChange: (open: boolean) => void
+  }) => (
+    <div data-hover-open={String(open)}>
+      <button onClick={() => onOpenChange(true)}>Hover workspace</button>
+      {children}
+    </div>
+  ),
+  HoverCardTrigger: ({ children }: { children: ReactNode }) => <>{children}</>,
+  HoverCardContent: ({ children }: { children: ReactNode }) => (
+    <div data-hover-content="">{children}</div>
+  )
+}))
+const attachments = [
+  {
+    provider: 'github',
+    type: 'pr',
+    number: 57,
+    title: 'Active review',
+    url: 'https://github.com/acme/orca/pull/57'
+  },
+  {
+    provider: 'gitlab',
+    type: 'mr',
+    number: 42,
+    title: 'Sibling review',
+    url: 'https://gitlab.example.com/team/orca/-/merge_requests/42'
+  },
+  {
+    provider: 'linear',
+    type: 'issue',
+    number: 0,
+    identifier: 'ENG-215',
+    title: 'Keyboard accessibility',
+    url: 'https://linear.app/acme/issue/ENG-215/title'
+  },
+  {
+    provider: 'jira',
+    type: 'issue',
+    number: 0,
+    identifier: 'APP-18',
+    title: 'Fix attachments',
+    url: 'https://acme.atlassian.net/browse/APP-18'
+  }
+] satisfies WorkspaceAttachment[]
+const workspace = makeWorktree({
+  id: 'repo::/repo/feature',
+  repoId: 'repo',
+  hostId: 'ssh:owner',
+  linkedPR: 57,
+  linkedItems: attachments
+})
+const review = {
+  provider: 'github' as const,
+  number: 57,
+  title: 'Active review',
+  url: 'https://github.com/acme/orca/pull/57',
+  status: 'success' as const
+}
+function Fixture({
+  onManage,
+  referenceDetails,
+  worktree = workspace
+}: {
+  onManage: () => void
+  referenceDetails?: WorkspaceReferenceDetailsMap
+  worktree?: Worktree
+}): React.JSX.Element {
+  const hoverControl = useWorktreeCardDetailsHoverControl()
+  return (
+    <WorktreeCardDetailsHover
+      workspace={worktree}
+      referenceDetails={referenceDetails}
+      review={review}
+      issue={null}
+      linearIssue={null}
+      comment={null}
+      onManageLinks={onManage}
+      hoverControl={hoverControl}
+    >
+      <span>Workspace</span>
+    </WorktreeCardDetailsHover>
+  )
+}
+afterEach(cleanup)
+describe('workspace linked references in hover details', () => {
+  it('shows each fetched sibling status and target without applying primary checks to its peers', () => {
+    const [, sibling, task] = attachments
+    const details: WorkspaceReferenceDetailsMap = {
+      [getWorkspaceAttachmentKey(sibling)]: {
+        title: 'Merged sibling',
+        url: sibling.url ?? '',
+        review: {
+          provider: 'gitlab',
+          number: 42,
+          title: 'Merged sibling',
+          url: sibling.url,
+          state: 'merged',
+          status: 'neutral',
+          baseRefName: 'release',
+          updatedAt: '2026-10-07',
+          mergeable: 'UNKNOWN'
+        }
+      },
+      [getWorkspaceAttachmentKey(task)]: {
+        title: 'Known task',
+        url: task.url ?? '',
+        stateName: 'In Progress'
+      }
+    }
+    const { container } = render(<Fixture onManage={vi.fn()} referenceDetails={details} />)
+    expect(screen.getByText('Merged sibling')).toBeTruthy()
+    expect(screen.getByText('State: Merged')).toBeTruthy()
+    expect(screen.getByText('Target: release')).toBeTruthy()
+    expect(screen.getByText('State: In Progress')).toBeTruthy()
+    expect(screen.getAllByText('Checks: Passing')).toHaveLength(1)
+    expect(screen.queryByText('Used for checks')).toBeNull()
+    const siblingRow = Array.from(
+      container.querySelectorAll('[data-workspace-hover-reference]')
+    ).find((node) => node.textContent?.includes('Merged sibling'))
+    const icon = siblingRow?.querySelector('svg')
+    expect(icon?.classList.contains('lucide-git-merge')).toBe(true)
+    expect(icon?.classList.contains('dark:text-purple-400/70')).toBe(true)
+  })
+  it('shows grouped peers and only each review’s own known checks', () => {
+    const { container } = render(<Fixture onManage={vi.fn()} />)
+    expect(screen.getByText('Reviews · 2')).toBeTruthy()
+    expect(screen.getByText('Issues & tasks · 2')).toBeTruthy()
+    expect(screen.getAllByText('Active review')).toHaveLength(1)
+    expect(screen.getByText('MR !42 · GitLab · gitlab.example.com/team/orca')).toBeTruthy()
+    expect(screen.getByText('ENG-215 · Linear · acme')).toBeTruthy()
+    const key = getWorkspaceAttachmentKey(attachments[0])
+    expect(
+      Array.from(container.querySelectorAll('[data-workspace-hover-reference]')).find(
+        (node) => node.getAttribute('data-workspace-hover-reference') === key
+      )?.textContent
+    ).toContain('Checks: Passing')
+    expect(screen.queryByText('Used for checks')).toBeNull()
+    expect(screen.getAllByText('Checks: Passing')).toHaveLength(1)
+  })
+  it('opens a reference without activating the parent and dismisses hover', () => {
+    const openUrl = vi.fn()
+    Object.defineProperty(window, 'api', { configurable: true, value: { shell: { openUrl } } })
+    const parentClick = vi.fn()
+    const { container } = render(
+      <div onClick={parentClick}>
+        <Fixture onManage={vi.fn()} />
+      </div>
+    )
+    fireEvent.click(screen.getByRole('button', { name: 'Hover workspace' }))
+    parentClick.mockClear()
+    fireEvent.click(screen.getByRole('button', { name: 'Open MR !42' }))
+    expect(openUrl).toHaveBeenCalledWith('https://gitlab.example.com/team/orca/-/merge_requests/42')
+    expect(parentClick).not.toHaveBeenCalled()
+    expect(container.querySelector('[data-hover-open]')?.getAttribute('data-hover-open')).toBe(
+      'false'
+    )
+  })
+  it('dismisses hover before managing links and exposes no second picker', () => {
+    const onManage = vi.fn()
+    const { container } = render(<Fixture onManage={onManage} />)
+    fireEvent.click(screen.getByRole('button', { name: 'Hover workspace' }))
+    fireEvent.click(screen.getByRole('button', { name: 'Manage links…' }))
+    expect(onManage).toHaveBeenCalledTimes(1)
+    expect(container.querySelector('[data-hover-open]')?.getAttribute('data-hover-open')).toBe(
+      'false'
+    )
+    expect(screen.queryByRole('combobox')).toBeNull()
+  })
+  it('opens metadata management for a URL-less reference and handles attachment-only folders', () => {
+    const onManage = vi.fn()
+    const { container } = render(
+      <WorktreeCardDetailsHover
+        workspace={{
+          ...workspace,
+          id: 'folder:docs',
+          linkedPR: null,
+          linkedItems: [{ provider: 'gitea', type: 'pr', number: 7 }]
+        }}
+        onManageLinks={onManage}
+        issue={null}
+        linearIssue={null}
+        review={null}
+        comment={null}
+      >
+        <span>Folder</span>
+      </WorktreeCardDetailsHover>
+    )
+    expect(container.querySelector('[data-workspace-hover-reference]')).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: 'Open PR #7' }))
+    expect(onManage).toHaveBeenCalledTimes(1)
+    expect(screen.queryByText('Used for checks')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.tsx b/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.tsx
new file mode 100644
index 000000000000..0db0a15c76d8
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeCardLinkedItemsSection.tsx
@@ -0,0 +1,204 @@
+import React from 'react'
+import { CircleDot, ExternalLink, GitMerge, GitPullRequest, Link2, Plus } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { translate } from '@/i18n/i18n'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import {
+  workspaceAttachmentLabel,
+  workspaceAttachmentProviderLabel
+} from './worktree-attachment-editing'
+import { getWorkspaceAttachmentSourceLabel } from './workspace-attachment-source-label'
+import { WorktreeCardDetailSection } from './WorktreeCardDetailSection'
+import { DetailHeader } from './WorktreeCardMetadataControls'
+import {
+  IssueStateBadge,
+  LinearStateBadge,
+  ReviewChecksBadge,
+  ReviewStateBadge
+} from './WorktreeCardMetadataStatusBadges'
+import { WorkspaceAttachmentOrigins } from './WorkspaceAttachmentOrigins'
+import { getReviewLabel, ReviewIcon } from './worktree-review-helpers'
+import type { WorkspaceReferenceDetailsMap } from './workspace-reference-details'
+import { getWorkspaceHoverAttachments } from './workspace-hover-attachments'
+import type {
+  WorktreeCardIssueDisplay,
+  WorktreeCardLinearIssueDisplay,
+  WorktreeCardJiraIssueDisplay
+} from './worktree-card-meta-types'
+import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
+
+export function WorktreeCardLinkedItemsSection({
+  workspace,
+  referenceDetails,
+  review,
+  issue,
+  linearIssue,
+  jiraIssue,
+  showItems,
+  onManage,
+  onOpen
+}: {
+  workspace?: Worktree
+  referenceDetails?: WorkspaceReferenceDetailsMap
+  review: WorktreeCardPrDisplay | null
+  issue?: WorktreeCardIssueDisplay | null
+  linearIssue?: WorktreeCardLinearIssueDisplay | null
+  jiraIssue?: WorktreeCardJiraIssueDisplay | null
+  showItems: boolean
+  onManage?: (event: React.MouseEvent) => void
+  onOpen?: (url: string) => void
+}): React.JSX.Element | null {
+  if (!workspace) {
+    return null
+  }
+  const { items, activeKey, referenceKeys } = getWorkspaceHoverAttachments(workspace, {
+    review,
+    issue,
+    linearIssue,
+    jiraIssue
+  })
+  const groups = [
+    {
+      label: translate('workspace.links.reviews', 'Reviews'),
+      items: items.filter((item) => item.type !== 'issue')
+    },
+    {
+      label: translate('workspace.links.tasks', 'Issues & tasks'),
+      items: items.filter((item) => item.type === 'issue')
+    }
+  ].filter((group) => group.items.length)
+  const open = (item: WorkspaceAttachment, event: React.MouseEvent): void => {
+    event.stopPropagation()
+    if (item.url) {
+      if (onOpen) {
+        onOpen(item.url)
+      } else {
+        void window.api.shell.openUrl(item.url)
+      }
+    } else {
+      onManage?.(event)
+    }
+  }
+  return (
+    <WorktreeCardDetailSection data-workspace-hover-linked-items="">
+      {showItems
+        ? groups.map((group) => (
+            <div key={group.label} className="space-y-1.5">
+              <DetailHeader
+                icon={<Link2 className="size-3" />}
+                label={`${group.label} · ${group.items.length}`}
+              />
+              <div className="divide-y divide-border">
+                {group.items.map((item) => {
+                  const key = getWorkspaceAttachmentKey(item)
+                  const label = workspaceAttachmentLabel(item)
+                  const source = getWorkspaceAttachmentSourceLabel(item)
+                  const active = key === activeKey
+                  const detail = referenceDetails?.[referenceKeys[items.indexOf(item)]]
+                  const url = item.url || detail?.url
+                  const live =
+                    detail?.review ??
+                    (active &&
+                    review?.provider === item.provider &&
+                    review.number === item.number &&
+                    (!item.url || review.url === item.url)
+                      ? review
+                      : null)
+                  return (
+                    <div
+                      key={key}
+                      className="space-y-1 py-1.5"
+                      data-workspace-hover-reference={key}
+                    >
+                      <div className="flex min-w-0 items-start gap-2">
+                        {live ? (
+                          <ReviewIcon review={live} className="mt-0.5 size-3.5 shrink-0" />
+                        ) : item.type === 'mr' ? (
+                          <GitMerge className="mt-0.5 size-3.5 shrink-0 text-muted-foreground" />
+                        ) : item.type === 'pr' ? (
+                          <GitPullRequest className="mt-0.5 size-3.5 shrink-0 text-muted-foreground" />
+                        ) : (
+                          <CircleDot className="mt-0.5 size-3.5 shrink-0 text-muted-foreground" />
+                        )}
+                        <button
+                          type="button"
+                          className="min-w-0 flex-1 rounded-sm text-left outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring"
+                          disabled={!url && !onManage}
+                          aria-label={translate('workspace.links.openItem', 'Open {{label}}', {
+                            label
+                          })}
+                          onClick={(event) => open({ ...item, url }, event)}
+                          onKeyDown={(event) => event.stopPropagation()}
+                        >
+                          <p className="line-clamp-2 text-xs font-medium leading-snug">
+                            {detail?.title || item.title || (live?.url ? live.title : label)}
+                          </p>
+                          <p className="truncate text-[11px] text-muted-foreground">
+                            {label} · {workspaceAttachmentProviderLabel(item)}
+                            {source ? ` · ${source}` : ''}
+                          </p>
+                        </button>
+                        {url ? (
+                          <ExternalLink
+                            aria-hidden
+                            className="mt-0.5 size-3 shrink-0 text-muted-foreground"
+                          />
+                        ) : null}
+                      </div>
+                      {live?.state || live?.status || detail?.stateName || detail?.issueState ? (
+                        <div className="flex flex-wrap items-center gap-1 pl-5">
+                          {live?.state ? (
+                            <ReviewStateBadge state={live.state} label={getReviewLabel(live)} />
+                          ) : null}
+                          {live?.status ? <ReviewChecksBadge status={live.status} /> : null}
+                          {detail?.stale ? (
+                            <span className="text-[11px] text-muted-foreground">
+                              {translate('workspace.links.lastKnownStatus', 'Last known status')}
+                            </span>
+                          ) : null}
+                          {live && 'baseRefName' in live && live.baseRefName ? (
+                            <span className="text-[11px] text-muted-foreground">
+                              {translate('workspace.links.reviewTarget', 'Target: {{branch}}', {
+                                branch: live.baseRefName
+                              })}
+                            </span>
+                          ) : null}
+                          {detail?.stateName ? (
+                            <LinearStateBadge
+                              stateName={detail.stateName}
+                              stateType={detail.stateType}
+                            />
+                          ) : null}
+                          {detail?.issueState ? (
+                            <IssueStateBadge state={detail.issueState} />
+                          ) : null}
+                        </div>
+                      ) : null}
+                      {item.origins?.length ? (
+                        <WorkspaceAttachmentOrigins item={item} workspace={workspace} />
+                      ) : null}
+                    </div>
+                  )
+                })}
+              </div>
+            </div>
+          ))
+        : null}
+      {onManage ? (
+        <Button
+          type="button"
+          variant="ghost"
+          size="xs"
+          onClick={onManage}
+          onKeyDown={(event) => event.stopPropagation()}
+        >
+          <Plus />
+          {items.length
+            ? translate('workspace.links.manage', 'Manage links…')
+            : translate('workspace.links.addReference', 'Add reference')}
+        </Button>
+      ) : null}
+    </WorktreeCardDetailSection>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorktreeCardMeta.tsx b/src/renderer/src/components/sidebar/WorktreeCardMeta.tsx
index 673dcad0f06c..d6bef7520354 100644
--- a/src/renderer/src/components/sidebar/WorktreeCardMeta.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCardMeta.tsx
@@ -1,4 +1,6 @@
 import React from 'react'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { WorktreeCardLinkedItemsSection } from './WorktreeCardLinkedItemsSection'
 import { Badge } from '@/components/ui/badge'
 import { HoverCard, HoverCardTrigger, HoverCardContent } from '@/components/ui/hover-card'
 import { ExternalLink, MonitorUp, Pencil, StickyNote } from 'lucide-react'
@@ -53,6 +55,9 @@ function hasComment(comment: string | null): boolean {
 }
 
 export function WorktreeCardDetailsHover({
+  workspace,
+  referenceDetails,
+  onManageLinks,
   issue,
   linearIssue,
   jiraIssue,
@@ -162,9 +167,15 @@ export function WorktreeCardDetailsHover({
   }, [copyLinkedWorkItemLink, review])
 
   const showIdentityHeader = Boolean(branchName || workspaceTitle)
+  const attachments = getWorkspaceAttachments(workspace ?? {})
+  const showAttachmentCollection =
+    attachments.length > 1 ||
+    (attachments.length === 1 && !issue && !linearIssue && !jiraIssue && !review)
 
   if (
     !showIdentityHeader &&
+    attachments.length === 0 &&
+    !onManageLinks &&
     !hasWorktreeCardDetails({
       issue,
       linearIssue,
@@ -196,7 +207,7 @@ export function WorktreeCardDetailsHover({
         side="right"
         align="start"
         sideOffset={8}
-        className="w-80 max-h-[28rem] overflow-y-auto p-3 text-xs scrollbar-sleek"
+        variant="workspace-details"
         {...{ [WORKTREE_NATIVE_CONTEXT_MENU_ATTR]: '' }}
         onClick={(event) => event.stopPropagation()}
         onDoubleClick={(event) => event.stopPropagation()}
@@ -213,122 +224,143 @@ export function WorktreeCardDetailsHover({
             />
           )}
 
-          <WorktreeCardIssueDetailSection
-            issue={issue}
-            issueMenuOpen={issueMenuOpen}
-            onIssueMenuOpenChange={handleIssueMenuOpenChange}
-            onCopyIssueLink={issue?.url ? handleCopyIssueLink : undefined}
-            onEditIssue={onEditIssue}
-            onOpenGitHubIssueInOrca={
-              onOpenGitHubIssueInOrca ? dismissAndRun(onOpenGitHubIssueInOrca) : undefined
-            }
-            onOpenIssueInBrowser={
-              onOpenIssueInBrowser && issue?.url
-                ? (url: string) => {
-                    closeHover()
-                    onOpenIssueInBrowser(url)
-                  }
-                : undefined
-            }
-          />
+          {!showAttachmentCollection ? (
+            <>
+              <WorktreeCardIssueDetailSection
+                issue={issue}
+                issueMenuOpen={issueMenuOpen}
+                onIssueMenuOpenChange={handleIssueMenuOpenChange}
+                onCopyIssueLink={issue?.url ? handleCopyIssueLink : undefined}
+                onEditIssue={onEditIssue}
+                onOpenGitHubIssueInOrca={
+                  onOpenGitHubIssueInOrca ? dismissAndRun(onOpenGitHubIssueInOrca) : undefined
+                }
+                onOpenIssueInBrowser={
+                  onOpenIssueInBrowser && issue?.url
+                    ? (url: string) => {
+                        closeHover()
+                        onOpenIssueInBrowser(url)
+                      }
+                    : undefined
+                }
+              />
 
-          {linearIssue && (
-            <WorktreeCardDetailSection>
-              <DetailHeader
-                icon={<LinearIcon className="size-3 text-muted-foreground" />}
-                label={translate(
-                  'auto.components.sidebar.WorktreeCardMeta.5e982e6128',
-                  'Linear {{value0}}',
-                  { value0: linearIssue.identifier }
-                )}
-                actions={
-                  <>
-                    {linearIssue.url && onOpenLinearIssueInOrca && (
-                      <MetadataActionIcon
-                        label={translate(
-                          'auto.components.sidebar.WorktreeCardMeta.2c67730e07',
-                          'Open in Orca'
+              {linearIssue && (
+                <WorktreeCardDetailSection>
+                  <DetailHeader
+                    icon={<LinearIcon className="size-3 text-muted-foreground" />}
+                    label={translate(
+                      'auto.components.sidebar.WorktreeCardMeta.5e982e6128',
+                      'Linear {{value0}}',
+                      { value0: linearIssue.identifier }
+                    )}
+                    actions={
+                      <>
+                        {linearIssue.url && onOpenLinearIssueInOrca && (
+                          <MetadataActionIcon
+                            label={translate(
+                              'auto.components.sidebar.WorktreeCardMeta.2c67730e07',
+                              'Open in Orca'
+                            )}
+                            onClick={dismissAndRun(onOpenLinearIssueInOrca)}
+                          >
+                            <MonitorUp className="size-3" />
+                          </MetadataActionIcon>
                         )}
-                        onClick={dismissAndRun(onOpenLinearIssueInOrca)}
-                      >
-                        <MonitorUp className="size-3" />
-                      </MetadataActionIcon>
+                        {linearIssue.url && (
+                          <MetadataActionIcon
+                            label={translate(
+                              'auto.components.sidebar.WorktreeCardMeta.e42941631a',
+                              'View on Linear'
+                            )}
+                            href={linearIssue.url}
+                          >
+                            <ExternalLink className="size-3" />
+                          </MetadataActionIcon>
+                        )}
+                      </>
+                    }
+                  />
+                  <WorktreeCardDetailSectionContent className="space-y-1.5">
+                    <div className="text-[13px] font-semibold leading-snug text-foreground break-words">
+                      {linearIssue.title}
+                    </div>
+                    {((linearIssue.labels && linearIssue.labels.length > 0) ||
+                      linearIssue.stateName) && (
+                      <div className="flex flex-wrap gap-1">
+                        {linearIssue.stateName && (
+                          <LinearStateBadge
+                            stateName={linearIssue.stateName}
+                            stateType={linearIssue.stateType}
+                          />
+                        )}
+                        {(linearIssue.labels ?? []).map((label) => (
+                          <Badge key={label} variant="outline" className="h-4 px-1.5 text-[9px]">
+                            {label}
+                          </Badge>
+                        ))}
+                      </div>
+                    )}
+                  </WorktreeCardDetailSectionContent>
+                </WorktreeCardDetailSection>
+              )}
+
+              {jiraIssue && (
+                <WorktreeCardDetailSection>
+                  <DetailHeader
+                    icon={<JiraIcon className="size-3 text-muted-foreground" />}
+                    label={translate(
+                      'auto.components.sidebar.WorktreeCardMeta.jiraIssue',
+                      'Jira {{value0}}',
+                      { value0: jiraIssue.identifier }
                     )}
-                    {linearIssue.url && (
+                    actions={
                       <MetadataActionIcon
                         label={translate(
-                          'auto.components.sidebar.WorktreeCardMeta.e42941631a',
-                          'View on Linear'
+                          'auto.components.sidebar.WorktreeCardMeta.viewOnJira',
+                          'View on Jira'
                         )}
-                        href={linearIssue.url}
+                        href={jiraIssue.url}
                       >
                         <ExternalLink className="size-3" />
                       </MetadataActionIcon>
-                    )}
-                  </>
-                }
-              />
-              <WorktreeCardDetailSectionContent className="space-y-1.5">
-                <div className="text-[13px] font-semibold leading-snug text-foreground break-words">
-                  {linearIssue.title}
-                </div>
-                {((linearIssue.labels && linearIssue.labels.length > 0) ||
-                  linearIssue.stateName) && (
-                  <div className="flex flex-wrap gap-1">
-                    {linearIssue.stateName && (
-                      <LinearStateBadge stateName={linearIssue.stateName} />
-                    )}
-                    {(linearIssue.labels ?? []).map((label) => (
-                      <Badge key={label} variant="outline" className="h-4 px-1.5 text-[9px]">
-                        {label}
-                      </Badge>
-                    ))}
-                  </div>
-                )}
-              </WorktreeCardDetailSectionContent>
-            </WorktreeCardDetailSection>
-          )}
+                    }
+                  />
+                  <WorktreeCardDetailSectionContent>
+                    <div className="text-[13px] font-semibold leading-snug text-foreground break-words">
+                      {jiraIssue.title}
+                    </div>
+                  </WorktreeCardDetailSectionContent>
+                </WorktreeCardDetailSection>
+              )}
 
-          {jiraIssue && (
-            <WorktreeCardDetailSection>
-              <DetailHeader
-                icon={<JiraIcon className="size-3 text-muted-foreground" />}
-                label={translate(
-                  'auto.components.sidebar.WorktreeCardMeta.jiraIssue',
-                  'Jira {{value0}}',
-                  { value0: jiraIssue.identifier }
-                )}
-                actions={
-                  <MetadataActionIcon
-                    label={translate(
-                      'auto.components.sidebar.WorktreeCardMeta.viewOnJira',
-                      'View on Jira'
-                    )}
-                    href={jiraIssue.url}
-                  >
-                    <ExternalLink className="size-3" />
-                  </MetadataActionIcon>
+              <WorktreeCardReviewDetailSection
+                review={review}
+                reviewMenuOpen={reviewMenuOpen}
+                onReviewMenuOpenChange={handleReviewMenuOpenChange}
+                onOpenReviewInOrca={onOpenReviewInOrca}
+                onOpenReviewInBrowser={
+                  onOpenReviewInBrowser && review?.url ? onOpenReviewInBrowser : undefined
                 }
+                onCopyReviewLink={review?.url ? handleCopyReviewLink : undefined}
+                onUnlinkReview={onUnlinkReview}
+                closeHover={closeHover}
               />
-              <WorktreeCardDetailSectionContent>
-                <div className="text-[13px] font-semibold leading-snug text-foreground break-words">
-                  {jiraIssue.title}
-                </div>
-              </WorktreeCardDetailSectionContent>
-            </WorktreeCardDetailSection>
-          )}
-
-          <WorktreeCardReviewDetailSection
+            </>
+          ) : null}
+          <WorktreeCardLinkedItemsSection
+            workspace={workspace}
+            referenceDetails={referenceDetails}
             review={review}
-            reviewMenuOpen={reviewMenuOpen}
-            onReviewMenuOpenChange={handleReviewMenuOpenChange}
-            onOpenReviewInOrca={onOpenReviewInOrca}
-            onOpenReviewInBrowser={
-              onOpenReviewInBrowser && review?.url ? onOpenReviewInBrowser : undefined
-            }
-            onCopyReviewLink={review?.url ? handleCopyReviewLink : undefined}
-            onUnlinkReview={onUnlinkReview}
-            closeHover={closeHover}
+            issue={issue}
+            linearIssue={linearIssue}
+            jiraIssue={jiraIssue}
+            showItems={showAttachmentCollection}
+            onManage={onManageLinks ? dismissAndRun(onManageLinks) : undefined}
+            onOpen={(url) => {
+              closeHover()
+              void window.api.shell.openUrl(url)
+            }}
           />
 
           {automationProvenance && (
diff --git a/src/renderer/src/components/sidebar/WorktreeCardMetaBadges.tsx b/src/renderer/src/components/sidebar/WorktreeCardMetaBadges.tsx
index 634bc59d126f..4b2bb876d182 100644
--- a/src/renderer/src/components/sidebar/WorktreeCardMetaBadges.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCardMetaBadges.tsx
@@ -1,5 +1,5 @@
 import React from 'react'
-import { CalendarClock, CircleDot, SquareTerminal, StickyNote } from 'lucide-react'
+import { CalendarClock, CircleDot, Link2, SquareTerminal, StickyNote } from 'lucide-react'
 import { cn } from '@/lib/utils'
 import { LinearIcon } from '@/components/icons/LinearIcon'
 import { JiraIcon } from '@/components/icons/JiraIcon'
@@ -10,12 +10,14 @@ import type {
   WorktreeCardMetaBadgesRootProps
 } from './worktree-card-meta-types'
 import { translate } from '@/i18n/i18n'
+import { WorktreeReferenceStack } from './WorktreeReferenceStack'
 
 function hasComment(comment: string | null): boolean {
   return (comment ?? '').trim().length > 0
 }
 
 export function hasWorktreeCardDetails({
+  linkedItemCount = 0,
   issue,
   linearIssue,
   jiraIssue,
@@ -25,6 +27,7 @@ export function hasWorktreeCardDetails({
   cliProvenance
 }: WorktreeCardMetaBadgesProps): boolean {
   return Boolean(
+    linkedItemCount > 0 ||
     issue ||
     linearIssue ||
     jiraIssue ||
@@ -40,6 +43,9 @@ export const WorktreeCardMetaBadges = React.forwardRef<
   WorktreeCardMetaBadgesRootProps
 >(function WorktreeCardMetaBadges(
   {
+    linkedItemCount = 0,
+    referenceItems,
+    referenceDetails,
     issue,
     linearIssue,
     jiraIssue,
@@ -54,6 +60,7 @@ export const WorktreeCardMetaBadges = React.forwardRef<
 ): React.JSX.Element | null {
   if (
     !hasWorktreeCardDetails({
+      linkedItemCount,
       issue,
       linearIssue,
       jiraIssue,
@@ -66,6 +73,14 @@ export const WorktreeCardMetaBadges = React.forwardRef<
     return null
   }
 
+  const reviewItems = referenceItems?.filter((item) => item.type !== 'issue') ?? []
+  const linearItems = referenceItems?.filter((item) => item.provider === 'linear') ?? []
+  const jiraItems = referenceItems?.filter((item) => item.provider === 'jira') ?? []
+  const issueItems =
+    referenceItems?.filter(
+      (item) => item.type === 'issue' && item.provider !== 'linear' && item.provider !== 'jira'
+    ) ?? []
+
   return (
     // Why: Radix HoverCardTrigger uses `asChild`, so this group must forward
     // trigger props/ref to the actual DOM node for attachment-only hover.
@@ -78,6 +93,20 @@ export const WorktreeCardMetaBadges = React.forwardRef<
         'Workspace metadata'
       )}
     >
+      {linkedItemCount > 0 &&
+      !referenceItems?.length &&
+      !issue &&
+      !linearIssue &&
+      !jiraIssue &&
+      !review ? (
+        <MetaIconBadge
+          label={translate('workspace.links.show', 'Show {{count}} linked reviews and tasks', {
+            count: linkedItemCount
+          })}
+        >
+          <Link2 />
+        </MetaIconBadge>
+      ) : null}
       {hasComment(comment) && (
         <MetaIconBadge
           label={translate(
@@ -108,40 +137,58 @@ export const WorktreeCardMetaBadges = React.forwardRef<
           <SquareTerminal className="text-muted-foreground" />
         </MetaIconBadge>
       )}
-      {issue && (
-        <MetaIconBadge
-          label={translate(
-            'auto.components.sidebar.WorktreeCardMeta.3f2649eeb8',
-            'Linked issue #{{value0}}',
-            { value0: issue.number }
-          )}
-        >
-          <CircleDot className="text-muted-foreground" />
-        </MetaIconBadge>
+      {issueItems.length ? (
+        <WorktreeReferenceStack items={issueItems} details={referenceDetails} />
+      ) : (
+        issue && (
+          <MetaIconBadge
+            label={translate(
+              'auto.components.sidebar.WorktreeCardMeta.3f2649eeb8',
+              'Linked issue #{{value0}}',
+              { value0: issue.number }
+            )}
+          >
+            <CircleDot className="text-muted-foreground" />
+          </MetaIconBadge>
+        )
       )}
-      {linearIssue && (
-        <MetaIconBadge
-          label={translate(
-            'auto.components.sidebar.WorktreeCardMeta.b105fd3057',
-            'Linked Linear {{value0}}',
-            { value0: linearIssue.identifier }
-          )}
-        >
-          <LinearIcon className="text-muted-foreground" />
-        </MetaIconBadge>
+      {jiraItems.length ? (
+        <WorktreeReferenceStack items={jiraItems} details={referenceDetails} />
+      ) : (
+        jiraIssue && (
+          <MetaIconBadge
+            label={translate(
+              'auto.components.sidebar.WorktreeCardMeta.linkedJira',
+              'Linked Jira {{value0}}',
+              { value0: jiraIssue.identifier }
+            )}
+          >
+            <JiraIcon className="text-muted-foreground" />
+          </MetaIconBadge>
+        )
       )}
-      {jiraIssue && (
-        <MetaIconBadge
-          label={translate(
-            'auto.components.sidebar.WorktreeCardMeta.linkedJira',
-            'Linked Jira {{value0}}',
-            { value0: jiraIssue.identifier }
-          )}
+      {linearItems.length || reviewItems.length ? (
+        <span
+          className="inline-flex shrink-0 items-center gap-1.5"
+          data-workspace-reference-groups=""
         >
-          <JiraIcon className="text-muted-foreground" />
-        </MetaIconBadge>
+          <WorktreeReferenceStack items={linearItems} details={referenceDetails} />
+          <WorktreeReferenceStack items={reviewItems} details={referenceDetails} />
+        </span>
+      ) : (
+        linearIssue && (
+          <MetaIconBadge
+            label={translate(
+              'auto.components.sidebar.WorktreeCardMeta.b105fd3057',
+              'Linked Linear {{value0}}',
+              { value0: linearIssue.identifier }
+            )}
+          >
+            <LinearIcon className="text-muted-foreground" />
+          </MetaIconBadge>
+        )
       )}
-      {review && (
+      {!reviewItems.length && review && (
         <MetaIconBadge
           label={translate(
             'auto.components.sidebar.WorktreeCardMeta.3ea2702e62',
diff --git a/src/renderer/src/components/sidebar/WorktreeCardMetadataStatusBadges.tsx b/src/renderer/src/components/sidebar/WorktreeCardMetadataStatusBadges.tsx
index 21b064cc323c..d9cf841fb7b0 100644
--- a/src/renderer/src/components/sidebar/WorktreeCardMetadataStatusBadges.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCardMetadataStatusBadges.tsx
@@ -58,11 +58,23 @@ export function IssueStateBadge({ state }: { state: IssueInfo['state'] }): React
   )
 }
 
-export function LinearStateBadge({ stateName }: { stateName: string }): React.JSX.Element {
+export function LinearStateBadge({
+  stateName,
+  stateType
+}: {
+  stateName: string
+  stateType?: string
+}): React.JSX.Element {
   const normalized = stateName.toLowerCase()
-  const done = /done|closed|complete|completed|merged|resolved/.test(normalized)
-  const cancelled = /cancel|canceled|duplicate|wontfix/.test(normalized)
-  const active = /progress|doing|started|active/.test(normalized)
+  const done = stateType
+    ? stateType === 'completed'
+    : /done|closed|complete|completed|merged|resolved/.test(normalized)
+  const cancelled = stateType
+    ? stateType === 'canceled'
+    : /cancel|canceled|duplicate|wontfix/.test(normalized)
+  const active = stateType
+    ? stateType === 'started'
+    : /progress|doing|started|active/.test(normalized)
   const Icon = done ? CircleCheck : cancelled ? CircleX : active ? Clock : CircleDot
   const tone = done
     ? 'border-purple-500/25 bg-purple-500/5 text-purple-600 dark:text-purple-300'
diff --git a/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.test.tsx b/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.test.tsx
index f8fc458a5dd8..dbdda9d713aa 100644
--- a/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.test.tsx
@@ -3,6 +3,9 @@ import type { ReactNode } from 'react'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { WorktreeCardStatusSlot } from './WorktreeCardStatusSlot'
 import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
+import { summarizeWorkspaceReviewChecks } from '../../../../shared/workspace-review-checks'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { referenceAttachment, referenceReview } from './workspace-reference-fixtures.test-support'
 
 const mocks = vi.hoisted(() => ({
   status: 'active',
@@ -46,6 +49,79 @@ describe('WorktreeCardStatusSlot', () => {
     status: 'pending'
   }
 
+  it('uses checks from every attached review rather than the legacy passing review', () => {
+    const items = [referenceAttachment(1), referenceAttachment(2)]
+    const details = Object.fromEntries(
+      items.map((item) => [
+        getWorkspaceAttachmentKey(item),
+        {
+          review: referenceReview(item.number, {
+            status: item.number === 1 ? 'success' : 'failure'
+          })
+        }
+      ])
+    )
+    const markup = renderToStaticMarkup(
+      <WorktreeCardStatusSlot
+        worktreeId="wt-1"
+        showStatus
+        showUnreadAction={false}
+        isUnread={false}
+        unreadTooltip=""
+        onPointerDown={vi.fn()}
+        onToggleUnread={vi.fn()}
+        newCardStyle
+        prDisplay={{ ...review, status: 'success' }}
+        reviewChecks={summarizeWorkspaceReviewChecks(items, details)}
+      />
+    )
+    expect(markup).toContain('Reviews: 2 · Checks: Failed')
+    expect(markup).toContain('text-rose-500/85')
+    expect(markup).not.toContain('checks: Passing')
+  })
+  it('keeps incomplete collection checks neutral instead of claiming passing', () => {
+    const items = [referenceAttachment(1), referenceAttachment(2)]
+    const markup = renderToStaticMarkup(
+      <WorktreeCardStatusSlot
+        worktreeId="wt-1"
+        showStatus
+        showUnreadAction={false}
+        isUnread={false}
+        unreadTooltip=""
+        onPointerDown={vi.fn()}
+        onToggleUnread={vi.fn()}
+        newCardStyle
+        prDisplay={{ ...review, status: 'success' }}
+        reviewChecks={summarizeWorkspaceReviewChecks(items, {})}
+      />
+    )
+    expect(markup).toContain('Reviews: 2 · Checks: Unknown')
+    expect(markup).toContain('text-muted-foreground')
+    expect(markup).not.toContain('text-emerald-500')
+  })
+  it.each([{ items: [] }, { items: [referenceAttachment(1)] }])(
+    'preserves discovered and singleton review lifecycle glyphs',
+    ({ items }) => {
+      const markup = renderToStaticMarkup(
+        <WorktreeCardStatusSlot
+          worktreeId="wt-1"
+          showStatus
+          showUnreadAction={false}
+          isUnread={false}
+          unreadTooltip=""
+          onPointerDown={vi.fn()}
+          onToggleUnread={vi.fn()}
+          newCardStyle
+          prDisplay={{ ...review, state: 'draft' }}
+          reviewChecks={summarizeWorkspaceReviewChecks(items, {})}
+        />
+      )
+      expect(markup).toContain('PR: Draft')
+      expect(markup).toContain('lucide-git-pull-request-draft')
+      expect(markup).not.toContain('Reviews:')
+    }
+  )
+
   it('lets the unread bell replace the visual status dot by default', () => {
     const markup = renderToStaticMarkup(
       <WorktreeCardStatusSlot
diff --git a/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.tsx b/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.tsx
index aaceddad4641..e7734a23cc86 100644
--- a/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeCardStatusSlot.tsx
@@ -10,6 +10,11 @@ import { useWorktreeActivityStatus } from './use-worktree-activity-status'
 import { useIsSleepingWorktree } from './use-worktree-sleep-state'
 import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
 import { getReviewLabel, ReviewIcon } from './worktree-review-helpers'
+import type { WorkspaceReviewChecksSummary } from '../../../../shared/workspace-review-checks'
+import {
+  WorkspaceReviewChecksIndicator,
+  workspaceReviewChecksLabel
+} from './WorkspaceReviewChecksIndicator'
 
 type WorktreeCardStatusSlotProps = {
   worktreeId: string
@@ -20,6 +25,7 @@ type WorktreeCardStatusSlotProps = {
   onToggleUnread: React.MouseEventHandler<HTMLButtonElement>
   onPointerDown: React.PointerEventHandler<HTMLButtonElement>
   prDisplay?: WorktreeCardPrDisplay | null
+  reviewChecks?: WorkspaceReviewChecksSummary
   newCardStyle?: boolean
   hasBranchIdentity?: boolean
   branchIdentityLabel?: string
@@ -102,11 +108,13 @@ export function WorktreeCardStatusSlot({
   onToggleUnread,
   onPointerDown,
   prDisplay = null,
+  reviewChecks,
   newCardStyle = false,
   hasBranchIdentity = false,
   branchIdentityLabel,
   className
 }: WorktreeCardStatusSlotProps): React.JSX.Element | null {
+  const collectionChecks = reviewChecks && reviewChecks.total > 1 ? reviewChecks : undefined
   const status = useWorktreeActivityStatus(worktreeId)
   const isSleeping = useIsSleepingWorktree(worktreeId)
   const statusLabel = getWorktreeStatusLabel(status) || status
@@ -118,7 +126,7 @@ export function WorktreeCardStatusSlot({
   const canShowReviewStatus =
     newCardStyle &&
     showStatus &&
-    prDisplay !== null &&
+    (prDisplay !== null || Boolean(collectionChecks)) &&
     !canShowSleepingStatus &&
     QUIET_REVIEW_REPLACEABLE_STATUSES.has(status)
   const canShowBranchStatus =
@@ -126,15 +134,18 @@ export function WorktreeCardStatusSlot({
     showStatus &&
     hasBranchIdentity &&
     prDisplay === null &&
+    !collectionChecks &&
     !canShowSleepingStatus &&
     QUIET_REVIEW_REPLACEABLE_STATUSES.has(status)
   const passiveStatusLabel = canShowSleepingStatus
     ? getSleepingStatusLabel()
-    : canShowReviewStatus && prDisplay
-      ? getReviewStatusLabel(prDisplay)
-      : canShowBranchStatus
-        ? (branchIdentityLabel ?? getDefaultBranchIdentityLabel())
-        : statusLabel
+    : canShowReviewStatus && collectionChecks
+      ? workspaceReviewChecksLabel(collectionChecks)
+      : canShowReviewStatus && prDisplay
+        ? getReviewStatusLabel(prDisplay)
+        : canShowBranchStatus
+          ? (branchIdentityLabel ?? getDefaultBranchIdentityLabel())
+          : statusLabel
   const passiveStatusAnnouncement =
     newCardStyle && isUnread ? `${passiveStatusLabel} · Unread` : passiveStatusLabel
   // Why: working and permission already own the new-card status lane, but
@@ -149,9 +160,16 @@ export function WorktreeCardStatusSlot({
       {sleepingStatusIcon}
       <span className="sr-only">{passiveStatusAnnouncement}</span>
     </span>
-  ) : canShowReviewStatus && prDisplay ? (
+  ) : canShowReviewStatus && (collectionChecks || prDisplay) ? (
     <span className={cn('inline-flex size-5 items-center justify-center p-0.5', className)}>
-      <ReviewIcon review={prDisplay} className={reviewStatusIconClassName} variant="generic" />
+      {collectionChecks ? (
+        <WorkspaceReviewChecksIndicator
+          summary={collectionChecks}
+          className={reviewStatusIconClassName}
+        />
+      ) : prDisplay ? (
+        <ReviewIcon review={prDisplay} className={reviewStatusIconClassName} variant="generic" />
+      ) : null}
       <span className="sr-only">{passiveStatusAnnouncement}</span>
     </span>
   ) : canShowBranchStatus ? (
diff --git a/src/renderer/src/components/sidebar/WorktreeDisplayNameField.tsx b/src/renderer/src/components/sidebar/WorktreeDisplayNameField.tsx
index 715c9976e178..381c951c2b6d 100644
--- a/src/renderer/src/components/sidebar/WorktreeDisplayNameField.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeDisplayNameField.tsx
@@ -68,10 +68,10 @@ export function WorktreeDisplayNameField({
         portalContainer={portalContainer}
         side="bottom"
       />
-      <p className="text-[10px] text-muted-foreground">
+      <p className="text-xs text-muted-foreground">
         {translate(
-          'auto.components.sidebar.WorktreeMetaDialog.459ad7f650',
-          'Only changes the name shown in the sidebar — the folder on disk stays the same. Leave blank to use the branch or folder name.'
+          'workspace.links.nameHelp',
+          'Shown in the sidebar. The folder name stays the same.'
         )}
       </p>
     </div>
diff --git a/src/renderer/src/components/sidebar/WorktreeIssueLinkField.tsx b/src/renderer/src/components/sidebar/WorktreeIssueLinkField.tsx
deleted file mode 100644
index 6a7306d01007..000000000000
--- a/src/renderer/src/components/sidebar/WorktreeIssueLinkField.tsx
+++ /dev/null
@@ -1,260 +0,0 @@
-import React, { useCallback, useId, useMemo } from 'react'
-import { Button } from '@/components/ui/button'
-import { Input } from '@/components/ui/input'
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuRadioGroup,
-  DropdownMenuRadioItem,
-  DropdownMenuTrigger
-} from '@/components/ui/dropdown-menu'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
-import { LinearIcon } from '@/components/icons/LinearIcon'
-import { ChevronDown, ExternalLink, Github, LoaderCircle } from 'lucide-react'
-import { cn } from '@/lib/utils'
-import { translate } from '@/i18n/i18n'
-import {
-  ISSUE_LINK_PROVIDERS,
-  isIssueLinkProvider,
-  type IssueLinkProvider
-} from '../../../../shared/issue-link-input'
-
-// Why: the value must clear the chip and the open-issue button that float over
-// the input's right edge. Provider labels are localized, so the text share is
-// measured in `ch` rather than baked into a Tailwind `pr-*` step that a longer
-// translation would overlap.
-const ADORNMENT_RESERVE_PX = 70
-const MAX_RESERVE = '55%'
-
-/** Exported for test: happy-dom drops `min()`, so this cannot be read back off a style. */
-export function issueAdornmentReserve(providerLabel: string): string {
-  return `min(calc(${ADORNMENT_RESERVE_PX}px + ${providerLabel.length}ch), ${MAX_RESERVE})`
-}
-
-function providerLabel(provider: IssueLinkProvider): string {
-  return provider === 'linear'
-    ? translate('auto.components.sidebar.WorktreeIssueLinkField.25852bfc59', 'Linear')
-    : translate('auto.components.sidebar.WorktreeIssueLinkField.5b440069e6', 'GitHub')
-}
-
-function ProviderIcon({
-  provider,
-  className
-}: {
-  provider: IssueLinkProvider
-  className?: string
-}): React.JSX.Element {
-  return provider === 'linear' ? (
-    <LinearIcon className={className} />
-  ) : (
-    <Github className={className} />
-  )
-}
-
-export type WorktreeIssueLinkFieldProps = {
-  inputRef: React.RefObject<HTMLInputElement | null>
-  value: string
-  provider: IssueLinkProvider
-  /** Set when the current value cannot be saved, so the row can explain why. */
-  isInvalid: boolean
-  /** Names the links this save would drop; both slots can be filled at once. */
-  displacedLinkLabels: string[] | null
-  /** Folder workspaces have no persisted link slots — see the design doc. */
-  isReadOnly: boolean
-  canOpenIssue: boolean
-  openingIssue: boolean
-  /** The last open attempt resolved to nothing — see useWorktreeIssueLink. */
-  openIssueFailed: boolean
-  onValueChange: (value: string) => void
-  onProviderChange: (provider: IssueLinkProvider) => void
-  onOpenIssue: () => void
-  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void
-}
-
-export function WorktreeIssueLinkField(props: WorktreeIssueLinkFieldProps): React.JSX.Element {
-  const {
-    inputRef,
-    value,
-    provider,
-    isInvalid,
-    displacedLinkLabels,
-    isReadOnly,
-    canOpenIssue,
-    openingIssue,
-    openIssueFailed,
-    onValueChange,
-    onProviderChange,
-    onOpenIssue,
-    onKeyDown
-  } = props
-
-  // Why: the helper `<p>` is the only surface for the invalid and displacement
-  // states, so it has to be announced with the field rather than just seen.
-  const helperId = useId()
-  const inputId = useId()
-  const label = providerLabel(provider)
-  const openIssueLabel = translate(
-    'auto.components.sidebar.WorktreeIssueLinkField.161b2d053a',
-    'Open linked issue'
-  )
-
-  const handleProviderChange = useCallback(
-    (next: string) => {
-      if (isIssueLinkProvider(next)) {
-        onProviderChange(next)
-      }
-    },
-    [onProviderChange]
-  )
-
-  const helperText = useMemo(() => {
-    if (isReadOnly) {
-      return translate(
-        'auto.components.sidebar.WorktreeIssueLinkField.d4785f9954',
-        "Issue links are set when a folder workspace is created and can't be changed here yet."
-      )
-    }
-    if (isInvalid) {
-      return provider === 'linear'
-        ? translate(
-            'auto.components.sidebar.WorktreeIssueLinkField.964d9bc00a',
-            'Not a Linear issue key or linear.app issue URL.'
-          )
-        : translate(
-            'auto.components.sidebar.WorktreeIssueLinkField.0a7a2c6efd',
-            'Not a GitHub issue number or issue URL.'
-          )
-    }
-    // Why: ranked above displacement because it answers the click the user just
-    // made, and it clears as soon as they edit the value that caused it.
-    if (openIssueFailed) {
-      return provider === 'linear'
-        ? translate(
-            'auto.components.sidebar.WorktreeIssueLinkField.d8c8a30d1f',
-            "Couldn't open that issue. Check the identifier and your Linear connection."
-          )
-        : translate(
-            'auto.components.sidebar.WorktreeIssueLinkField.269198eeda',
-            "Couldn't open that issue. Check the number and your GitHub connection."
-          )
-    }
-    // Whole sentences per arity rather than a joined list: a translated " and "
-    // fragment would not survive languages that order or punctuate lists differently.
-    if (displacedLinkLabels && displacedLinkLabels.length > 1) {
-      return translate(
-        'auto.components.sidebar.WorktreeIssueLinkField.72486800ff',
-        'Saving unlinks {{first}} and {{second}} — a workspace tracks one issue.',
-        { first: displacedLinkLabels[0], second: displacedLinkLabels[1] }
-      )
-    }
-    if (displacedLinkLabels?.length) {
-      return translate(
-        'auto.components.sidebar.WorktreeIssueLinkField.2c245ac134',
-        'Saving unlinks {{link}} — a workspace tracks one issue.',
-        { link: displacedLinkLabels[0] }
-      )
-    }
-    return translate(
-      'auto.components.sidebar.WorktreeIssueLinkField.f047887705',
-      'Paste a GitHub or Linear URL, or enter a number. Leave blank to remove the link.'
-    )
-  }, [displacedLinkLabels, isInvalid, isReadOnly, openIssueFailed, provider])
-
-  return (
-    <div className="space-y-1">
-      <label htmlFor={inputId} className="text-[11px] font-medium text-muted-foreground">
-        {translate('auto.components.sidebar.WorktreeIssueLinkField.ad78f9bee2', 'Issue')}
-      </label>
-      <div className="relative">
-        <Input
-          ref={inputRef}
-          id={inputId}
-          aria-describedby={helperId}
-          value={value}
-          onChange={(e) => onValueChange(e.target.value)}
-          onKeyDown={onKeyDown}
-          disabled={isReadOnly}
-          aria-invalid={isInvalid || undefined}
-          placeholder={translate(
-            'auto.components.sidebar.WorktreeIssueLinkField.662ae142f8',
-            'Issue #, or a GitHub or Linear URL'
-          )}
-          className="h-8 text-xs"
-          style={{ paddingRight: issueAdornmentReserve(label) }}
-        />
-        <div className="absolute right-1 top-1 flex items-center gap-0.5">
-          {/* Why: `modal` would stack a second scroll-lock layer over the
-              Dialog's, whose nested teardown strands pointer-events on body. */}
-          <DropdownMenu modal={false}>
-            <DropdownMenuTrigger asChild>
-              <Button
-                type="button"
-                variant="ghost"
-                size="xs"
-                disabled={isReadOnly}
-                aria-label={translate(
-                  'auto.components.sidebar.WorktreeIssueLinkField.929c98d05a',
-                  'Issue provider'
-                )}
-                className="h-6 px-1 text-[10px] font-medium text-muted-foreground"
-              >
-                <ProviderIcon provider={provider} className="size-3" />
-                {label}
-                <ChevronDown className="size-2.5 opacity-60" />
-              </Button>
-            </DropdownMenuTrigger>
-            <DropdownMenuContent align="end" className="min-w-32">
-              <DropdownMenuRadioGroup value={provider} onValueChange={handleProviderChange}>
-                {ISSUE_LINK_PROVIDERS.map((item) => (
-                  <DropdownMenuRadioItem key={item} value={item} className="text-xs">
-                    <ProviderIcon provider={item} className="size-3" />
-                    {providerLabel(item)}
-                  </DropdownMenuRadioItem>
-                ))}
-              </DropdownMenuRadioGroup>
-            </DropdownMenuContent>
-          </DropdownMenu>
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <Button
-                type="button"
-                variant="ghost"
-                size="icon-xs"
-                aria-label={openIssueLabel}
-                disabled={!canOpenIssue || openingIssue}
-                onClick={onOpenIssue}
-                className="text-muted-foreground"
-              >
-                {openingIssue ? (
-                  <LoaderCircle className="size-3 animate-spin" />
-                ) : (
-                  <ExternalLink className="size-3" />
-                )}
-              </Button>
-            </TooltipTrigger>
-            <TooltipContent side="top" sideOffset={4}>
-              {openIssueLabel}
-            </TooltipContent>
-          </Tooltip>
-        </div>
-      </div>
-      {/* Why: two lines are reserved up front. The dialog is centered by
-          transform, so a wrap-count change would shift the field being typed in. */}
-      {/* Why: the failure and displacement messages appear without focus moving
-          here, so only a live region announces them. */}
-      <p
-        id={helperId}
-        role="status"
-        aria-live="polite"
-        className={cn(
-          'min-h-[28px] text-[10px] leading-[14px]',
-          (openIssueFailed || displacedLinkLabels?.length) && !isInvalid && !isReadOnly
-            ? 'text-amber-600 dark:text-amber-400'
-            : 'text-muted-foreground'
-        )}
-      >
-        {helperText}
-      </p>
-    </div>
-  )
-}
diff --git a/src/renderer/src/components/sidebar/WorktreeLinkedItemRow.tsx b/src/renderer/src/components/sidebar/WorktreeLinkedItemRow.tsx
new file mode 100644
index 000000000000..a7a595c3d6e7
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeLinkedItemRow.tsx
@@ -0,0 +1,135 @@
+import React from 'react'
+import { ExternalLink, GitPullRequest, Terminal, Ticket, X } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '@/components/ui/collapsible'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { translate } from '@/i18n/i18n'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import { WorkspaceAttachmentOrigins } from './WorkspaceAttachmentOrigins'
+import {
+  workspaceAttachmentLabel,
+  workspaceAttachmentProviderLabel
+} from './worktree-attachment-editing'
+import { getWorkspaceAttachmentSourceLabel } from './workspace-attachment-source-label'
+
+type Props = {
+  item: WorkspaceAttachment
+  workspace?: Worktree
+  disabled: boolean
+  onRemove: () => void
+}
+
+export function WorktreeLinkedItemRow({
+  item,
+  workspace,
+  disabled,
+  onRemove
+}: Props): React.JSX.Element {
+  const label = workspaceAttachmentLabel(item)
+  const source = getWorkspaceAttachmentSourceLabel(item)
+  const provider = workspaceAttachmentProviderLabel(item)
+  const observedCount = item.origins?.filter((origin) => origin.kind === 'observed').length ?? 0
+  const sessionsLabel = translate('workspace.links.sessions', 'Sessions & terminals')
+  return (
+    <Collapsible
+      data-workspace-linked-item=""
+      onKeyDown={(event) => {
+        if (event.key === 'Enter' && !event.metaKey && !event.ctrlKey) {
+          event.stopPropagation()
+        }
+      }}
+    >
+      <div className="flex min-h-8 min-w-0 items-center gap-1 py-1">
+        {item.type === 'issue' ? (
+          <Ticket className="size-3.5 shrink-0 text-muted-foreground" />
+        ) : (
+          <GitPullRequest className="size-3.5 shrink-0 text-muted-foreground" />
+        )}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <div className="flex min-w-0 flex-1 items-baseline gap-2 text-xs">
+              <span className="shrink-0 font-medium">{label}</span>
+              {item.title ? (
+                <span className="truncate text-muted-foreground">{item.title}</span>
+              ) : null}
+              <span className="sr-only">
+                {provider}
+                {source ? ` · ${source}` : ''}
+              </span>
+            </div>
+          </TooltipTrigger>
+          <TooltipContent className="max-w-sm">
+            <p>{item.title || label}</p>
+            <p>
+              {label} · {provider}
+              {source ? ` · ${source}` : ''}
+            </p>
+          </TooltipContent>
+        </Tooltip>
+        {workspace && observedCount > 0 ? (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <CollapsibleTrigger asChild>
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="xs"
+                  disabled={disabled}
+                  aria-label={translate(
+                    'workspace.links.sessionsForItem',
+                    'Sessions & terminals for {{label}} · {{count}}',
+                    { label, count: observedCount }
+                  )}
+                >
+                  <Terminal className="size-3" />
+                  <span>{observedCount}</span>
+                </Button>
+              </CollapsibleTrigger>
+            </TooltipTrigger>
+            <TooltipContent>{sessionsLabel}</TooltipContent>
+          </Tooltip>
+        ) : null}
+        {item.url ? (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Button
+                type="button"
+                variant="ghost"
+                size="icon-xs"
+                aria-label={translate('workspace.links.openItem', 'Open {{label}}', { label })}
+                onClick={() => void window.api.shell.openUrl(item.url ?? '')}
+              >
+                <ExternalLink className="size-3" />
+              </Button>
+            </TooltipTrigger>
+            <TooltipContent>{translate('workspace.links.open', 'Open link')}</TooltipContent>
+          </Tooltip>
+        ) : null}
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Button
+              type="button"
+              variant="ghost"
+              size="icon-xs"
+              disabled={disabled}
+              aria-label={translate('workspace.links.unlinkItem', 'Unlink {{label}}', { label })}
+              onClick={onRemove}
+            >
+              <X className="size-3" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>
+            {translate('workspace.links.unlink', 'Unlink from workspace')}
+          </TooltipContent>
+        </Tooltip>
+      </div>
+      {workspace && observedCount > 0 ? (
+        <CollapsibleContent>
+          <div className="text-xs">
+            <WorkspaceAttachmentOrigins item={item} workspace={workspace} />
+          </div>
+        </CollapsibleContent>
+      ) : null}
+    </Collapsible>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorktreeLinkedItemsField.tsx b/src/renderer/src/components/sidebar/WorktreeLinkedItemsField.tsx
new file mode 100644
index 000000000000..f8a5cb74d606
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeLinkedItemsField.tsx
@@ -0,0 +1,173 @@
+import { WorktreeLinkedItemRow } from './WorktreeLinkedItemRow'
+import { translate } from '@/i18n/i18n'
+import React, { useState } from 'react'
+import { Link2 } from 'lucide-react'
+import { Label } from '@/components/ui/label'
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import {
+  canUseWorkspaceReviewForChecks,
+  isWorkspaceRepositoryAttachment,
+  type AttachmentInputKind
+} from './worktree-attachment-editing'
+import { WorkspaceAttachmentComposer } from './WorkspaceAttachmentComposer'
+import {
+  appendWorkspaceAttachment,
+  isWorkspaceAttachmentLinked
+} from './workspace-attachment-source-result'
+
+type Props = {
+  items: readonly WorkspaceAttachment[]
+  onItemsChange: (items: WorkspaceAttachment[]) => void
+  onSave: () => void
+  repo?: Repo
+  workspace?: Worktree
+  isFolderWorkspace?: boolean
+  inputRef: React.RefObject<HTMLInputElement | null>
+  initialKind: AttachmentInputKind
+  initialInput?: string
+  disabled: boolean
+}
+
+export function WorktreeLinkedItemsField({
+  items,
+  onItemsChange,
+  onSave,
+  repo,
+  workspace,
+  isFolderWorkspace = false,
+  inputRef,
+  initialKind,
+  initialInput = '',
+  disabled
+}: Props): React.JSX.Element {
+  const [error, setError] = useState<string | null>(null)
+  const getScopeError = (item: WorkspaceAttachment): string | null => {
+    if (
+      !isFolderWorkspace &&
+      item.type !== 'issue' &&
+      !item.url &&
+      !canUseWorkspaceReviewForChecks(item, repo)
+    ) {
+      return translate(
+        'workspace.links.reviewUrlRequired',
+        'Paste the review URL to verify its repository and provider.'
+      )
+    }
+    if (
+      !item.url ||
+      (item.type === 'issue' && item.provider !== 'github' && item.provider !== 'gitlab') ||
+      isFolderWorkspace ||
+      isWorkspaceRepositoryAttachment(item, repo)
+    ) {
+      return null
+    }
+    if (!repo?.gitRemoteIdentity) {
+      return translate(
+        'workspace.links.repositoryLoading',
+        'Repository identity is still loading. Try again once it is available.'
+      )
+    }
+    return item.type === 'issue'
+      ? translate(
+          'workspace.links.foreignIssue',
+          'This issue belongs to another repository. Add issues from this workspace’s repository.'
+        )
+      : translate(
+          'workspace.links.foreignReview',
+          'This review belongs to another repository. Add reviews from this workspace’s repository.'
+        )
+  }
+  const add = (item: WorkspaceAttachment): boolean => {
+    if (disabled) {
+      return false
+    }
+    const scopeError = getScopeError(item)
+    if (scopeError) {
+      setError(scopeError)
+      return false
+    }
+    if (isWorkspaceAttachmentLinked(items, item)) {
+      setError(translate('workspace.links.duplicate', 'This link is already attached.'))
+      return false
+    }
+    onItemsChange(appendWorkspaceAttachment(items, item))
+    setError(null)
+    return true
+  }
+  const remove = (key: string): void => {
+    const next = items.filter((item) => getWorkspaceAttachmentKey(item) !== key)
+    onItemsChange(next)
+  }
+  const groups = [
+    {
+      label: translate('workspace.links.reviews', 'Reviews'),
+      items: items.filter((item) => item.type !== 'issue')
+    },
+    {
+      label: translate('workspace.links.tasks', 'Issues & tasks'),
+      items: items.filter((item) => item.type === 'issue')
+    }
+  ].filter((group) => group.items.length > 0)
+
+  return (
+    <div className="space-y-3" data-workspace-linked-items="">
+      <div className="flex items-center justify-between gap-2">
+        <Label>{translate('workspace.links.title', 'Linked work')}</Label>
+        <span className="text-xs text-muted-foreground">
+          {translate('workspace.links.count', '{{count}} linked', { count: items.length })}
+        </span>
+      </div>
+      <WorkspaceAttachmentComposer
+        items={items}
+        repo={repo}
+        workspace={workspace}
+        disabled={disabled}
+        initialKind={initialKind}
+        initialInput={initialInput}
+        inputRef={inputRef}
+        onAdd={add}
+        onSave={onSave}
+        onQueryChange={() => setError(null)}
+        getScopeError={getScopeError}
+        error={error}
+      />
+      {items.length === 0 ? (
+        <div className="flex items-center gap-2 py-2 text-xs text-muted-foreground">
+          <Link2 className="size-4 shrink-0" />
+          <span>
+            {translate(
+              'workspace.links.empty',
+              'Keep every review and task for this workspace together.'
+            )}
+          </span>
+        </div>
+      ) : (
+        <div className="space-y-3">
+          {groups.map((group) => (
+            <div key={group.label} className="space-y-1">
+              <p className="text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">
+                {group.label} · {group.items.length}
+              </p>
+              <div className="divide-y divide-border">
+                {group.items.map((item) => {
+                  const key = getWorkspaceAttachmentKey(item)
+                  return (
+                    <WorktreeLinkedItemRow
+                      key={key}
+                      item={item}
+                      workspace={workspace}
+                      disabled={disabled}
+                      onRemove={() => remove(key)}
+                    />
+                  )
+                })}
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialog.host-scope.test.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialog.host-scope.test.tsx
new file mode 100644
index 000000000000..ca67c631271b
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialog.host-scope.test.tsx
@@ -0,0 +1,155 @@
+// @vitest-environment happy-dom
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import type { Repo } from '../../../../shared/repo-types'
+import type { Worktree, WorkspaceAttachment } from '../../../../shared/worktree/types'
+import type { FolderWorkspace } from '../../../../shared/folder-workspace-types'
+import { folderWorkspaceKey } from '../../../../shared/workspace-scope'
+import WorktreeMetaDialog from './WorktreeMetaDialog'
+
+vi.mock('./WorktreeDisplayNameField', () => ({ WorktreeDisplayNameField: () => null }))
+vi.mock('./WorktreeLinkedItemsField', () => ({
+  WorktreeLinkedItemsField: ({ items, repo }: { items: WorkspaceAttachment[]; repo?: Repo }) => (
+    <div>
+      <span data-testid="owner-repo">{repo?.path ?? 'none'}</span>
+      {items.map((item) => (
+        <span key={item.number}>{item.title}</span>
+      ))}
+    </div>
+  )
+}))
+
+const initialState = useAppStore.getInitialState()
+const update = vi.fn(async () => ({ ok: true as const }))
+const localRepo: Repo = {
+  id: 'repo',
+  path: '/local',
+  displayName: 'Local',
+  badgeColor: '',
+  addedAt: 1
+}
+const remoteRepo: Repo = { ...localRepo, path: '/remote', executionHostId: 'ssh:box' }
+function workspace(hostId?: Worktree['hostId']): Worktree {
+  return {
+    id: 'shared-id',
+    repoId: 'repo',
+    path: '/workspace',
+    branch: 'feature',
+    head: 'abc',
+    isBare: false,
+    isMainWorktree: false,
+    isArchived: false,
+    isUnread: false,
+    isPinned: false,
+    sortOrder: 0,
+    lastActivityAt: 1,
+    displayName: 'Workspace',
+    comment: 'note',
+    hostId,
+    linkedPR: null,
+    linkedIssue: null,
+    linkedLinearIssue: null,
+    linkedItems: [
+      {
+        provider: 'github',
+        type: 'issue',
+        number: hostId ? 2 : 1,
+        title: hostId ? 'Remote task' : 'Local task'
+      }
+    ]
+  }
+}
+function open(
+  executionHostId: string,
+  rows: Worktree[] = [workspace(), workspace('ssh:box')],
+  repos: Repo[] = [localRepo, remoteRepo]
+): void {
+  useAppStore.setState({
+    repos,
+    worktreesByRepo: { repo: rows },
+    updateWorktreeMeta: update,
+    activeModal: 'edit-meta',
+    modalData: { worktreeId: 'shared-id', repoId: 'repo', executionHostId }
+  })
+  render(<WorktreeMetaDialog />)
+}
+
+describe('workspace details exact host selection', () => {
+  beforeEach(() => {
+    useAppStore.setState(initialState, true)
+    update.mockClear()
+  })
+  afterEach(cleanup)
+
+  it.each([
+    ['local', '/local', 'Local task', 'Remote task'],
+    ['ssh:box', '/remote', 'Remote task', 'Local task']
+  ])(
+    'seeds the %s workspace and repository with duplicate IDs',
+    async (host, path, shown, hidden) => {
+      open(host)
+      expect(screen.getByTestId('owner-repo').textContent).toBe(path)
+      expect(screen.getByText(shown)).toBeTruthy()
+      expect(screen.queryByText(hidden)).toBeNull()
+      fireEvent.click(screen.getByRole('button', { name: 'Save' }))
+      await waitFor(() =>
+        expect(update).toHaveBeenCalledWith('shared-id', {}, { executionHostId: host })
+      )
+    }
+  )
+
+  it('does not fall back to another host when the requested workspace disappeared', () => {
+    open('ssh:missing', [workspace()])
+    expect(screen.getByTestId('owner-repo').textContent).toBe('none')
+    expect(screen.queryByText('Local task')).toBeNull()
+    const save = screen.getByRole('button', { name: 'Save' })
+    expect(save.hasAttribute('disabled')).toBe(true)
+    fireEvent.click(save)
+    expect(update).not.toHaveBeenCalled()
+  })
+
+  it('uses the owning runtime repository for its nested SSH worktree alias', () => {
+    const row = { ...workspace('ssh:nested'), runtimeOwnerEnvironmentId: 'hub' }
+    open('runtime:hub', [row], [{ ...localRepo, path: '/hub', executionHostId: 'runtime:hub' }])
+    expect(screen.getByTestId('owner-repo').textContent).toBe('/hub')
+    expect(screen.getByText('Remote task')).toBeTruthy()
+  })
+
+  it('selects the host-qualified folder when folder IDs are duplicated', () => {
+    const folder: FolderWorkspace = {
+      id: 'folder',
+      projectGroupId: 'group',
+      name: 'Docs',
+      folderPath: '/docs',
+      linkedTask: null,
+      comment: '',
+      isArchived: false,
+      isUnread: false,
+      isPinned: false,
+      sortOrder: 0,
+      lastActivityAt: 1,
+      createdAt: 1,
+      updatedAt: 1,
+      linkedItems: [{ provider: 'github', type: 'issue', number: 1, title: 'Local folder task' }]
+    }
+    useAppStore.setState({
+      folderWorkspaces: [
+        folder,
+        {
+          ...folder,
+          executionHostId: 'ssh:box',
+          linkedItems: [
+            { provider: 'github', type: 'issue', number: 2, title: 'Remote folder task' }
+          ]
+        }
+      ],
+      updateWorktreeMeta: update,
+      activeModal: 'edit-meta',
+      modalData: { worktreeId: folderWorkspaceKey('folder'), executionHostId: 'ssh:box' }
+    })
+    render(<WorktreeMetaDialog />)
+    expect(screen.getByText('Remote folder task')).toBeTruthy()
+    expect(screen.queryByText('Local folder task')).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
index 1b1eeb8f81de..d6a998de3cdd 100644
--- a/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialog.test.tsx
@@ -1,82 +1,49 @@
 // @vitest-environment happy-dom
-
-import { act, type ReactNode } from 'react'
+import { act, createContext, useContext, type ReactNode } from 'react'
 import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { useAppStore } from '@/store'
-import type { FolderWorkspace } from '../../../../shared/folder-workspace-types'
-import type { LinearIssue } from '../../../../shared/linear/issue-types'
-import type { Repo } from '../../../../shared/repo-types'
+import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
+import type { Worktree } from '../../../../shared/worktree/types'
 import type { WorktreeMeta } from '../../../../shared/worktree/meta-types'
 import type { WorktreeMetaUpdateOptions } from '@/store/slices/worktree-helpers'
-import type { Worktree } from '../../../../shared/worktree/types'
+import type { FolderWorkspace } from '../../../../shared/folder-workspace-types'
 import { folderWorkspaceKey } from '../../../../shared/workspace-scope'
 
-// Why: Radix tooltips need a provider the dialog does not own, and the menu's
-// portal needs real layout. Stand-ins keep these tests on provider selection.
 vi.mock('@/components/ui/tooltip', () => ({
   Tooltip: ({ children }: { children?: ReactNode }) => <>{children}</>,
   TooltipContent: () => null,
   TooltipTrigger: ({ children }: { children?: ReactNode }) => <>{children}</>
 }))
-
-vi.mock('@/components/ui/dropdown-menu', async () => {
-  const React = await import('react')
-  const SelectContext = React.createContext<(value: string) => void>(() => {})
-  const Passthrough = ({ children }: { children?: ReactNode }) => <>{children}</>
+vi.mock('@/components/ui/dropdown-menu', () => {
+  const Selection = createContext<(value: string) => void>(() => {})
+  const Pass = ({ children }: { children?: ReactNode }) => <>{children}</>
   return {
-    DropdownMenu: Passthrough,
-    DropdownMenuTrigger: Passthrough,
-    DropdownMenuContent: Passthrough,
+    DropdownMenu: Pass,
+    DropdownMenuContent: Pass,
+    DropdownMenuTrigger: Pass,
     DropdownMenuRadioGroup: ({
-      value,
-      onValueChange,
-      children
+      children,
+      onValueChange
     }: {
-      value: string
-      onValueChange: (value: string) => void
       children?: ReactNode
-    }) => (
-      <SelectContext.Provider value={onValueChange}>
-        <div data-selected={value}>{children}</div>
-      </SelectContext.Provider>
-    ),
+      onValueChange: (value: string) => void
+    }) => <Selection.Provider value={onValueChange}>{children}</Selection.Provider>,
     DropdownMenuRadioItem: ({ value, children }: { value: string; children?: ReactNode }) => {
-      const onSelect = React.useContext(SelectContext)
+      const select = useContext(Selection)
       return (
-        <button type="button" role="menuitemradio" onClick={() => onSelect(value)}>
+        <button type="button" onClick={() => select(value)}>
           {children}
         </button>
       )
     }
   }
 })
-
+vi.mock('@/runtime/runtime-linear-client', () => ({
+  linearStatus: vi.fn(async () => ({ connected: false, viewer: null }))
+}))
 import WorktreeMetaDialog from './WorktreeMetaDialog'
 
-const REPO_ID = 'repo-1'
-const WORKTREE_ID = 'repo-1::/repo/worktrees/feature'
-
-const IME_FIELDS = [
-  {
-    placeholder: 'Notes about this worktree...',
-    value: '日本語',
-    updates: { comment: '日本語' }
-  },
-  {
-    placeholder: 'Custom display name...',
-    value: '日本語の名前',
-    updates: { displayName: '日本語の名前' }
-  },
-  {
-    placeholder: 'Issue #, or a GitHub or Linear URL',
-    value: '42',
-    updates: { linkedIssue: 42 }
-  },
-  { placeholder: 'PR # or GitHub URL', value: '43', updates: { linkedPR: 43 } },
-  { placeholder: 'MR ! or GitLab URL', value: '!44', updates: { linkedGitLabMR: 44 } }
-] as const
-
 const initialState = useAppStore.getInitialState()
 const updateWorktreeMeta =
   vi.fn<
@@ -86,26 +53,15 @@ const updateWorktreeMeta =
       options?: WorktreeMetaUpdateOptions
     ) => Promise<{ ok: true } | { ok: false; error: string }>
   >()
-const fetchLinearIssue = vi.fn<(...args: never[]) => Promise<LinearIssue | null>>()
-const openUrl = vi.fn<(url: string) => void>()
-
-/** Only `url` is read by the open-issue path. */
-function makeLinearIssue(url: string): LinearIssue {
-  return { url } as LinearIssue
-}
-
-function makeRepo(id: string = REPO_ID, path: string = '/repo'): Repo {
-  return { id, path, displayName: 'orca', badgeColor: '#999999', addedAt: 1 }
-}
-
-function makeWorktree(overrides: Partial<Worktree> = {}): Worktree {
+const openUrl = vi.fn()
+function worktree(overrides: Partial<Worktree> = {}): Worktree {
   return {
-    id: WORKTREE_ID,
-    repoId: REPO_ID,
+    id: 'repo::/repo/worktrees/feature',
+    repoId: 'repo',
     path: '/repo/worktrees/feature',
     displayName: 'Feature work',
     branch: 'feature',
-    head: 'abc123',
+    head: 'abc',
     isBare: false,
     isMainWorktree: false,
     comment: 'existing note',
@@ -120,694 +76,553 @@ function makeWorktree(overrides: Partial<Worktree> = {}): Worktree {
     ...overrides
   }
 }
-
-function makeFolderWorkspace(overrides: Partial<FolderWorkspace> = {}): FolderWorkspace {
-  return {
-    id: 'fw-1',
-    projectGroupId: 'pg-1',
-    name: 'Docs folder',
-    folderPath: '/repo/docs',
-    linkedTask: {
-      provider: 'linear',
-      type: 'issue',
-      number: 901,
-      title: 'Fix auth',
-      url: 'https://linear.app/acme/issue/STA-901',
-      linearIdentifier: 'STA-901'
-    },
-    comment: '',
-    isArchived: false,
-    isUnread: false,
-    isPinned: false,
-    sortOrder: 0,
-    lastActivityAt: 1,
-    createdAt: 1,
-    updatedAt: 1,
-    ...overrides
-  }
-}
-
 function openDialog(
-  options: {
-    worktree?: Partial<Worktree>
-    worktreeId?: string
-    folderWorkspace?: Partial<FolderWorkspace>
-    /** Extra owners of the same workspace ID, which the index reads as ambiguous. */
-    otherRepos?: { repoId: string; worktree?: Partial<Worktree> }[]
-    modalRepoId?: string
-    modalExecutionHostId?: string
-    modalReviewProvider?: 'github' | 'gitlab'
-    modalCurrentReview?: number
-    modalSuppressHostedReviewRefresh?: boolean
-    linearViewerOrganizationUrlKey?: string
-  } = {}
-): void {
-  const worktree = makeWorktree(options.worktree)
-  const otherRepos = options.otherRepos ?? []
+  overrides: Partial<Worktree> = {},
+  modal: Record<string, unknown> = {}
+): Worktree {
+  const item = worktree(overrides)
   useAppStore.setState({
-    repos: [makeRepo(), ...otherRepos.map((other) => makeRepo(other.repoId, `/${other.repoId}`))],
-    worktreesByRepo: {
-      [REPO_ID]: [worktree],
-      ...Object.fromEntries(
-        otherRepos.map((other) => [
-          other.repoId,
-          [makeWorktree({ repoId: other.repoId, ...other.worktree })]
-        ])
-      )
-    },
-    ...(options.folderWorkspace
-      ? { folderWorkspaces: [makeFolderWorkspace(options.folderWorkspace)] }
-      : {}),
-    ...(options.linearViewerOrganizationUrlKey
-      ? {
-          linearStatus: {
-            connected: true,
-            viewer: {
-              displayName: 'Viewer',
-              email: null,
-              organizationName: 'Active',
-              organizationUrlKey: options.linearViewerOrganizationUrlKey
-            }
-          }
+    repos: [
+      {
+        id: 'repo',
+        path: '/repo',
+        displayName: 'orca',
+        badgeColor: '',
+        addedAt: 1,
+        ...(overrides.hostId ? { executionHostId: overrides.hostId } : {}),
+        gitRemoteIdentity: {
+          canonicalKey: 'github.com/acme/orca',
+          remoteName: 'origin',
+          remoteUrl: 'https://github.com/acme/orca.git'
         }
-      : {}),
+      }
+    ],
+    worktreesByRepo: { repo: [item] },
     activeModal: 'edit-meta',
     modalData: {
-      worktreeId: options.worktreeId ?? worktree.id,
-      ...(options.modalRepoId ? { repoId: options.modalRepoId } : {}),
-      ...(options.modalExecutionHostId ? { executionHostId: options.modalExecutionHostId } : {}),
-      ...(options.modalReviewProvider ? { reviewProvider: options.modalReviewProvider } : {}),
-      ...(options.modalCurrentReview ? { currentReview: options.modalCurrentReview } : {}),
-      ...(options.modalSuppressHostedReviewRefresh ? { suppressHostedReviewRefresh: true } : {}),
-      currentDisplayName: worktree.displayName,
-      currentComment: worktree.comment,
-      focus: 'comment'
+      worktreeId: item.id,
+      repoId: item.repoId,
+      currentDisplayName: item.displayName,
+      currentComment: item.comment,
+      focus: 'comment',
+      ...modal
     },
-    updateWorktreeMeta,
-    fetchLinearIssue: fetchLinearIssue as unknown as ReturnType<
-      typeof useAppStore.getState
-    >['fetchLinearIssue']
+    updateWorktreeMeta
   })
   render(<WorktreeMetaDialog />)
+  return item
 }
-
-function issueInput(): HTMLInputElement {
-  return screen.getByPlaceholderText('Issue #, or a GitHub or Linear URL')
+function input(): HTMLElement {
+  const field = screen.getByRole('combobox', { name: 'Search references' })
+  act(() => field.focus())
+  return field
 }
-
-function providerChip(): HTMLButtonElement {
-  return screen.getByRole('button', { name: 'Issue provider' })
+async function add(value: string, kind?: string): Promise<void> {
+  const field = input()
+  fireEvent.change(field, { target: { value } })
+  if (kind) {
+    fireEvent.click(screen.getByRole('button', { name: kind }))
+  }
+  const command = await screen.findByRole('option', { name: /^Add (PR|Issue|MR|STA)/ })
+  await waitFor(() => expect(command.getAttribute('data-disabled')).not.toBe('true'))
+  fireEvent.click(command)
 }
-
-function saveButton(): HTMLButtonElement {
-  return screen.getByRole('button', { name: 'Save' })
+async function save(): Promise<void> {
+  fireEvent.click(screen.getByRole('button', { name: 'Save' }))
+  await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalled())
 }
 
-function openIssueButton(): HTMLButtonElement {
-  return screen.getByRole('button', { name: 'Open linked issue' })
-}
-
-describe('WorktreeMetaDialog issue link row', () => {
+describe('workspace linked work editor', () => {
   beforeEach(() => {
     useAppStore.setState(initialState, true)
-    updateWorktreeMeta.mockReset()
-    updateWorktreeMeta.mockResolvedValue({ ok: true })
-    fetchLinearIssue.mockReset()
-    fetchLinearIssue.mockResolvedValue(null)
-    openUrl.mockReset()
-    Object.defineProperty(window, 'api', {
-      configurable: true,
-      value: { shell: { openUrl } }
+    useAppStore.setState({
+      fetchWorkItems: vi.fn(async () => []),
+      getCachedWorkItems: vi.fn(() => []),
+      refreshPreflightStatus: vi.fn(async () => {}),
+      checkLinearConnection: vi.fn(async () => {}),
+      readJiraStatus: vi.fn(async () => ({ connected: false, viewer: null, sites: [] })),
+      linearStatusChecked: true
     })
+    Element.prototype.scrollIntoView = vi.fn()
+    updateWorktreeMeta.mockReset().mockResolvedValue({ ok: true })
+    openUrl.mockReset()
+    Object.defineProperty(window, 'api', { configurable: true, value: { shell: { openUrl } } })
   })
-
-  afterEach(() => {
-    cleanup()
-    vi.restoreAllMocks()
-    useAppStore.setState(initialState, true)
+  afterEach(cleanup)
+
+  it('adds multiple reviews and tasks without displacing existing links', async () => {
+    openDialog({ linkedPR: 1, linkedIssue: 2 })
+    await add('3', 'GitHub PR')
+    await add('STA-4', 'Linear task')
+    expect(screen.getByText('PR #1')).toBeTruthy()
+    expect(screen.getByText('PR #3')).toBeTruthy()
+    expect(screen.getByText('Issue #2')).toBeTruthy()
+    expect(screen.getByText('STA-4')).toBeTruthy()
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ provider: 'github', type: 'pr', number: 1 }),
+        expect.objectContaining({ provider: 'github', type: 'pr', number: 3 }),
+        expect.objectContaining({ provider: 'linear', identifier: 'STA-4' })
+      ])
+    )
   })
-
-  it.each(IME_FIELDS)(
-    'ignores IME Enter and resets on blur in $placeholder',
-    async ({ placeholder, value, updates }) => {
-      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
-      const input = screen.getByPlaceholderText(placeholder)
-      fireEvent.change(input, { target: { value } })
-      for (const marker of [{ isComposing: true, keyCode: 13 }, { keyCode: 229 }]) {
-        expect(fireEvent.keyDown(input, { key: 'Enter', ...marker })).toBe(true)
-        expect(updateWorktreeMeta).not.toHaveBeenCalled()
-        expect(useAppStore.getState().activeModal).toBe('edit-meta')
-      }
-      fireEvent.compositionStart(input)
-      expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })).toBe(true)
-      expect(updateWorktreeMeta).not.toHaveBeenCalled()
-      fireEvent.blur(input)
-      await act(async () => {
-        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+  it('adds a pasted URL according to its provider and type', async () => {
+    openDialog()
+    act(() =>
+      useAppStore.setState({
+        repos: [
+          {
+            id: 'repo',
+            path: '/repo',
+            displayName: 'orca',
+            badgeColor: '',
+            addedAt: 1,
+            gitRemoteIdentity: {
+              canonicalKey: 'gitlab.example.com/team/orca',
+              remoteName: 'origin',
+              remoteUrl: 'https://gitlab.example.com/team/orca.git'
+            }
+          }
+        ]
       })
-      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
-      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
-      expect(useAppStore.getState().activeModal).toBe('none')
-    }
-  )
-
-  it.each(
-    ['before keyup', 'after keyup'].flatMap((order) =>
-      IME_FIELDS.map((field) => ({ ...field, order }))
     )
-  )(
-    'ignores the IME Enter redispatch $order in $placeholder',
-    async ({ order, placeholder, value, updates }) => {
-      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
-      const input = screen.getByPlaceholderText(placeholder)
-      const frames: FrameRequestCallback[] = []
-      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) =>
-        frames.push(callback)
-      )
-      fireEvent.compositionStart(input)
-      fireEvent.keyDown(input, { key: 'Process', keyCode: 229, isComposing: true })
-      fireEvent.change(input, { target: { value } })
-      fireEvent.compositionEnd(input)
-      if (order === 'after keyup') {
-        fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
-      }
-      expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })).toBe(false)
-      expect(updateWorktreeMeta).not.toHaveBeenCalled()
-      expect(useAppStore.getState().activeModal).toBe('edit-meta')
-      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
-      act(() => frames.forEach((callback) => callback(0)))
-      await act(async () => {
-        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
-      })
-      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
-      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
-      expect(useAppStore.getState().activeModal).toBe('none')
-    }
-  )
-
-  it.each(IME_FIELDS)(
-    'expires an IME gesture without redispatch in $placeholder',
-    async ({ placeholder }) => {
-      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
-      const input = screen.getByPlaceholderText(placeholder)
-      const frames: FrameRequestCallback[] = []
-      vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) =>
-        frames.push(callback)
-      )
-      fireEvent.compositionStart(input)
-      fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
-      fireEvent.compositionEnd(input)
-      fireEvent.keyUp(input, { key: 'Enter', keyCode: 13 })
-      act(() => frames.forEach((callback) => callback(0)))
-      await act(async () => {
-        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    await add('https://gitlab.example.com/team/orca/-/merge_requests/12')
+    expect(screen.getByText('MR !12')).toBeTruthy()
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual([
+      expect.objectContaining({ provider: 'gitlab', type: 'mr', number: 12 })
+    ])
+  })
+  it('shows an existing reference as linked', async () => {
+    openDialog({ linkedIssue: 42 })
+    fireEvent.change(input(), { target: { value: '#42' } })
+    expect(await screen.findByText('Linked')).toBeTruthy()
+    expect(screen.getAllByText('Issue #42')).toHaveLength(1)
+  })
+  it('unlinks only the chosen item', async () => {
+    openDialog({
+      linkedPR: 1,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 1 },
+        { provider: 'github', type: 'pr', number: 2 }
+      ]
+    })
+    fireEvent.click(screen.getByRole('button', { name: 'Unlink PR #2' }))
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual([
+      { provider: 'github', type: 'pr', number: 1 }
+    ])
+  })
+  it('keeps all reviews without exposing a checks selector', async () => {
+    openDialog({
+      linkedPR: 1,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 1 },
+        { provider: 'github', type: 'pr', number: 2 }
+      ]
+    })
+    expect(screen.queryByRole('button', { name: /Use .* for checks/ })).toBeNull()
+    expect(screen.queryByText('Used for checks')).toBeNull()
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual({})
+  })
+  it('unlinks a review without overriding another client’s concurrently selected review', async () => {
+    const original = openDialog({
+      linkedPR: 1,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 1 },
+        { provider: 'github', type: 'pr', number: 2 }
+      ]
+    })
+    fireEvent.click(screen.getByRole('button', { name: 'Unlink PR #1' }))
+    act(() =>
+      useAppStore.setState({
+        worktreesByRepo: {
+          repo: [
+            {
+              ...original,
+              linkedPR: 3,
+              linkedItems: [
+                ...(original.linkedItems ?? []),
+                { provider: 'github', type: 'pr', number: 3 }
+              ]
+            }
+          ]
+        }
       })
-      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
-      expect(useAppStore.getState().activeModal).toBe('none')
-    }
-  )
-
-  it.each(
-    ['active composition', 'pending confirmation'].flatMap((phase) =>
-      IME_FIELDS.map((field) => ({ ...field, phase }))
     )
-  )(
-    'allows a deliberate save after closing with $phase in $placeholder',
-    async ({ phase, placeholder, value, updates }) => {
-      openDialog(placeholder === 'MR ! or GitLab URL' ? { modalReviewProvider: 'gitlab' } : {})
-      const input = screen.getByPlaceholderText(placeholder)
-      const modalData = useAppStore.getState().modalData
-      fireEvent.compositionStart(input)
-      if (phase === 'pending confirmation') {
-        fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
-        fireEvent.compositionEnd(input)
-      }
-      act(() => useAppStore.getState().closeModal())
-      expect(screen.queryByPlaceholderText(placeholder)).toBeNull()
-      act(() => useAppStore.setState({ activeModal: 'edit-meta', modalData }))
-      const reopenedInput = screen.getByPlaceholderText(placeholder)
-      fireEvent.change(reopenedInput, { target: { value } })
-      await act(async () => {
-        fireEvent.keyDown(reopenedInput, { key: 'Enter', keyCode: 13 })
-      })
-      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
-      expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(expect.objectContaining(updates))
-      expect(useAppStore.getState().activeModal).toBe('none')
-    }
-  )
-
-  it('keeps a folder workspace note open through composition confirmation', async () => {
-    const worktreeId = folderWorkspaceKey('fw-1')
-    openDialog({ worktreeId, folderWorkspace: {} })
-    const input = screen.getByPlaceholderText('Notes about this worktree...')
-    fireEvent.change(input, { target: { value: '日本語' } })
-    fireEvent.compositionStart(input)
-    fireEvent.keyDown(input, { key: 'Enter', keyCode: 229 })
-    fireEvent.compositionEnd(input)
-    fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
-    expect(updateWorktreeMeta).not.toHaveBeenCalled()
-    expect(useAppStore.getState().activeModal).toBe('edit-meta')
-    await act(async () => {
-      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13 })
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual({
+      linkedItemsBase: original.linkedItems,
+      linkedItems: [{ provider: 'github', type: 'pr', number: 2 }]
     })
-    expect(updateWorktreeMeta).toHaveBeenCalledExactlyOnceWith(worktreeId, { comment: '日本語' })
-    expect(useAppStore.getState().activeModal).toBe('none')
   })
-
-  it.each([
-    { userAgent: 'Macintosh', modifier: { metaKey: true } },
-    { userAgent: 'Windows', modifier: { ctrlKey: true } },
-    { userAgent: 'Linux', modifier: { ctrlKey: true } }
-  ])(
-    'keeps the save shortcut outside composition on $userAgent',
-    async ({ userAgent, modifier }) => {
-      vi.spyOn(navigator, 'userAgent', 'get').mockReturnValue(userAgent)
-      openDialog()
-      const input = screen.getByPlaceholderText('Notes about this worktree...')
-      fireEvent.compositionStart(input)
-      fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, ...modifier })
-      expect(updateWorktreeMeta).not.toHaveBeenCalled()
-      fireEvent.compositionEnd(input)
-      await act(async () => {
-        fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, ...modifier })
+  it('passes the original snapshot so persistence can preserve background additions', async () => {
+    const original = openDialog({ linkedIssue: 1 })
+    fireEvent.click(screen.getByRole('button', { name: 'Unlink Issue #1' }))
+    act(() =>
+      useAppStore.setState({
+        worktreesByRepo: {
+          repo: [
+            {
+              ...original,
+              linkedItems: [
+                { provider: 'github', type: 'issue', number: 1 },
+                { provider: 'github', type: 'issue', number: 2 }
+              ]
+            }
+          ]
+        }
       })
-      expect(updateWorktreeMeta).toHaveBeenCalledTimes(1)
-    }
-  )
-
-  it('leaves Shift+Enter available for a newline', () => {
+    )
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual({
+      linkedItemsBase: [{ provider: 'github', type: 'issue', number: 1 }],
+      linkedItems: []
+    })
+  })
+  it('omits untouched links on comment-only saves', async () => {
+    openDialog({ linkedIssue: 1, linkedLinearIssue: 'STA-2' })
+    fireEvent.change(screen.getByPlaceholderText('Notes about this worktree...'), {
+      target: { value: 'new note' }
+    })
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual({ comment: 'new note' })
+  })
+  it('keeps the draft and error visible after a failed save', async () => {
+    updateWorktreeMeta.mockResolvedValue({ ok: false, error: 'Host is disconnected' })
     openDialog()
-    const input = screen.getByPlaceholderText('Notes about this worktree...')
-    expect(fireEvent.keyDown(input, { key: 'Enter', keyCode: 13, shiftKey: true })).toBe(true)
-    expect(updateWorktreeMeta).not.toHaveBeenCalled()
+    await add('4')
+    await save()
+    const alert = await screen.findByRole('alert')
+    expect(alert.textContent).toBe('Host is disconnected')
+    expect(alert.parentElement?.contains(screen.getByRole('button', { name: 'Save' }))).toBe(true)
+    expect(screen.getByText('Issue #4')).toBeTruthy()
     expect(useAppStore.getState().activeModal).toBe('edit-meta')
   })
-
-  it('seeds the chip and value from a GitHub link', () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    expect(providerChip().textContent).toContain('GitHub')
-    expect(issueInput().value).toBe('42')
+  it('supports folder workspace links', async () => {
+    const folder: FolderWorkspace = {
+      id: 'folder-1',
+      projectGroupId: 'group',
+      name: 'Docs',
+      folderPath: '/docs',
+      linkedTask: null,
+      comment: '',
+      isArchived: false,
+      isUnread: false,
+      isPinned: false,
+      sortOrder: 0,
+      lastActivityAt: 1,
+      createdAt: 1,
+      updatedAt: 1
+    }
+    useAppStore.setState({ folderWorkspaces: [folder] })
+    openDialog({}, { worktreeId: folderWorkspaceKey(folder.id), repoId: undefined })
+    await add('STA-5', 'Linear task')
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[0]).toBe(folderWorkspaceKey(folder.id))
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual([
+      expect.objectContaining({ provider: 'linear', identifier: 'STA-5' })
+    ])
   })
-
-  it('seeds and saves the GitLab MR row through the GitLab slot', async () => {
-    openDialog({
-      worktree: { linkedGitLabMR: 42 },
-      modalReviewProvider: 'gitlab',
-      modalCurrentReview: 42,
-      modalSuppressHostedReviewRefresh: true
-    })
-    const input = screen.getByPlaceholderText('MR ! or GitLab URL')
-
-    expect(screen.getByText('GitLab MR')).toBeTruthy()
-    expect((input as HTMLInputElement).value).toBe('42')
-    fireEvent.change(input, { target: { value: '!43' } })
-    await act(async () => fireEvent.click(saveButton()))
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    expect(updateWorktreeMeta.mock.calls[0]?.[1]).toEqual(
-      expect.objectContaining({ linkedGitLabMR: 43 })
-    )
-    expect(updateWorktreeMeta.mock.calls[0]?.[1]).not.toHaveProperty('linkedPR')
-    expect(updateWorktreeMeta.mock.calls[0]?.[2]).toEqual({ suppressHostedReviewRefresh: true })
+  it('preserves the execution host in a metadata save', async () => {
+    openDialog({ hostId: 'runtime:host-1' }, { executionHostId: 'runtime:host-1' })
+    await add('4')
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[2]).toEqual({ executionHostId: 'runtime:host-1' })
   })
-
-  it('replaces a completed emoji shortcode in the display name', () => {
+  it('Enter adds another link and leaves the editor open', async () => {
     openDialog()
-    const displayNameInput = screen.getByRole('textbox', { name: 'Display Name' })
-
-    fireEvent.change(displayNameInput, {
-      target: { value: 'Feature :wink:', selectionStart: 14 }
-    })
-
-    expect((displayNameInput as HTMLInputElement).value).toBe('Feature 😉')
+    const field = input()
+    fireEvent.change(field, { target: { value: 'https://github.com/acme/orca/issues/4' } })
+    fireEvent.keyDown(field, { key: 'Enter' })
+    expect(screen.queryByText('Issue #4')).toBeNull()
+    const command = await screen.findByRole('option', { name: 'Add Issue #4' })
+    await waitFor(() => expect(command.getAttribute('data-disabled')).not.toBe('true'))
+    fireEvent.keyDown(field, { key: 'Enter' })
+    expect(screen.getByText('Issue #4')).toBeTruthy()
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
   })
-
-  it('seeds the chip and value from a Linear link', () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    expect(providerChip().textContent).toContain('Linear')
-    expect(issueInput().value).toBe('STA-335')
+  it('does not add during an IME composition gesture', () => {
+    openDialog()
+    const field = input()
+    fireEvent.change(field, { target: { value: '4' } })
+    fireEvent.compositionStart(field)
+    fireEvent.keyDown(field, { key: 'Enter', isComposing: true })
+    expect(screen.queryByText('Issue #4')).toBeNull()
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
   })
-
-  it('flips to Linear when a linear.app issue URL is pasted', () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    fireEvent.change(issueInput(), {
-      target: { value: 'https://linear.app/acme/issue/STA-335/fix-the-thing' }
-    })
-
-    expect(providerChip().textContent).toContain('Linear')
+  it.each([
+    { key: 'Enter', keyCode: 13, isComposing: true },
+    { key: 'Enter', keyCode: 229 },
+    { key: 'Enter', keyCode: 13 }
+  ])('keeps notes open through IME confirmation and redispatch: %j', async (event) => {
+    openDialog()
+    const notes = screen.getByRole('textbox', { name: 'Notes' })
+    fireEvent.compositionStart(notes)
+    fireEvent.change(notes, { target: { value: '確定' } })
+    fireEvent.keyDown(notes, event)
+    fireEvent.compositionEnd(notes)
+    fireEvent.keyUp(notes, { key: 'Enter', keyCode: 13 })
+    fireEvent.keyDown(notes, { key: 'Enter', keyCode: 13 })
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+    fireEvent.keyDown(notes, { key: 'Enter', keyCode: 13 })
+    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalled())
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].comment).toBe('確定')
   })
-
-  // Why: Linear and Jira issue keys are the same shape, so only a URL may steer
-  // the provider — a bare key must never override the user's explicit choice.
-  it('keeps the chip on GitHub when a bare issue key is typed', () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    fireEvent.change(issueInput(), { target: { value: 'GH-1234' } })
-
-    expect(providerChip().textContent).toContain('GitHub')
-    expect(providerChip().textContent).not.toContain('Linear')
+  it('saves selected drafts while leaving search text unattached', async () => {
+    openDialog({ linkedIssue: 1 })
+    await add('https://github.com/acme/orca/issues/4')
+    fireEvent.change(input(), { target: { value: '42' } })
+    expect(screen.getByRole('button', { name: 'Save' }).hasAttribute('disabled')).toBe(false)
+    expect(screen.getByText('Select a result to attach it.')).toBeTruthy()
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual([
+      expect.objectContaining({ number: 1 }),
+      expect.objectContaining({ number: 4 })
+    ])
   })
-
-  it('flips to GitHub when a GitHub issue URL is pasted over a Linear link', () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), {
-      target: { value: 'https://github.com/acme/orca/issues/77' }
+  it('blocks known foreign issue URLs with an explanation', () => {
+    openDialog()
+    fireEvent.change(input(), {
+      target: { value: 'https://github.com/other/project/issues/4' }
     })
-
-    expect(providerChip().textContent).toContain('GitHub')
-  })
-
-  it('names the Linear issue that switching to GitHub would unlink', () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.click(screen.getByRole('menuitemradio', { name: 'GitHub' }))
-    fireEvent.change(issueInput(), { target: { value: '99' } })
-
     expect(
-      screen.getByText('Saving unlinks Linear STA-335 — a workspace tracks one issue.')
+      screen.getByRole('option', { name: /^Add / }).getAttribute('aria-disabled') === 'true'
+    ).toBe(true)
+    expect(
+      screen.getByText(
+        'This issue belongs to another repository. Add issues from this workspace’s repository.'
+      )
     ).toBeTruthy()
   })
-
-  // Both slots can hold a link at once — naming only one understates the save.
-  it('names both links when clearing the field would drop both', () => {
-    openDialog({ worktree: { linkedIssue: 42, linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), { target: { value: '' } })
-
+  it('blocks known foreign review URLs with an explanation', () => {
+    openDialog()
+    fireEvent.change(input(), {
+      target: { value: 'https://github.com/other/project/pull/4' }
+    })
+    expect(
+      screen.getByRole('option', { name: /^Add / }).getAttribute('aria-disabled') === 'true'
+    ).toBe(true)
     expect(
       screen.getByText(
-        'Saving unlinks Linear STA-335 and GitHub #42 — a workspace tracks one issue.'
+        'This review belongs to another repository. Add reviews from this workspace’s repository.'
       )
     ).toBeTruthy()
   })
-
-  // The warning above only promises the displacement — this asserts the payload
-  // that carries it out, which is where the one-issue-per-workspace rule lives.
-  it('clears the displaced GitHub link when a Linear value is saved', async () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    fireEvent.click(screen.getByRole('menuitemradio', { name: 'Linear' }))
-    fireEvent.change(issueInput(), { target: { value: 'STA-335' } })
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(updates.linkedLinearIssue).toBe('STA-335')
-    expect(updates.linkedIssue).toBeNull()
+  it('clears search with captured Escape before the next Escape closes details', () => {
+    openDialog()
+    const field = input()
+    fireEvent.change(field, { target: { value: 'unselected search' } })
+    fireEvent.keyDown(field, { key: 'Escape' })
+    expect(screen.getByRole('combobox')).toBe(field)
+    expect(screen.queryByRole('option')).toBeNull()
+    expect(screen.queryByRole('button', { name: 'Clear search' })).toBeNull()
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+    fireEvent.keyDown(field, { key: 'Escape' })
+    expect(useAppStore.getState().activeModal).toBe('none')
   })
-
-  // A GitHub-only save must carry no Linear keys: persistence gates the remote
-  // Linear capability on key presence, so a synthetic clear fails the save.
-  it('sends no Linear keys when the workspace has no Linear link', async () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    fireEvent.change(issueInput(), { target: { value: '99' } })
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(updates.linkedIssue).toBe(99)
-    expect(updates).not.toHaveProperty('linkedLinearIssue')
+  it('keeps real GitLab-enabled controller effects bounded in Smart mode', async () => {
+    const errors = vi.spyOn(console, 'error').mockImplementation(() => {})
+    openDialog({ hostId: 'ssh:test-host' })
+    input()
+    await waitFor(() => expect(useAppStore.getState().fetchWorkItems).toHaveBeenCalledTimes(1))
+    expect(screen.getByRole('tab', { name: 'GitLab' })).toBeTruthy()
+    expect(errors.mock.calls.flat().join(' ')).not.toContain('Maximum update depth')
+    errors.mockRestore()
   })
-  it('qualifies a save with the host selected by the opening row', async () => {
-    openDialog({
-      worktree: { hostId: 'ssh:build-box' },
-      modalExecutionHostId: 'ssh:build-box'
-    })
-
-    fireEvent.change(screen.getByPlaceholderText('Notes about this worktree...'), {
-      target: { value: 'remote note' }
-    })
-    await act(async () => {
-      fireEvent.click(saveButton())
+  it('adds a searched issue with title and source context and stays ready for another', async () => {
+    useAppStore.setState({
+      fetchWorkItems: vi.fn(async (): Promise<GitHubWorkItem[]> => [
+        {
+          id: 'issue-71',
+          repoId: 'repo',
+          type: 'issue',
+          number: 71,
+          title: 'Searchable issue',
+          state: 'open',
+          url: 'https://github.com/acme/orca/issues/71',
+          labels: [],
+          updatedAt: '2026-10-05',
+          author: null
+        }
+      ])
     })
-
+    openDialog()
+    const field = input()
+    fireEvent.change(field, { target: { value: 'Searchable' } })
+    await screen.findByRole('option', { name: /Searchable issue/ })
     await waitFor(() =>
-      expect(updateWorktreeMeta).toHaveBeenCalledWith(
-        WORKTREE_ID,
-        expect.objectContaining({ comment: 'remote note' }),
-        { executionHostId: 'ssh:build-box' }
-      )
+      expect(
+        screen.getByRole('option', { name: /Searchable issue/ }).getAttribute('data-disabled')
+      ).not.toBe('true')
     )
+    fireEvent.click(screen.getByRole('option', { name: /Searchable issue/ }))
+    expect(screen.getByRole('combobox')).toBeTruthy()
+    expect(field).toBeInstanceOf(HTMLInputElement)
+    if (!(field instanceof HTMLInputElement)) {
+      throw new Error('Expected reference input')
+    }
+    expect(field.value).toBe('')
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]?.[1].linkedItems).toEqual([
+      expect.objectContaining({
+        number: 71,
+        title: 'Searchable issue',
+        taskSourceContext: expect.objectContaining({
+          provider: 'github',
+          providerIdentity: expect.objectContaining({ owner: 'acme', repo: 'orca' })
+        })
+      })
+    ])
   })
-
-  // updateWorktreeMeta stamps lastActivityAt on any comment write, which would
-  // reorder the workspace under the time-decay sidebar sort.
-  it('sends no comment when only the issue link changed', async () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), { target: { value: 'STA-999' } })
-    await act(async () => {
-      fireEvent.click(saveButton())
+  it('does not select a held result after typing a different query', async () => {
+    useAppStore.setState({
+      fetchWorkItems: vi.fn(async (): Promise<GitHubWorkItem[]> => [
+        {
+          id: 'issue-71',
+          repoId: 'repo',
+          type: 'issue',
+          number: 71,
+          title: 'Old result',
+          state: 'open',
+          url: 'https://github.com/acme/orca/issues/71',
+          labels: [],
+          updatedAt: '2026-10-05',
+          author: null
+        }
+      ])
     })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    expect(updateWorktreeMeta.mock.calls[0]?.[1] ?? {}).not.toHaveProperty('comment')
+    openDialog()
+    const field = input()
+    fireEvent.change(field, { target: { value: 'Old' } })
+    const result = await screen.findByRole('option', { name: /Old result/ })
+    fireEvent.change(field, { target: { value: 'new query' } })
+    fireEvent.keyDown(field, { key: 'Enter' })
+    fireEvent.click(result)
+    expect(screen.getByText('0 linked')).toBeTruthy()
   })
-
-  // A failed save refetches and reverts the optimistic write, so closing here
-  // would report success for an edit that silently undid itself.
-  it('keeps the dialog open and reports why when the save fails', async () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-    updateWorktreeMeta.mockResolvedValue({ ok: false, error: 'Runtime is offline' })
-
-    fireEvent.change(issueInput(), { target: { value: 'STA-999' } })
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    expect(screen.getByRole('alert').textContent).toBe('Runtime is offline')
-    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+  it('stops cmdk from adding an IME-owned unmarked Enter', () => {
+    openDialog()
+    const field = input()
+    fireEvent.change(field, { target: { value: 'https://github.com/acme/orca/issues/71' } })
+    fireEvent.compositionStart(field)
+    fireEvent.keyDown(field, { key: 'Enter', keyCode: 13, isComposing: false })
+    fireEvent.compositionEnd(field)
+    fireEvent.keyDown(field, { key: 'Enter', keyCode: 13, isComposing: false })
+    expect(screen.getByText('0 linked')).toBeTruthy()
   })
 
-  it('leaves the Linear link alone when only the comment is edited', async () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(screen.getByPlaceholderText('Notes about this worktree...'), {
-      target: { value: 'updated note' }
-    })
-
-    expect(screen.queryByText(/Saving unlinks/)).toBeNull()
-
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(Object.keys(updates)).not.toContain('linkedLinearIssue')
-    expect(Object.keys(updates)).not.toContain('linkedIssue')
-    expect(updates.comment).toBe('updated note')
+  it('focuses an inline suggested review without assuming it has been attached', () => {
+    openDialog({}, { focus: 'pr', currentReview: 42 })
+    expect(screen.getByRole('combobox', { name: 'Search references' })).toBeTruthy()
+    expect(screen.getByRole('button', { name: 'Save' }).hasAttribute('disabled')).toBe(false)
+    expect(screen.getByRole('option', { name: 'Add PR #42' })).toBeTruthy()
   })
-
-  it('blocks saving an unparseable Linear value', () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), { target: { value: 'not an issue' } })
-
-    expect(screen.getByText('Not a Linear issue key or linear.app issue URL.')).toBeTruthy()
-    expect(saveButton().disabled).toBe(true)
+  it('keeps search inside the single details dialog and starts with no result overlay', () => {
+    openDialog()
+    const field = input()
+    expect(screen.getAllByRole('dialog')).toHaveLength(1)
+    expect(screen.getByRole('dialog').contains(field)).toBe(true)
+    expect(screen.queryByRole('option')).toBeNull()
+    fireEvent.keyDown(field, { key: 'Enter' })
+    expect(screen.getByText('0 linked')).toBeTruthy()
   })
-
-  it('is read-only for a folder workspace', () => {
-    openDialog({ worktreeId: folderWorkspaceKey('fw-1') })
-
-    expect(issueInput().disabled).toBe(true)
-    expect(providerChip().disabled).toBe(true)
-    expect(
-      screen.getByText(
-        "Issue links are set when a folder workspace is created and can't be changed here yet."
-      )
-    ).toBeTruthy()
+  it('clears results explicitly and preserves the selected drafts', async () => {
+    openDialog()
+    await add('https://github.com/acme/orca/issues/4')
+    fireEvent.change(input(), { target: { value: 'unselected' } })
+    fireEvent.click(screen.getByRole('button', { name: 'Clear search' }))
+    expect(screen.queryByRole('option')).toBeNull()
+    expect(screen.getByText('Issue #4')).toBeTruthy()
+    expect(document.activeElement).toBe(input())
   })
-
-  // Folder workspaces live outside worktreesByRepo, so the indexed lookup alone
-  // leaves the row blank and the link it does hold looks lost.
-  it('shows a folder workspace its own linked issue', () => {
-    openDialog({ worktreeId: folderWorkspaceKey('fw-1'), folderWorkspace: {} })
-
-    expect(issueInput().value).toBe('STA-901')
-    expect(providerChip().textContent).toContain('Linear')
+  it('cancels added references without a metadata write', async () => {
+    openDialog()
+    await add('https://github.com/acme/orca/issues/4')
+    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }))
+    expect(updateWorktreeMeta).not.toHaveBeenCalled()
+    expect(useAppStore.getState().activeModal).toBe('none')
   })
-
-  // A background `orca worktree set` must not move the baseline mid-edit: the
-  // field would read as dirty and a comment-only save would write the stale seed.
-  it('keeps the baseline frozen when the store changes while open', async () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    act(() => {
-      useAppStore.setState({
-        worktreesByRepo: {
-          [REPO_ID]: [makeWorktree({ linkedLinearIssue: 'STA-999' })]
-        }
-      })
-    })
-    fireEvent.change(screen.getByPlaceholderText('Notes about this worktree...'), {
-      target: { value: 'still working' }
-    })
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(updates.comment).toBe('still working')
-    expect(updates).not.toHaveProperty('linkedLinearIssue')
-    expect(updates).not.toHaveProperty('linkedIssue')
+  it('keeps empty notes collapsed for link focus and preserves existing notes', () => {
+    openDialog({ comment: '' }, { focus: 'links' })
+    expect(screen.queryByRole('textbox', { name: 'Notes' })).toBeNull()
+    fireEvent.click(screen.getByRole('button', { name: 'Add notes' }))
+    expect(screen.getByRole('textbox', { name: 'Notes' })).toBeTruthy()
+    expect(document.activeElement).toBe(screen.getByRole('textbox', { name: 'Notes' }))
   })
-
-  // A bare key names no organization. Building one from the connected viewer
-  // opens a not-found page — or a colliding issue — for every other workspace
-  // the user belongs to, and skips the lookup that would have said so.
-  it('resolves a bare Linear key across workspaces rather than the active organization', async () => {
-    fetchLinearIssue.mockResolvedValue(makeLinearIssue('https://linear.app/other/issue/STA-999'))
-    openDialog({
-      worktree: { linkedLinearIssue: 'STA-335' },
-      linearViewerOrganizationUrlKey: 'active-org'
-    })
-
-    fireEvent.change(issueInput(), { target: { value: 'STA-999' } })
-    await act(async () => {
-      fireEvent.click(openIssueButton())
-    })
-
-    expect(fetchLinearIssue.mock.calls[0]?.slice(0, 2)).toEqual(['STA-999', 'all'])
-    expect(openUrl).toHaveBeenCalledWith('https://linear.app/other/issue/STA-999')
+  it('preserves name and comment autofocus while search remains inline', () => {
+    openDialog({}, { focus: 'displayName' })
+    expect(document.activeElement).toBe(screen.getByRole('textbox', { name: 'Display Name' }))
   })
-
-  // The stored key belongs to the persisted identifier, so it stays authoritative
-  // for it — no lookup, no round trip.
-  it('opens a stored Linear link directly from its organization key', async () => {
-    openDialog({
-      worktree: {
-        linkedLinearIssue: 'STA-335',
-        linkedLinearIssueOrganizationUrlKey: 'acme'
-      },
-      linearViewerOrganizationUrlKey: 'active-org'
-    })
-
-    await act(async () => {
-      fireEvent.click(openIssueButton())
-    })
-
-    expect(fetchLinearIssue).not.toHaveBeenCalled()
-    expect(openUrl).toHaveBeenCalledWith('https://linear.app/acme/issue/STA-335')
+  it('does not dismiss the dialog when Escape belongs to IME composition', () => {
+    openDialog()
+    const field = input()
+    fireEvent.compositionStart(field)
+    fireEvent.keyDown(field, { key: 'Escape', isComposing: false })
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+    fireEvent.compositionEnd(field)
   })
-
-  // Promise.race cannot cancel the lookup, and the field stays editable while it
-  // runs — a late result must not open the issue the user just replaced.
-  it('does not open a lookup result after the field moved on', async () => {
-    let resolveLookup: ((issue: LinearIssue | null) => void) | undefined
-    fetchLinearIssue.mockReturnValue(
-      new Promise<LinearIssue | null>((resolve) => {
-        resolveLookup = resolve
-      })
-    )
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), { target: { value: 'STA-999' } })
-    fireEvent.click(openIssueButton())
-    fireEvent.change(issueInput(), { target: { value: 'STA-777' } })
-    await act(async () => {
-      resolveLookup?.(makeLinearIssue('https://linear.app/acme/issue/STA-999'))
+  it('resets the draft when another host opens the same workspace ID', async () => {
+    const original = openDialog({ linkedIssue: 1 }, { executionHostId: 'local' })
+    fireEvent.change(screen.getByRole('textbox', { name: 'Notes' }), {
+      target: { value: 'Local draft' }
     })
-
-    expect(openUrl).not.toHaveBeenCalled()
-    expect(
-      screen.queryByText(
-        "Couldn't open that issue. Check the identifier and your Linear connection."
-      )
-    ).toBeNull()
-  })
-
-  // Displacement is decided at save time, not at open: a link added by the CLI
-  // while the dialog sat open must not outlive the save that warned about it.
-  it('clears a Linear link added while the dialog was open', async () => {
-    openDialog({ worktree: { linkedIssue: 42 } })
-
-    act(() => {
+    await add('https://github.com/acme/orca/issues/3')
+    act(() =>
       useAppStore.setState({
         worktreesByRepo: {
-          [REPO_ID]: [makeWorktree({ linkedIssue: 42, linkedLinearIssue: 'STA-999' })]
+          repo: [
+            original,
+            { ...original, hostId: 'ssh:other', linkedIssue: 2, comment: 'Remote note' }
+          ]
+        },
+        modalData: {
+          worktreeId: original.id,
+          repoId: 'repo',
+          executionHostId: 'ssh:other',
+          focus: 'comment'
         }
       })
-    })
-    fireEvent.change(issueInput(), { target: { value: '99' } })
-
+    )
+    expect(screen.getByText('Issue #2')).toBeTruthy()
+    expect(screen.queryByText('Issue #1')).toBeNull()
+    expect(screen.queryByText('Issue #3')).toBeNull()
     expect(
-      screen.getByText('Saving unlinks Linear STA-999 — a workspace tracks one issue.')
-    ).toBeTruthy()
-
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(updates.linkedIssue).toBe(99)
-    expect(updates.linkedLinearIssue).toBeNull()
+      screen.getByRole('textbox', { name: 'Notes' }).getAttribute('value') ??
+        screen.getByRole('textbox', { name: 'Notes' }).textContent
+    ).toBe('Remote note')
+    await save()
+    expect(updateWorktreeMeta.mock.calls[0]).toEqual([
+      original.id,
+      {},
+      { executionHostId: 'ssh:other' }
+    ])
   })
-
-  // Same issue, different spelling: the link is unchanged, so its title and
-  // SSH/runtime source context must survive the save.
-  it('keeps the linked work item when the value is only respelled', async () => {
-    openDialog({
-      worktree: {
-        linkedLinearIssue: 'STA-335',
-        linkedWorkItem: {
-          provider: 'linear',
-          type: 'issue',
-          number: 335,
-          title: 'Fix auth',
-          url: 'https://linear.app/acme/issue/STA-335'
+  it('does not close a new owner’s draft when an earlier save completes', async () => {
+    const original = openDialog({}, { executionHostId: 'local' })
+    const pending = Promise.withResolvers<{ ok: true }>()
+    updateWorktreeMeta.mockReturnValueOnce(pending.promise)
+    fireEvent.click(screen.getByRole('button', { name: 'Save' }))
+    expect(updateWorktreeMeta).toHaveBeenCalledOnce()
+    act(() =>
+      useAppStore.setState({
+        worktreesByRepo: {
+          repo: [original, { ...original, hostId: 'ssh:other', comment: 'Remote draft' }]
+        },
+        modalData: {
+          worktreeId: original.id,
+          repoId: 'repo',
+          executionHostId: 'ssh:other',
+          focus: 'comment'
         }
-      }
-    })
-
-    fireEvent.change(issueInput(), { target: { value: 'sta-335' } })
-
-    expect(screen.queryByText(/Saving unlinks/)).toBeNull()
-
-    await act(async () => {
-      fireEvent.click(saveButton())
-    })
-
-    await waitFor(() => expect(updateWorktreeMeta).toHaveBeenCalledTimes(1))
-    const updates = updateWorktreeMeta.mock.calls[0]?.[1] ?? {}
-    expect(updates).not.toHaveProperty('linkedWorkItem')
-    expect(updates).not.toHaveProperty('linkedTaskSourceContext')
-    expect(updates).not.toHaveProperty('linkedLinearIssue')
-  })
-
-  // The owner index reports a duplicated workspace ID as ambiguous rather than
-  // guessing, so the opening row has to name its own bucket.
-  it('shows the clicked row when the same workspace ID exists under two hosts', () => {
-    openDialog({
-      worktree: { linkedIssue: 42 },
-      otherRepos: [{ repoId: 'repo-2', worktree: { linkedIssue: 77 } }],
-      modalRepoId: 'repo-2'
-    })
-
-    expect(issueInput().value).toBe('77')
-    expect(providerChip().textContent).toContain('GitHub')
-  })
-
-  it('dispatches nothing when the dialog is cancelled', async () => {
-    openDialog({ worktree: { linkedLinearIssue: 'STA-335' } })
-
-    fireEvent.change(issueInput(), { target: { value: '99' } })
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: 'Cancel' }))
-    })
-
-    expect(updateWorktreeMeta).not.toHaveBeenCalled()
-    expect(useAppStore.getState().activeModal).toBe('none')
+      })
+    )
+    await act(async () => pending.resolve({ ok: true }))
+    expect(useAppStore.getState().activeModal).toBe('edit-meta')
+    expect(screen.getByRole('button', { name: 'Save' }).hasAttribute('disabled')).toBe(false)
+    expect(screen.getByRole('textbox', { name: 'Notes' }).textContent).toBe('Remote draft')
   })
 })
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
index 197485851a47..57a000bd9e8e 100644
--- a/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialog.tsx
@@ -1,436 +1,9 @@
-import { ImeTextarea } from '@/lib/ime-text-field'
-import React, { useCallback, useMemo, useRef, useState } from 'react'
+import React from 'react'
 import { useAppStore } from '@/store'
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle
-} from '@/components/ui/dialog'
-import { Button } from '@/components/ui/button'
-import { getDisplacedLinkLabels } from './worktree-issue-displacement'
-import {
-  buildWorktreeMetaUpdates,
-  parseGitLabMergeRequestNumberForMetaField,
-  parseGitHubWorkItemNumberForMetaField,
-  type WorktreeReviewProvider,
-  type WorktreeMetaDraft,
-  type WorktreeMetaSavedPayload,
-  type WorktreeMetaSnapshot
-} from './worktree-meta-updates'
-import { useWorktreeIssueLink } from './use-worktree-issue-link'
-import { useWorktreeMetaWorkspace } from './use-worktree-meta-workspace'
-import { WorktreeIssueLinkField } from './WorktreeIssueLinkField'
-import { getScreenSubmitShortcutLabel, isScreenSubmitShortcut } from '@/lib/screen-submit-shortcut'
-import { useMountedRef } from '@/hooks/useMountedRef'
-import { translate } from '@/i18n/i18n'
-import { isWorkItemLinkQueryTooLarge } from '../../../../shared/new-workspace/work-item-link-query-bounds'
-import {
-  getIssueLinkProviderFromUrl,
-  parseIssueLinkInput,
-  type IssueLinkProvider
-} from '../../../../shared/issue-link-input'
-import { parseExecutionHostId } from '../../../../shared/execution-host'
-import { WorktreeDisplayNameField } from './WorktreeDisplayNameField'
-import { WorktreeReviewLinkField } from './WorktreeReviewLinkField'
-import { resizeCommentTextarea } from './worktree-comment-textarea-sizing'
+import WorktreeMetaDialogDraft from './WorktreeMetaDialogDraft'
+import { getWorktreeMetaDialogOwner } from './worktree-meta-dialog-owner'
 
-/** Only read before the first open, when nothing can be saved yet. */
-const EMPTY_SNAPSHOT: WorktreeMetaSnapshot = {
-  displayName: '',
-  comment: '',
-  issueInput: '',
-  issueProvider: 'github',
-  prInput: ''
+export default function WorktreeMetaDialog(): React.JSX.Element {
+  const owner = useAppStore(getWorktreeMetaDialogOwner)
+  return <WorktreeMetaDialogDraft key={owner ?? 'closed'} />
 }
-
-const WorktreeMetaDialog = React.memo(function WorktreeMetaDialog() {
-  const activeModal = useAppStore((s) => s.activeModal)
-  const modalData = useAppStore((s) => s.modalData)
-  const closeModal = useAppStore((s) => s.closeModal)
-  const updateWorktreeMeta = useAppStore((s) => s.updateWorktreeMeta)
-
-  const isOpen = activeModal === 'edit-meta'
-
-  const worktreeId = typeof modalData.worktreeId === 'string' ? modalData.worktreeId : ''
-  const executionHostId =
-    typeof modalData.executionHostId === 'string'
-      ? (parseExecutionHostId(modalData.executionHostId)?.id ?? undefined)
-      : undefined
-  const currentDisplayName =
-    typeof modalData.currentDisplayName === 'string' ? modalData.currentDisplayName : ''
-  const currentComment =
-    typeof modalData.currentComment === 'string' ? modalData.currentComment : ''
-  const focusField = typeof modalData.focus === 'string' ? modalData.focus : 'comment'
-  const reviewProvider: WorktreeReviewProvider =
-    modalData.reviewProvider === 'gitlab' ? 'gitlab' : 'github'
-  const suppressHostedReviewRefresh = modalData.suppressHostedReviewRefresh === true
-  const afterSave =
-    typeof modalData.afterSave === 'function'
-      ? (modalData.afterSave as (payload: WorktreeMetaSavedPayload) => void | Promise<void>)
-      : null
-
-  // Why: the opening row names its repo bucket for workspace IDs the owner index
-  // reads as ambiguous across hosts.
-  const ownerRepoId = typeof modalData.repoId === 'string' ? modalData.repoId : null
-  const {
-    worktree,
-    linkedIssue,
-    linkedLinearIssue,
-    currentIssue,
-    currentProvider,
-    isFolderWorkspace,
-    liveLinks
-  } = useWorktreeMetaWorkspace({ worktreeId, ownerRepoId, executionHostId })
-  // Why: ChecksPanel seeds the review it is looking at, which may not be linked yet.
-  const currentReview =
-    typeof modalData.currentReview === 'number'
-      ? String(modalData.currentReview)
-      : reviewProvider === 'gitlab'
-        ? worktree?.linkedGitLabMR != null
-          ? String(worktree.linkedGitLabMR)
-          : ''
-        : typeof modalData.currentPR === 'number'
-          ? String(modalData.currentPR)
-          : worktree?.linkedPR != null
-            ? String(worktree.linkedPR)
-            : ''
-
-  const [displayNameInput, setDisplayNameInput] = useState('')
-  const [issueInput, setIssueInput] = useState('')
-  const [issueProvider, setIssueProvider] = useState<IssueLinkProvider>('github')
-  const [reviewInput, setReviewInput] = useState('')
-  const [commentInput, setCommentInput] = useState('')
-  const [saving, setSaving] = useState(false)
-  const [saveError, setSaveError] = useState<string | null>(null)
-  const [snapshot, setSnapshot] = useState<WorktreeMetaSnapshot>(EMPTY_SNAPSHOT)
-  const [dialogElement, setDialogElement] = useState<HTMLElement | null>(null)
-  const { canOpenIssue, openingIssue, openIssueFailed, handleOpenIssue, resetOpeningIssue } =
-    useWorktreeIssueLink({
-      worktreeId,
-      ownerRepoId,
-      issueInput,
-      issueProvider,
-      linearOrganizationUrlKey: worktree?.linkedLinearIssueOrganizationUrlKey ?? null,
-      linkedLinearIssue: worktree?.linkedLinearIssue ?? null,
-      linearSourceContext: worktree?.linkedTaskSourceContext ?? null
-    })
-
-  const issueInputRef = useRef<HTMLInputElement>(null)
-  const reviewInputRef = useRef<HTMLInputElement>(null)
-  const textareaRef = useRef<HTMLTextAreaElement>(null)
-  const prevIsOpenRef = useRef(false)
-  const displayNameInputRef = useRef<HTMLInputElement>(null)
-  const mountedRef = useMountedRef()
-  if (isOpen && !prevIsOpenRef.current) {
-    setDisplayNameInput(currentDisplayName)
-    setIssueInput(currentIssue)
-    setIssueProvider(currentProvider)
-    setReviewInput(currentReview)
-    setCommentInput(currentComment)
-    // Why: the baseline is frozen with the seed instead of tracking the store.
-    // A background `orca worktree set --linear-issue` while the dialog is open
-    // would otherwise move it, making the untouched field read as dirty — and
-    // the next comment-only save would write the stale seed back over the new link.
-    setSnapshot({
-      displayName: currentDisplayName,
-      comment: currentComment,
-      issueInput: currentIssue,
-      issueProvider: currentProvider,
-      prInput: worktree?.linkedPR != null ? String(worktree.linkedPR) : '',
-      linkedLinearIssueOrganizationUrlKey: worktree?.linkedLinearIssueOrganizationUrlKey ?? null
-    })
-    setSaveError(null)
-    resetOpeningIssue()
-  }
-  prevIsOpenRef.current = isOpen
-
-  const draft = useMemo<WorktreeMetaDraft>(
-    () => ({ displayNameInput, issueInput, issueProvider, reviewInput, commentInput }),
-    [displayNameInput, issueInput, issueProvider, reviewInput, commentInput]
-  )
-
-  // Why: a URL names its provider unambiguously. A bare key does not — Linear
-  // and Jira identifiers are the same shape — so typing never steers the chip.
-  const handleIssueInputChange = useCallback((next: string) => {
-    setIssueInput(next)
-    // Why: the same bound the save gate applies. Detection parses on every
-    // keystroke, and the field accepts pasted URLs of any length.
-    const detected = isWorkItemLinkQueryTooLarge(next) ? null : getIssueLinkProviderFromUrl(next)
-    if (detected) {
-      setIssueProvider(detected)
-    }
-  }, [])
-
-  const setCommentTextareaRef = useCallback(
-    (textarea: HTMLTextAreaElement | null) => {
-      textareaRef.current = textarea
-      if (textarea && isOpen) {
-        resizeCommentTextarea(textarea)
-      }
-    },
-    [isOpen]
-  )
-
-  const handleCommentChange = useCallback((event: React.ChangeEvent<HTMLTextAreaElement>) => {
-    setCommentInput(event.target.value)
-    // Why: notes should grow in the same input event; a passive Effect leaves a stale height.
-    resizeCommentTextarea(event.currentTarget)
-  }, [])
-
-  // Why: bound the parse before it runs on every keystroke — the field accepts
-  // pasted URLs and has no length cap of its own.
-  const issueInvalid = useMemo(() => {
-    const trimmed = issueInput.trim()
-    if (trimmed === '' || isFolderWorkspace) {
-      return false
-    }
-    return (
-      isWorkItemLinkQueryTooLarge(trimmed) || parseIssueLinkInput(trimmed, issueProvider) === null
-    )
-  }, [isFolderWorkspace, issueInput, issueProvider])
-
-  const canSave = useMemo(() => {
-    if (!worktreeId) {
-      return false
-    }
-    const trimmedPR = reviewInput.trim()
-    // Same quadratic-parse bound as the issue field — this runs on every keystroke.
-    const prValid =
-      trimmedPR === '' ||
-      (!isWorkItemLinkQueryTooLarge(trimmedPR) &&
-        (reviewProvider === 'gitlab'
-          ? parseGitLabMergeRequestNumberForMetaField(trimmedPR)
-          : parseGitHubWorkItemNumberForMetaField(trimmedPR, 'pr')) !== null)
-    return !issueInvalid && prValid
-  }, [worktreeId, issueInvalid, reviewInput, reviewProvider])
-
-  const displacedLinkLabels = useMemo(
-    () =>
-      getDisplacedLinkLabels({
-        draft,
-        snapshot,
-        isFolderWorkspace,
-        linkedIssue,
-        linkedLinearIssue
-      }),
-    [draft, snapshot, isFolderWorkspace, linkedIssue, linkedLinearIssue]
-  )
-
-  const handleOpenChange = useCallback(
-    (open: boolean) => {
-      if (!open) {
-        closeModal()
-      }
-    },
-    [closeModal]
-  )
-
-  const handleSave = useCallback(async () => {
-    if (!canSave) {
-      return
-    }
-    setSaving(true)
-    // Why: a stale failure from the previous attempt must not sit under the
-    // spinner for the whole in-flight save.
-    setSaveError(null)
-    try {
-      const updates = buildWorktreeMetaUpdates(draft, snapshot, liveLinks, reviewProvider)
-
-      const result =
-        executionHostId || suppressHostedReviewRefresh
-          ? await updateWorktreeMeta(worktreeId, updates, {
-              ...(executionHostId ? { executionHostId } : {}),
-              ...(suppressHostedReviewRefresh ? { suppressHostedReviewRefresh: true } : {})
-            })
-          : await updateWorktreeMeta(worktreeId, updates)
-      // Why: a failed save refetches and reverts the optimistic write. Closing
-      // here would report success for an edit that silently undid itself, and
-      // would discard the name, comment and PR changes in the same payload.
-      if (!result.ok) {
-        if (mountedRef.current) {
-          setSaveError(result.error)
-        }
-        return
-      }
-      closeModal()
-      // Why: follow-up refreshes should not turn a successful metadata save
-      // into a failed dialog.
-      try {
-        void Promise.resolve(afterSave?.({ worktreeId, updates })).catch(console.error)
-      } catch (error) {
-        console.error(error)
-      }
-    } finally {
-      if (mountedRef.current) {
-        setSaving(false)
-      }
-    }
-  }, [
-    worktreeId,
-    executionHostId,
-    suppressHostedReviewRefresh,
-    canSave,
-    draft,
-    snapshot,
-    liveLinks,
-    reviewProvider,
-    updateWorktreeMeta,
-    closeModal,
-    afterSave,
-    mountedRef
-  ])
-
-  const handleCommentKeyDown = useCallback(
-    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-      const isPlainEnter = e.key === 'Enter' && !e.shiftKey && !e.altKey && !e.metaKey && !e.ctrlKey
-      if (isPlainEnter || isScreenSubmitShortcut(e)) {
-        e.preventDefault()
-        e.stopPropagation()
-        handleSave()
-      }
-    },
-    [handleSave]
-  )
-
-  const handleIssueKeyDown = useCallback(
-    (e: React.KeyboardEvent<HTMLInputElement>) => {
-      if (e.key === 'Enter') {
-        e.preventDefault()
-        handleSave()
-      }
-    },
-    [handleSave]
-  )
-
-  return (
-    <Dialog open={isOpen} onOpenChange={handleOpenChange}>
-      <DialogContent
-        ref={setDialogElement}
-        className="max-w-md"
-        onOpenAutoFocus={(e) => {
-          e.preventDefault()
-          if (focusField === 'displayName') {
-            displayNameInputRef.current?.focus()
-          } else if (focusField === 'issue') {
-            issueInputRef.current?.focus()
-          } else if (focusField === 'pr') {
-            reviewInputRef.current?.focus()
-          } else {
-            textareaRef.current?.focus()
-          }
-        }}
-      >
-        <DialogHeader>
-          <DialogTitle className="text-sm">
-            {translate(
-              'auto.components.sidebar.WorktreeMetaDialog.382fd11a3e',
-              'Edit Worktree Details'
-            )}
-          </DialogTitle>
-          <DialogDescription className="text-xs">
-            {reviewProvider === 'gitlab'
-              ? translate(
-                  'auto.components.sidebar.WorktreeMetaDialog.gitlabDescription',
-                  'Edit issue links, merge request links, and notes for this workspace.'
-                )
-              : translate(
-                  'auto.components.sidebar.WorktreeMetaDialog.a0d191b7a7',
-                  'Edit issue links, pull request links, and notes for this workspace.'
-                )}
-          </DialogDescription>
-        </DialogHeader>
-
-        <div className="space-y-4">
-          <WorktreeDisplayNameField
-            disabled={saving}
-            inputRef={displayNameInputRef}
-            onEnter={handleSave}
-            onValueChange={setDisplayNameInput}
-            portalContainer={dialogElement}
-            value={displayNameInput}
-          />
-
-          <WorktreeIssueLinkField
-            inputRef={issueInputRef}
-            value={issueInput}
-            provider={issueProvider}
-            isInvalid={issueInvalid}
-            displacedLinkLabels={displacedLinkLabels}
-            isReadOnly={isFolderWorkspace}
-            canOpenIssue={canOpenIssue}
-            openingIssue={openingIssue}
-            openIssueFailed={openIssueFailed}
-            onValueChange={handleIssueInputChange}
-            onProviderChange={setIssueProvider}
-            onOpenIssue={handleOpenIssue}
-            onKeyDown={handleIssueKeyDown}
-          />
-
-          <WorktreeReviewLinkField
-            inputRef={reviewInputRef}
-            onKeyDown={handleIssueKeyDown}
-            onValueChange={setReviewInput}
-            provider={reviewProvider}
-            value={reviewInput}
-          />
-
-          <div className="space-y-1">
-            <label className="text-[11px] font-medium text-muted-foreground">
-              {translate('auto.components.sidebar.WorktreeMetaDialog.9c1d1e9b71', 'Comment')}
-            </label>
-            <ImeTextarea
-              ref={setCommentTextareaRef}
-              value={commentInput}
-              onChange={handleCommentChange}
-              onKeyDown={handleCommentKeyDown}
-              placeholder={translate(
-                'auto.components.sidebar.WorktreeMetaDialog.030d484fc0',
-                'Notes about this worktree...'
-              )}
-              rows={3}
-              className="w-full min-w-0 rounded-md border border-input bg-transparent px-3 py-2 text-xs shadow-xs transition-[color,box-shadow] outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 resize-none max-h-60 overflow-y-auto scrollbar-sleek"
-            />
-            <p className="text-[10px] text-muted-foreground">
-              {translate(
-                'auto.components.sidebar.WorktreeMetaDialog.7f0be5e9a6',
-                'Supports **markdown** — bold, lists, `code`, links. Press Enter or'
-              )}{' '}
-              {getScreenSubmitShortcutLabel()}{' '}
-              {translate(
-                'auto.components.sidebar.WorktreeMetaDialog.b48c271d39',
-                'to save, Shift+Enter for a new line.'
-              )}
-            </p>
-          </div>
-        </div>
-
-        {saveError ? (
-          <p role="alert" className="text-[11px] leading-[15px] text-destructive">
-            {saveError}
-          </p>
-        ) : null}
-
-        <DialogFooter>
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => handleOpenChange(false)}
-            className="text-xs"
-          >
-            {translate('auto.components.sidebar.WorktreeMetaDialog.3db0a2a593', 'Cancel')}
-          </Button>
-          <Button size="sm" onClick={handleSave} disabled={!canSave || saving} className="text-xs">
-            {saving
-              ? translate('auto.components.sidebar.WorktreeMetaDialog.61d6f612cf', 'Saving...')
-              : translate('auto.components.sidebar.WorktreeMetaDialog.2174f17011', 'Save')}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  )
-})
-
-export default WorktreeMetaDialog
diff --git a/src/renderer/src/components/sidebar/WorktreeMetaDialogDraft.tsx b/src/renderer/src/components/sidebar/WorktreeMetaDialogDraft.tsx
new file mode 100644
index 000000000000..d28a6be3d94f
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeMetaDialogDraft.tsx
@@ -0,0 +1,360 @@
+import React, { useCallback, useRef, useState } from 'react'
+import { getWorktreeMetaDialogOwner } from './worktree-meta-dialog-owner'
+import { Plus } from 'lucide-react'
+import { useAppStore } from '@/store'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Textarea } from '@/components/ui/textarea'
+import { Label } from '@/components/ui/label'
+import { useWorktreeMetaWorkspace } from './use-worktree-meta-workspace'
+import { getScreenSubmitShortcutLabel, isScreenSubmitShortcut } from '@/lib/screen-submit-shortcut'
+import { useMountedRef } from '@/hooks/useMountedRef'
+import { translate } from '@/i18n/i18n'
+import {
+  getWorktreeExecutionHostId,
+  parseExecutionHostId,
+  toRuntimeExecutionHostId
+} from '../../../../shared/execution-host'
+import { findIndexedRepoOwnerForHost } from '@/lib/worktree-runtime-owner-index'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import { WorktreeDisplayNameField } from './WorktreeDisplayNameField'
+import { WorktreeLinkedItemsField } from './WorktreeLinkedItemsField'
+import { buildWorkspaceAttachmentEdits } from './worktree-attachment-editing'
+import { resizeCommentTextarea } from './worktree-comment-textarea-sizing'
+import {
+  isImeOwnedKeyboardEvent,
+  useImeEnterGestureOwnership
+} from '@/lib/ime-composition-keyboard-event'
+
+const WorktreeMetaDialogDraft = React.memo(function WorktreeMetaDialogDraft() {
+  const activeModal = useAppStore((s) => s.activeModal)
+  const modalData = useAppStore((s) => s.modalData)
+  const closeModal = useAppStore((s) => s.closeModal)
+  const updateWorktreeMeta = useAppStore((s) => s.updateWorktreeMeta)
+  const isOpen = activeModal === 'edit-meta'
+  const dialogOwner = getWorktreeMetaDialogOwner({ activeModal, modalData })
+  const worktreeId = typeof modalData.worktreeId === 'string' ? modalData.worktreeId : ''
+  const ownerRepoId = typeof modalData.repoId === 'string' ? modalData.repoId : null
+  const executionHostId =
+    typeof modalData.executionHostId === 'string'
+      ? (parseExecutionHostId(modalData.executionHostId)?.id ?? undefined)
+      : undefined
+  const focusField = typeof modalData.focus === 'string' ? modalData.focus : 'comment'
+  const suppressHostedReviewRefresh = modalData.suppressHostedReviewRefresh === true
+  const suggestedReviewNumber =
+    typeof modalData.currentReview === 'number'
+      ? modalData.currentReview
+      : typeof modalData.currentPR === 'number'
+        ? modalData.currentPR
+        : null
+  const suggestedReviewProvider = modalData.reviewProvider === 'gitlab' ? 'gitlab' : 'github'
+  const { worktree, isFolderWorkspace } = useWorktreeMetaWorkspace({
+    worktreeId,
+    ownerRepoId,
+    executionHostId
+  })
+  const repo = useAppStore((s) =>
+    worktree && !isFolderWorkspace
+      ? (findIndexedRepoOwnerForHost(
+          s.repos,
+          worktree.repoId,
+          worktree.runtimeOwnerEnvironmentId
+            ? toRuntimeExecutionHostId(worktree.runtimeOwnerEnvironmentId)
+            : (executionHostId ?? getWorktreeExecutionHostId(worktree, undefined))
+        ) ?? undefined)
+      : undefined
+  )
+  const [initial] = useState(() => ({
+    displayName:
+      typeof modalData.currentDisplayName === 'string'
+        ? modalData.currentDisplayName
+        : (worktree?.displayName ?? ''),
+    comment:
+      typeof modalData.currentComment === 'string'
+        ? modalData.currentComment
+        : (worktree?.comment ?? ''),
+    items: getWorkspaceAttachments(worktree ?? {})
+  }))
+  const [displayNameInput, setDisplayNameInput] = useState(initial.displayName)
+  const [commentInput, setCommentInput] = useState(initial.comment)
+  const [items, setItems] = useState<WorkspaceAttachment[]>(initial.items)
+  const [notesOpen, setNotesOpen] = useState(
+    Boolean(initial.comment.trim()) || focusField === 'comment'
+  )
+  const [saving, setSaving] = useState(false)
+  const [saveError, setSaveError] = useState<string | null>(null)
+  const [dialogElement, setDialogElement] = useState<HTMLElement | null>(null)
+  const displayNameInputRef = useRef<HTMLInputElement>(null)
+  const linkInputRef = useRef<HTMLInputElement>(null)
+  const textareaRef = useRef<HTMLTextAreaElement>(null)
+  const focusNotesOnMountRef = useRef(false)
+  const mountedRef = useMountedRef()
+  const commentIme = useImeEnterGestureOwnership()
+
+  const handleSave = async (): Promise<void> => {
+    if (!worktreeId || !worktree || saving) {
+      return
+    }
+    setSaving(true)
+    setSaveError(null)
+    try {
+      const updates = {
+        ...(displayNameInput.trim() !== initial.displayName
+          ? { displayName: displayNameInput.trim() }
+          : {}),
+        ...(commentInput.trim() !== initial.comment ? { comment: commentInput.trim() } : {}),
+        ...buildWorkspaceAttachmentEdits({
+          initial: initial.items,
+          draft: items
+        })
+      }
+      const result =
+        executionHostId || suppressHostedReviewRefresh
+          ? await updateWorktreeMeta(worktreeId, updates, {
+              ...(executionHostId ? { executionHostId } : {}),
+              ...(suppressHostedReviewRefresh ? { suppressHostedReviewRefresh: true } : {})
+            })
+          : await updateWorktreeMeta(worktreeId, updates)
+      if (
+        !mountedRef.current ||
+        getWorktreeMetaDialogOwner(useAppStore.getState()) !== dialogOwner
+      ) {
+        return
+      }
+      if (!result.ok) {
+        if (mountedRef.current) {
+          setSaveError(result.error)
+        }
+        return
+      }
+      closeModal()
+      if (typeof modalData.afterSave === 'function') {
+        try {
+          void Promise.resolve(modalData.afterSave({ worktreeId, updates })).catch(console.error)
+        } catch (error) {
+          console.error(error)
+        }
+      }
+    } finally {
+      if (mountedRef.current) {
+        setSaving(false)
+      }
+    }
+  }
+
+  const setCommentTextareaRef = useCallback(
+    (textarea: HTMLTextAreaElement | null) => {
+      textareaRef.current = textarea
+      if (textarea && isOpen) {
+        resizeCommentTextarea(textarea)
+        if (focusNotesOnMountRef.current) {
+          focusNotesOnMountRef.current = false
+          textarea.focus()
+        }
+      }
+    },
+    [isOpen]
+  )
+
+  return (
+    <Dialog
+      open={isOpen}
+      onOpenChange={(open) => {
+        if (!open && !saving) {
+          closeModal()
+        }
+      }}
+    >
+      <DialogContent
+        ref={setDialogElement}
+        className="max-h-[calc(100vh-3rem)] grid-rows-[auto_minmax(0,1fr)_auto] sm:max-w-[640px]"
+        onEscapeKeyDown={(event) => {
+          const search = linkInputRef.current
+          if (
+            isImeOwnedKeyboardEvent(event) ||
+            textareaRef.current?.dataset.imeComposing === 'true' ||
+            search?.dataset.imeComposing === 'true' ||
+            (event.target === search && Boolean(search?.value))
+          ) {
+            event.preventDefault()
+          }
+        }}
+        onOpenAutoFocus={(event) => {
+          event.preventDefault()
+          if (focusField === 'displayName') {
+            displayNameInputRef.current?.focus()
+          } else if (focusField === 'issue' || focusField === 'pr' || focusField === 'links') {
+            linkInputRef.current?.focus()
+          } else {
+            textareaRef.current?.focus()
+          }
+        }}
+      >
+        <DialogHeader>
+          <DialogTitle>{translate('workspace.links.details', 'Workspace details')}</DialogTitle>
+          <DialogDescription>
+            {translate(
+              'workspace.links.description',
+              'Attach reviews and tasks, and keep notes for this workspace.'
+            )}
+          </DialogDescription>
+        </DialogHeader>
+        <div className="min-h-0 space-y-4 overflow-y-auto scrollbar-sleek">
+          <WorktreeDisplayNameField
+            disabled={saving}
+            inputRef={displayNameInputRef}
+            onEnter={handleSave}
+            onValueChange={setDisplayNameInput}
+            portalContainer={dialogElement}
+            value={displayNameInput}
+          />
+          <WorktreeLinkedItemsField
+            key={`${worktreeId}:${isOpen}`}
+            items={items}
+            onItemsChange={setItems}
+            onSave={handleSave}
+            repo={repo}
+            workspace={worktree}
+            isFolderWorkspace={isFolderWorkspace}
+            inputRef={linkInputRef}
+            initialInput={
+              suggestedReviewNumber !== null &&
+              !items.some(
+                (item) =>
+                  item.provider === suggestedReviewProvider &&
+                  item.type !== 'issue' &&
+                  item.number === suggestedReviewNumber
+              )
+                ? String(suggestedReviewNumber)
+                : ''
+            }
+            initialKind={
+              focusField === 'pr'
+                ? modalData.reviewProvider === 'gitlab'
+                  ? 'gitlab-mr'
+                  : 'github-pr'
+                : 'github-issue'
+            }
+            disabled={saving}
+          />
+          <div className="space-y-2">
+            <div className="flex items-center justify-between gap-2">
+              {notesOpen ? (
+                <Label htmlFor="workspace-comment">
+                  {translate('workspace.links.notes', 'Notes')}
+                </Label>
+              ) : (
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="xs"
+                  disabled={saving}
+                  onClick={() => {
+                    focusNotesOnMountRef.current = true
+                    setNotesOpen(true)
+                  }}
+                >
+                  <Plus />
+                  {translate('workspace.links.addNotes', 'Add notes')}
+                </Button>
+              )}
+              <span className="text-xs text-muted-foreground">
+                {translate('workspace.links.notesOptional', 'Optional · Markdown')}
+              </span>
+            </div>
+            {notesOpen ? (
+              <>
+                <Textarea
+                  id="workspace-comment"
+                  ref={setCommentTextareaRef}
+                  value={commentInput}
+                  disabled={saving}
+                  onChange={(event) => {
+                    setCommentInput(event.target.value)
+                    resizeCommentTextarea(event.currentTarget)
+                  }}
+                  onCompositionStart={(event) => {
+                    commentIme.setComposing(true)
+                    event.currentTarget.dataset.imeComposing = 'true'
+                  }}
+                  onCompositionEnd={(event) => {
+                    commentIme.setComposing(false)
+                    delete event.currentTarget.dataset.imeComposing
+                  }}
+                  onBlur={(event) => {
+                    commentIme.reset()
+                    delete event.currentTarget.dataset.imeComposing
+                  }}
+                  onKeyUp={commentIme.onKeyUp}
+                  onKeyDown={(event) => {
+                    if (
+                      commentIme.ownsKeyDown(event) ||
+                      isImeOwnedKeyboardEvent(event) ||
+                      commentIme.isComposing()
+                    ) {
+                      return
+                    }
+                    const plainEnter =
+                      event.key === 'Enter' &&
+                      !event.shiftKey &&
+                      !event.altKey &&
+                      !event.metaKey &&
+                      !event.ctrlKey
+                    if (plainEnter || isScreenSubmitShortcut(event)) {
+                      event.preventDefault()
+                      event.stopPropagation()
+                      void handleSave()
+                    }
+                  }}
+                  placeholder={translate(
+                    'auto.components.sidebar.WorktreeMetaDialog.030d484fc0',
+                    'Notes about this worktree...'
+                  )}
+                  rows={3}
+                  className="max-h-60 resize-none"
+                />
+                <p className="text-[11px] text-muted-foreground">
+                  {translate(
+                    'workspace.links.commentHelp',
+                    'Markdown supported. Enter or {{shortcut}} to save · Shift+Enter for a new line.',
+                    { shortcut: getScreenSubmitShortcutLabel() }
+                  )}
+                </p>
+              </>
+            ) : null}
+          </div>
+        </div>
+        <div className="space-y-2">
+          {saveError ? (
+            <p role="alert" className="text-xs text-destructive">
+              {saveError}
+            </p>
+          ) : null}
+          <DialogFooter>
+            <p className="mr-auto text-xs text-muted-foreground">
+              {translate('workspace.links.saveHint', 'Changes apply when you save')}
+            </p>
+            <Button variant="ghost" size="sm" disabled={saving} onClick={closeModal}>
+              {translate('auto.components.sidebar.WorktreeMetaDialog.3db0a2a593', 'Cancel')}
+            </Button>
+            <Button size="sm" onClick={handleSave} disabled={!worktreeId || !worktree || saving}>
+              {saving
+                ? translate('auto.components.sidebar.WorktreeMetaDialog.61d6f612cf', 'Saving...')
+                : translate('auto.components.sidebar.WorktreeMetaDialog.2174f17011', 'Save')}
+            </Button>
+          </DialogFooter>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+})
+
+export default WorktreeMetaDialogDraft
diff --git a/src/renderer/src/components/sidebar/WorktreeReferenceStack.test.tsx b/src/renderer/src/components/sidebar/WorktreeReferenceStack.test.tsx
new file mode 100644
index 000000000000..3a3c83b9744b
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeReferenceStack.test.tsx
@@ -0,0 +1,86 @@
+// @vitest-environment happy-dom
+import { cleanup, render } from '@testing-library/react'
+import { afterEach, describe, expect, it } from 'vitest'
+import { WorktreeReferenceStack } from './WorktreeReferenceStack'
+import { WorktreeCardMetaBadges } from './WorktreeCardMetaBadges'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { referenceAttachment, referenceReview } from './workspace-reference-fixtures.test-support'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+
+afterEach(cleanup)
+describe('fixed workspace reference stacks', () => {
+  it('preserves singleton brand/status icons without ghosts or a count', () => {
+    const linear: WorkspaceAttachment = {
+      provider: 'linear',
+      type: 'issue',
+      number: 0,
+      identifier: 'ENG-1'
+    }
+    const { container } = render(
+      <>
+        <WorktreeReferenceStack items={[referenceAttachment()]} />
+        <WorktreeReferenceStack items={[linear]} />
+      </>
+    )
+    expect(container.querySelectorAll('[data-reference-front]')).toHaveLength(2)
+    expect(container.querySelectorAll('svg')).toHaveLength(2)
+    expect(container.querySelector('[data-reference-count]')).toBeNull()
+    expect(container.querySelector('.workspace-reference-stack-ghost')).toBeNull()
+    expect(container.textContent).toContain('Linked PR #7')
+    expect(container.textContent).toContain('Linked Linear ENG-1')
+    expect(container.textContent).not.toContain('1 linked')
+  })
+  it('prioritizes the review needing attention over a legacy primary and preserves sibling states', () => {
+    const items = [referenceAttachment(1), referenceAttachment(2), referenceAttachment(3)]
+    const details = Object.fromEntries(
+      items.map((item, index) => [
+        getWorkspaceAttachmentKey(item),
+        {
+          title: '',
+          url: item.url ?? '',
+          review: referenceReview(item.number, {
+            state: index === 0 ? 'merged' : index === 1 ? 'draft' : 'open',
+            status: index === 2 ? 'failure' : 'success'
+          })
+        }
+      ])
+    )
+    const { container } = render(<WorktreeReferenceStack items={items} details={details} />)
+    expect(
+      container.querySelector('[data-reference-front] svg')?.classList.contains('text-rose-500/85')
+    ).toBe(true)
+    expect(container.querySelectorAll('.workspace-reference-stack-ghost')).toHaveLength(2)
+    expect(container.querySelector('[data-reference-count]')?.textContent).toBe('3')
+    expect(container.textContent).toContain('PR #2 · draft')
+  })
+  it('keeps two provider cells with the same six-pixel gap and no new metadata row at twelve references', () => {
+    const refs: WorkspaceAttachment[] = [
+      ...Array.from({ length: 12 }, (_, index) => referenceAttachment(index + 1)),
+      ...Array.from({ length: 12 }, (_, index) => ({
+        provider: 'linear' as const,
+        type: 'issue' as const,
+        number: 0,
+        identifier: `ENG-${index + 1}`
+      }))
+    ]
+    const { container } = render(
+      <WorktreeCardMetaBadges
+        linkedItemCount={refs.length}
+        referenceItems={refs}
+        issue={null}
+        linearIssue={null}
+        review={null}
+        comment={null}
+      />
+    )
+    const group = container.querySelector('[data-workspace-reference-groups]')
+    expect(group?.classList.contains('gap-1.5')).toBe(true)
+    expect(group?.querySelectorAll('[data-workspace-reference-stack]')).toHaveLength(2)
+    expect(
+      Array.from(group?.querySelectorAll('[data-reference-count]') ?? []).map(
+        (node) => node.textContent
+      )
+    ).toEqual(['12', '12'])
+    expect(container.textContent).not.toContain('24 linked')
+  })
+})
diff --git a/src/renderer/src/components/sidebar/WorktreeReferenceStack.tsx b/src/renderer/src/components/sidebar/WorktreeReferenceStack.tsx
new file mode 100644
index 000000000000..559697ac634d
--- /dev/null
+++ b/src/renderer/src/components/sidebar/WorktreeReferenceStack.tsx
@@ -0,0 +1,169 @@
+import React from 'react'
+import { CircleDot } from 'lucide-react'
+import { LinearIcon } from '@/components/icons/LinearIcon'
+import { JiraIcon } from '@/components/icons/JiraIcon'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import { ReviewIcon } from './worktree-review-helpers'
+import { workspaceAttachmentLabel } from './worktree-attachment-editing'
+import {
+  workspaceReferenceReview,
+  type WorkspaceReferenceDetailsMap
+} from './workspace-reference-details'
+import { translate } from '@/i18n/i18n'
+const EMPTY_DETAILS: WorkspaceReferenceDetailsMap = {}
+
+function singleReferenceLabel(item: WorkspaceAttachment): string {
+  if (item.provider === 'linear') {
+    return translate(
+      'auto.components.sidebar.WorktreeCardMeta.b105fd3057',
+      'Linked Linear {{value0}}',
+      { value0: item.identifier ?? item.linearIdentifier }
+    )
+  }
+  if (item.provider === 'jira') {
+    return translate(
+      'auto.components.sidebar.WorktreeCardMeta.linkedJira',
+      'Linked Jira {{value0}}',
+      { value0: item.identifier ?? item.jiraIdentifier }
+    )
+  }
+  return item.type === 'issue'
+    ? translate('auto.components.sidebar.WorktreeCardMeta.3f2649eeb8', 'Linked issue #{{value0}}', {
+        value0: item.number
+      })
+    : translate(
+        'auto.components.sidebar.WorktreeCardMeta.3ea2702e62',
+        'Linked {{value0}} #{{value1}}',
+        { value0: item.type === 'mr' ? 'MR' : 'PR', value1: item.number }
+      )
+}
+
+function ReferenceGlyph({
+  item,
+  details
+}: {
+  item: WorkspaceAttachment
+  details: WorkspaceReferenceDetailsMap
+}): React.JSX.Element {
+  const review = workspaceReferenceReview(item, details[getWorkspaceAttachmentKey(item)])
+  if (review) {
+    return <ReviewIcon review={review} />
+  }
+  if (item.provider === 'linear') {
+    return <LinearIcon className="text-muted-foreground" />
+  }
+  if (item.provider === 'jira') {
+    return <JiraIcon className="text-muted-foreground" />
+  }
+  return <CircleDot className="text-muted-foreground" />
+}
+
+function priority(item: WorkspaceAttachment, details: WorkspaceReferenceDetailsMap): number {
+  const key = getWorkspaceAttachmentKey(item)
+  const detail = details[key]
+  if (item.type !== 'issue') {
+    const review = detail?.review
+    return review?.state === 'open'
+      ? review.status === 'failure'
+        ? 0
+        : review.status === 'pending'
+          ? 1
+          : 2
+      : review?.state === 'draft'
+        ? 3
+        : review?.state === 'merged'
+          ? 4
+          : review?.state === 'closed'
+            ? 5
+            : 6
+  }
+  const state = detail?.stateName?.toLowerCase() ?? ''
+  if (detail?.stateType) {
+    return detail.stateType === 'started'
+      ? 0
+      : detail.stateType === 'unstarted' || detail.stateType === 'backlog'
+        ? 1
+        : detail.stateType === 'completed'
+          ? 2
+          : detail.stateType === 'canceled'
+            ? 3
+            : 4
+  }
+  return /progress|started|doing|active/.test(state)
+    ? 0
+    : /todo|backlog|unstarted/.test(state)
+      ? 1
+      : /done|complete|resolved/.test(state)
+        ? 2
+        : /cancel|duplicate/.test(state)
+          ? 3
+          : 4
+}
+
+export function WorktreeReferenceStack({
+  items,
+  details = EMPTY_DETAILS
+}: {
+  items: readonly WorkspaceAttachment[]
+  details?: WorkspaceReferenceDetailsMap
+}): React.JSX.Element | null {
+  const ordered = [...items].sort((a, b) => priority(a, details) - priority(b, details))
+  const front = ordered[0]
+  if (!front) {
+    return null
+  }
+  const summary = ordered
+    .map((item) => {
+      const detail = details[getWorkspaceAttachmentKey(item)]
+      return [
+        workspaceAttachmentLabel(item),
+        detail?.review?.state ?? detail?.stateName,
+        detail?.review?.status
+      ]
+        .filter(Boolean)
+        .join(' · ')
+    })
+    .join(', ')
+  return (
+    <span
+      className="workspace-reference-stack"
+      data-workspace-reference-stack={front.type === 'issue' ? front.provider : 'review'}
+    >
+      {ordered
+        .slice(1, 3)
+        .toReversed()
+        .map((item, index, ghosts) => (
+          <span
+            key={getWorkspaceAttachmentKey(item)}
+            className="workspace-reference-stack-ghost"
+            data-depth={ghosts.length - index}
+            aria-hidden
+          >
+            <ReferenceGlyph item={item} details={details} />
+          </span>
+        ))}
+      <span className="workspace-reference-stack-front" data-reference-front="" aria-hidden>
+        <ReferenceGlyph item={front} details={details} />
+      </span>
+      {items.length > 1 ? (
+        <span
+          className="workspace-reference-stack-count"
+          data-reference-count=""
+          data-multiple-digits={items.length > 9}
+          aria-hidden
+        >
+          {items.length}
+        </span>
+      ) : null}
+      <span className="sr-only">
+        {items.length === 1
+          ? singleReferenceLabel(front)
+          : translate('workspace.links.stackSummary', '{{count}} linked: {{references}}', {
+              count: items.length,
+              references: summary
+            })}
+      </span>
+    </span>
+  )
+}
diff --git a/src/renderer/src/components/sidebar/WorktreeReviewLinkField.tsx b/src/renderer/src/components/sidebar/WorktreeReviewLinkField.tsx
deleted file mode 100644
index 76c4adb3f04a..000000000000
--- a/src/renderer/src/components/sidebar/WorktreeReviewLinkField.tsx
+++ /dev/null
@@ -1,60 +0,0 @@
-import type { RefObject } from 'react'
-import { Input } from '@/components/ui/input'
-import { translate } from '@/i18n/i18n'
-import type { WorktreeReviewProvider } from './worktree-meta-updates'
-
-type WorktreeReviewLinkFieldProps = {
-  inputRef: RefObject<HTMLInputElement | null>
-  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void
-  onValueChange: (value: string) => void
-  provider: WorktreeReviewProvider
-  value: string
-}
-
-export function WorktreeReviewLinkField({
-  inputRef,
-  onKeyDown,
-  onValueChange,
-  provider,
-  value
-}: WorktreeReviewLinkFieldProps): React.JSX.Element {
-  const isGitLab = provider === 'gitlab'
-  return (
-    <div className="space-y-1">
-      <label className="text-[11px] font-medium text-muted-foreground">
-        {isGitLab
-          ? translate('auto.components.sidebar.WorktreeMetaDialog.gitlabMR', 'GitLab MR')
-          : translate('auto.components.sidebar.WorktreeMetaDialog.1b91db7e14', 'GH PR')}
-      </label>
-      <Input
-        ref={inputRef}
-        value={value}
-        onChange={(event) => onValueChange(event.target.value)}
-        onKeyDown={onKeyDown}
-        placeholder={
-          isGitLab
-            ? translate(
-                'auto.components.sidebar.WorktreeMetaDialog.gitlabPlaceholder',
-                'MR ! or GitLab URL'
-              )
-            : translate(
-                'auto.components.sidebar.WorktreeMetaDialog.077a4f7b5c',
-                'PR # or GitHub URL'
-              )
-        }
-        className="h-8 text-xs"
-      />
-      <p className="text-[10px] text-muted-foreground">
-        {isGitLab
-          ? translate(
-              'auto.components.sidebar.WorktreeMetaDialog.gitlabHelp',
-              'Paste a merge request URL, or enter a number. Leave blank to remove the link.'
-            )
-          : translate(
-              'auto.components.sidebar.WorktreeMetaDialog.5ae06f40fd',
-              'Paste a pull request URL, or enter a number. Leave blank to remove the link.'
-            )}
-      </p>
-    </div>
-  )
-}
diff --git a/src/renderer/src/components/sidebar/use-workspace-reference-details.test.tsx b/src/renderer/src/components/sidebar/use-workspace-reference-details.test.tsx
new file mode 100644
index 000000000000..317f7c70918c
--- /dev/null
+++ b/src/renderer/src/components/sidebar/use-workspace-reference-details.test.tsx
@@ -0,0 +1,296 @@
+// @vitest-environment happy-dom
+import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import type * as VisibleReviewTargets from '@/store/github/visible-hosted-review-refresh-targets'
+import { useWorkspaceReferenceDetails } from './use-workspace-reference-details'
+import { useVisibleHostedReviewRefresh } from '@/app-shell/use-visible-hosted-review-refresh'
+import { readWorkspaceReferenceDetails } from './workspace-reference-detail-read'
+import { getWorkspaceReferenceRequest } from './workspace-reference-details'
+import {
+  normalizeTaskSourceContext,
+  getTaskSourceCacheScope
+} from '../../../../shared/task-source-context'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { _clearHostedReviewRequestGenerationsForTest } from '@/store/slices/hosted-review-request-state'
+import { getHostedReviewCacheKey } from '@/store/slices/hosted-review-cache-identity'
+import {
+  referenceAttachment,
+  referenceRepo,
+  referenceReview,
+  referenceWorkspace,
+  referenceLinearIssue
+} from './workspace-reference-fixtures.test-support'
+
+vi.mock('@/store', async () => {
+  const browserWindow = globalThis.window
+  const { createTestStore } = await import('@/store/slices/github-slice-test-harness')
+  globalThis.window = browserWindow
+  return { useAppStore: createTestStore() }
+})
+// Branch refresh has its own integration suite; this suite exercises the additional exact targets.
+vi.mock('@/store/github/visible-hosted-review-refresh-targets', async (original) => ({
+  ...(await original<typeof VisibleReviewTargets>()),
+  getVisibleHostedReviewRefreshTargets: () => [],
+  visibleHostedReviewRefreshInputsChanged: () => true
+}))
+const mocks = vi.hoisted(() => ({ web: false }))
+vi.mock('@/lib/web-client-location', () => ({ isWebClientLocation: () => mocks.web }))
+const read = vi.fn<(...args: unknown[]) => Promise<ReturnType<typeof referenceReview> | null>>()
+const workspace = {
+  ...referenceWorkspace,
+  linkedPR: null,
+  linkedItems: [referenceAttachment(1), referenceAttachment(2)]
+}
+function mount(open = false, enabled = true) {
+  return renderHook(() => {
+    useVisibleHostedReviewRefresh({ enabled })
+    return useWorkspaceReferenceDetails(workspace, referenceRepo, null, open)
+  })
+}
+beforeEach(() => {
+  vi.clearAllMocks()
+  _clearHostedReviewRequestGenerationsForTest()
+  mocks.web = false
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { hostedReview: { forBranch: read } }
+  })
+  Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' })
+  read.mockResolvedValue(null)
+  useAppStore.setState({
+    settings: null,
+    repos: [referenceRepo],
+    worktreesByRepo: { repo: [workspace] },
+    visibleReviewWorktreeIds: [workspace.id],
+    activeWorktreeId: null,
+    hostedReviewCache: {},
+    prCache: {},
+    linearIssueCache: {},
+    jiraIssueSummaryCache: {},
+    issueCache: {},
+    tabsByWorktree: {},
+    ptyIdsByTabId: {},
+    browserTabsByWorktree: {
+      [workspace.id]: [
+        {
+          id: 'browser',
+          worktreeId: workspace.id,
+          url: '',
+          title: '',
+          loading: false,
+          faviconUrl: null,
+          canGoBack: false,
+          canGoForward: false,
+          loadError: null,
+          createdAt: 1
+        }
+      ]
+    },
+    unifiedTabsByWorktree: {},
+    agentStatusByPaneKey: {},
+    agentStatusEpoch: 0,
+    sshConnectionStates: new Map()
+  })
+})
+afterEach(cleanup)
+
+it('automatically reads every attached review without a mounted reference hook', async () => {
+  renderHook(() => useVisibleHostedReviewRefresh({ enabled: true }))
+  await waitFor(() => expect(read).toHaveBeenCalledTimes(2))
+})
+it.each(['not-visible', 'hidden', 'sleeping', 'archived', 'bare', 'unready', 'web-unselected'])(
+  'does not poll %s workspaces',
+  async (condition) => {
+    if (condition === 'not-visible') {
+      useAppStore.setState({ visibleReviewWorktreeIds: [] })
+    }
+    if (condition === 'hidden') {
+      Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' })
+    }
+    if (condition === 'sleeping') {
+      useAppStore.setState({ browserTabsByWorktree: {} })
+    }
+    if (condition === 'archived' || condition === 'bare') {
+      useAppStore.setState({
+        worktreesByRepo: {
+          repo: [
+            { ...workspace, isArchived: condition === 'archived', isBare: condition === 'bare' }
+          ]
+        }
+      })
+    }
+    mocks.web = condition === 'web-unselected'
+    mount(false, condition !== 'unready')
+    await act(async () => {
+      await Promise.resolve()
+    })
+    expect(read).not.toHaveBeenCalled()
+  }
+)
+it('shares exact results across hover and scheduler without replacing the primary branch cache', async () => {
+  const primaryKey = getHostedReviewCacheKey(
+    referenceRepo.path,
+    workspace.branch,
+    null,
+    referenceRepo.id,
+    null,
+    null,
+    true
+  )
+  const primary = { data: referenceReview(7), fetchedAt: Date.now() }
+  useAppStore.setState({ hostedReviewCache: { [primaryKey]: primary } })
+  read.mockImplementation(async (args) =>
+    referenceReview(
+      typeof args === 'object' &&
+        args &&
+        'linkedGitHubPR' in args &&
+        typeof args.linkedGitHubPR === 'number'
+        ? args.linkedGitHubPR
+        : 0
+    )
+  )
+  const hook = mount(true)
+  await waitFor(() => expect(Object.values(hook.result.current).filter(Boolean)).toHaveLength(2))
+  expect(read).toHaveBeenCalledTimes(2)
+  expect(useAppStore.getState().hostedReviewCache[primaryKey]).toBe(primary)
+})
+it('keeps failed exact refreshes stale while retaining their last known details', async () => {
+  const request = getWorkspaceReferenceRequest(referenceAttachment(1), workspace, referenceRepo)
+  useAppStore.setState({
+    hostedReviewCache: {
+      [request.key]: { data: referenceReview(1), fetchedAt: Date.now() - 61_000 }
+    }
+  })
+  read.mockRejectedValue(new Error('Disconnected'))
+  await readWorkspaceReferenceDetails(request)
+  const hook = renderHook(() => useWorkspaceReferenceDetails(workspace, referenceRepo, null, false))
+  expect(hook.result.current[getWorkspaceAttachmentKey(request.item)]).toMatchObject({
+    stale: true,
+    review: { number: 1 }
+  })
+})
+it.each(['host', 'remote', 'account'])('drops cached success after %s rebinding', (kind) => {
+  const request = getWorkspaceReferenceRequest(referenceAttachment(1), workspace, referenceRepo)
+  useAppStore.setState({
+    hostedReviewCache: { [request.key]: { data: referenceReview(1), fetchedAt: Date.now() } }
+  })
+  const hook = renderHook(
+    ({ repo }) => useWorkspaceReferenceDetails(workspace, repo, null, false),
+    { initialProps: { repo: referenceRepo } }
+  )
+  expect(hook.result.current[getWorkspaceAttachmentKey(request.item)]?.review?.status).toBe(
+    'success'
+  )
+  hook.rerender({
+    repo: {
+      ...referenceRepo,
+      ...(kind === 'host'
+        ? { executionHostId: 'runtime:other' }
+        : kind === 'account'
+          ? { ghAccount: { host: 'github.com', user: 'other' } }
+          : {
+              gitRemoteIdentity: {
+                canonicalKey: 'github.com/other/project',
+                remoteName: 'origin',
+                remoteUrl: 'https://github.com/other/project.git'
+              }
+            })
+    }
+  })
+  expect(hook.result.current[getWorkspaceAttachmentKey(request.item)]).toBeUndefined()
+})
+it('bounds native reads and cancels queued hover demand without adding a negative cache entry', async () => {
+  const finish: (() => void)[] = []
+  read.mockImplementation(() => new Promise((resolve) => finish.push(() => resolve(null))))
+  const requests = [20, 21, 22, 23].map((number) =>
+    getWorkspaceReferenceRequest(referenceAttachment(number), workspace, referenceRepo)
+  )
+  const active = requests.slice(0, 3).map((request) => readWorkspaceReferenceDetails(request))
+  await waitFor(() => expect(read).toHaveBeenCalledTimes(3))
+  const controller = new AbortController()
+  const queued = readWorkspaceReferenceDetails(requests[3], controller.signal).catch(() => null)
+  controller.abort()
+  await queued
+  finish.forEach((resolve) => resolve())
+  await Promise.all(active)
+  expect(read).toHaveBeenCalledTimes(3)
+  expect(useAppStore.getState().hostedReviewCache[requests[3].key]).toBeUndefined()
+})
+it.each(['hide', 'unmount'])('stops queued scheduler work on %s', async (action) => {
+  const finish: (() => void)[] = []
+  read.mockImplementation(() => new Promise((resolve) => finish.push(() => resolve(null))))
+  useAppStore.setState({
+    worktreesByRepo: {
+      repo: [{ ...workspace, linkedItems: [20, 21, 22, 23, 24].map(referenceAttachment) }]
+    }
+  })
+  const hook = mount()
+  await waitFor(() => expect(read).toHaveBeenCalledTimes(3))
+  if (action === 'unmount') {
+    hook.unmount()
+  } else {
+    act(() => {
+      Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' })
+      document.dispatchEvent(new Event('visibilitychange'))
+    })
+  }
+  await act(async () => {
+    finish.forEach((resolve) => resolve())
+    await Promise.resolve()
+  })
+  expect(read).toHaveBeenCalledTimes(3)
+})
+it('does not revive primary success after an exact lookup returns unavailable', async () => {
+  const request = getWorkspaceReferenceRequest(referenceAttachment(1), workspace, referenceRepo)
+  await readWorkspaceReferenceDetails(request)
+  const hook = renderHook(() =>
+    useWorkspaceReferenceDetails(workspace, referenceRepo, referenceReview(1), false)
+  )
+  expect(hook.result.current[getWorkspaceAttachmentKey(request.item)]).toBeUndefined()
+})
+
+it('projects task mutations directly from the source provider cache', () => {
+  const source = normalizeTaskSourceContext({
+    provider: 'linear',
+    projectId: 'project',
+    hostId: 'local'
+  })
+  if (!source) {
+    throw new Error('Invalid fixture')
+  }
+  const item = {
+    provider: 'linear',
+    type: 'issue',
+    number: 0,
+    identifier: 'ENG-1',
+    taskSourceContext: source
+  } as const
+  const key = `${getTaskSourceCacheScope(source)}::all::ENG-1`
+  useAppStore.setState({
+    linearIssueCache: { [key]: { data: referenceLinearIssue(), fetchedAt: Date.now() } }
+  })
+  const hook = renderHook(() =>
+    useWorkspaceReferenceDetails({ ...workspace, linkedItems: [item] }, referenceRepo, null, false)
+  )
+  expect(hook.result.current[getWorkspaceAttachmentKey(item)]?.title).toBe('Task')
+  act(() =>
+    useAppStore.setState({
+      linearIssueCache: {
+        [key]: { data: referenceLinearIssue({ title: 'Edited' }), fetchedAt: Date.now() }
+      }
+    })
+  )
+  expect(hook.result.current[getWorkspaceAttachmentKey(item)]?.title).toBe('Edited')
+  const otherAccount = { ...item, taskSourceContext: { ...source, accountLabel: 'other' } }
+  const other = renderHook(() =>
+    useWorkspaceReferenceDetails(
+      { ...workspace, linkedItems: [otherAccount] },
+      referenceRepo,
+      null,
+      false
+    )
+  )
+  expect(other.result.current[getWorkspaceAttachmentKey(otherAccount)]).toBeUndefined()
+  expect(read).not.toHaveBeenCalled()
+})
diff --git a/src/renderer/src/components/sidebar/use-workspace-reference-details.ts b/src/renderer/src/components/sidebar/use-workspace-reference-details.ts
new file mode 100644
index 000000000000..ef116796e279
--- /dev/null
+++ b/src/renderer/src/components/sidebar/use-workspace-reference-details.ts
@@ -0,0 +1,69 @@
+import { useEffect, useMemo } from 'react'
+import { useShallow } from 'zustand/react/shallow'
+import { useAppStore } from '@/store'
+import type { Repo } from '../../../../shared/repo-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
+import { canReadWorkspaceReferenceReview } from './workspace-reference-review-source'
+import {
+  getWorkspaceReferenceRequest,
+  getWorkspaceReferenceRuntimeVersion,
+  matchWorkspaceReferenceReview,
+  type WorkspaceReferenceDetailsMap
+} from './workspace-reference-details'
+import {
+  getWorkspaceReferenceLookup,
+  readWorkspaceReferenceDetails
+} from './workspace-reference-detail-read'
+
+export function useWorkspaceReferenceDetails(
+  workspace: Worktree,
+  repo: Repo | undefined,
+  review: WorktreeCardPrDisplay | null,
+  hoverOpen: boolean
+): WorkspaceReferenceDetailsMap {
+  const runtimeVersion = getWorkspaceReferenceRuntimeVersion(workspace, repo)
+  const requests = useMemo(
+    () =>
+      getWorkspaceAttachments(workspace).map((item) => ({
+        ...getWorkspaceReferenceRequest(item, workspace, repo, runtimeVersion),
+        knownProvider: review?.state ? review.provider : undefined
+      })),
+    [workspace, repo, runtimeVersion, review?.state, review?.provider]
+  )
+  useAppStore(
+    useShallow((state) =>
+      requests.map((request) => getWorkspaceReferenceLookup(request, state)?.rawEntry)
+    )
+  )
+  useEffect(() => {
+    if (!hoverOpen) {
+      return
+    }
+    const controller = new AbortController()
+    for (const request of requests) {
+      void readWorkspaceReferenceDetails(request, controller.signal).catch(() => {})
+    }
+    return () => controller.abort()
+  }, [requests, hoverOpen])
+  const matching = requests.filter(
+    (request) =>
+      matchWorkspaceReferenceReview(request.item, review) &&
+      canReadWorkspaceReferenceReview(request, review?.provider)
+  )
+  return Object.fromEntries(
+    requests.map((request) => {
+      const entry = getWorkspaceReferenceLookup(request, useAppStore.getState())?.entry
+      const primary =
+        review?.url && review.state && matching.length === 1 && matching[0] === request
+          ? { title: review.title, url: review.url, review, stale: true }
+          : undefined
+      return [
+        getWorkspaceAttachmentKey(request.item),
+        entry ? (entry.data ? { ...entry.data, stale: entry.stale } : undefined) : primary
+      ]
+    })
+  )
+}
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-controller.ts b/src/renderer/src/components/sidebar/use-worktree-card-controller.ts
index 8a608f371252..92424055d871 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-controller.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-controller.ts
@@ -1,3 +1,6 @@
+import { useWorkspaceReferenceDetails } from './use-workspace-reference-details'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { summarizeWorkspaceReviewChecks } from '../../../../shared/workspace-review-checks'
 import { canShowWorkspaceDeleteQuickAction } from './workspace-delete-quick-action'
 import { useWorktreeCardDetailsHoverControl } from './worktree-card-details-hover-state'
 import type { ResolvedWorktreeCardProps } from './worktree-card-model'
@@ -43,6 +46,16 @@ export function useWorktreeCardController(props: ResolvedWorktreeCardProps) {
   const shouldRefreshHostedReview = foundation.newCardStyle ? showStatus : showPR
   const detailsHoverControl = useWorktreeCardDetailsHoverControl()
   const hoverDetailsOpen = detailsHoverControl.hoverOpen
+  const referenceDetails = useWorkspaceReferenceDetails(
+    worktree,
+    repo,
+    review.prDisplay,
+    hoverDetailsOpen
+  )
+  const reviewChecks = summarizeWorkspaceReviewChecks(
+    getWorkspaceAttachments(worktree),
+    referenceDetails
+  )
 
   useWorktreeCardLifecycleEffects({
     worktree,
@@ -63,6 +76,8 @@ export function useWorktreeCardController(props: ResolvedWorktreeCardProps) {
     issueCacheKey: review.issueCacheKey,
     fetchIssue: foundation.fetchIssue,
     showLinearIssue,
+    linearSourceContext: review.linearSourceContext,
+    linearWorkspaceId: review.linearWorkspaceId,
     fetchLinearIssue: foundation.fetchLinearIssue
   })
 
@@ -146,6 +161,8 @@ export function useWorktreeCardController(props: ResolvedWorktreeCardProps) {
     ...review,
     ...linked,
     detailsHoverControl,
+    referenceDetails,
+    reviewChecks,
     showStatus,
     showIssue,
     showLinearIssue,
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-foundation.ts b/src/renderer/src/components/sidebar/use-worktree-card-foundation.ts
index d8ec20bb45a0..376bf0037112 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-foundation.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-foundation.ts
@@ -65,6 +65,21 @@ export function useWorktreeCardFoundation({
     [worktree, openModal]
   )
 
+  const handleManageLinks = useCallback(
+    (event: React.MouseEvent) => {
+      event.stopPropagation()
+      openModal('edit-meta', {
+        worktreeId: worktree.id,
+        repoId: worktree.repoId,
+        executionHostId: worktree.hostId,
+        currentDisplayName: worktree.displayName,
+        currentComment: worktree.comment,
+        focus: 'links'
+      })
+    },
+    [worktree, openModal]
+  )
+
   const handleEditComment = useCallback(
     (e: React.MouseEvent) => {
       e.stopPropagation()
@@ -220,6 +235,7 @@ export function useWorktreeCardFoundation({
     newCardStyle,
     compactCards,
     handleEditIssue,
+    handleManageLinks,
     handleEditComment,
     handleOpenAutomation,
     handleOpenAutomationRun,
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-lifecycle-effects.ts b/src/renderer/src/components/sidebar/use-worktree-card-lifecycle-effects.ts
index 0d130ceb815d..dd28e95099b2 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-lifecycle-effects.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-lifecycle-effects.ts
@@ -28,6 +28,8 @@ export function useWorktreeCardLifecycleEffects({
   issueCacheKey,
   fetchIssue,
   showLinearIssue,
+  linearSourceContext,
+  linearWorkspaceId,
   fetchLinearIssue
 }: Pick<WorktreeCardProps, 'worktree' | 'repo'> &
   Pick<
@@ -41,6 +43,8 @@ export function useWorktreeCardLifecycleEffects({
     | 'linkedGiteaPR'
     | 'branch'
     | 'issueCacheKey'
+    | 'linearSourceContext'
+    | 'linearWorkspaceId'
   > &
   Pick<
     Foundation,
@@ -156,7 +160,9 @@ export function useWorktreeCardLifecycleEffects({
       if (!isWindowVisible()) {
         return
       }
-      void fetchLinearIssue(linearIssueId, 'all')
+      void fetchLinearIssue(linearIssueId, linearWorkspaceId, {
+        sourceContext: linearSourceContext
+      })
     }
     refreshLinearIssueIfVisible()
     window.addEventListener('focus', refreshLinearIssueIfVisible)
@@ -165,18 +171,28 @@ export function useWorktreeCardLifecycleEffects({
       window.removeEventListener('focus', refreshLinearIssueIfVisible)
       document.removeEventListener('visibilitychange', refreshLinearIssueIfVisible)
     }
-  }, [worktree.linkedLinearIssue, fetchLinearIssue, showLinearIssue])
+  }, [
+    worktree.linkedLinearIssue,
+    fetchLinearIssue,
+    showLinearIssue,
+    linearSourceContext,
+    linearWorkspaceId
+  ])
 
   useEffect(() => {
     if (!newCardStyle || !hoverDetailsOpen || showLinearIssue || !worktree.linkedLinearIssue) {
       return
     }
-    void fetchLinearIssue(worktree.linkedLinearIssue, 'all')
+    void fetchLinearIssue(worktree.linkedLinearIssue, linearWorkspaceId, {
+      sourceContext: linearSourceContext
+    })
   }, [
     newCardStyle,
     hoverDetailsOpen,
     showLinearIssue,
     worktree.linkedLinearIssue,
+    linearSourceContext,
+    linearWorkspaceId,
     fetchLinearIssue
   ])
 }
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-linked-details.ts b/src/renderer/src/components/sidebar/use-worktree-card-linked-details.ts
index a2ec8e0774e0..fb3f85e93106 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-linked-details.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-linked-details.ts
@@ -1,7 +1,5 @@
-import React from 'react'
-
 import { translate } from '@/i18n/i18n'
-import { useAppStore } from '@/store'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
 import type { IssueInfo } from '../../../../shared/github/pull-request-types'
 import type { LinearIssue } from '../../../../shared/linear/issue-types'
 import { getWorktreeCardJiraIssueDisplay } from './worktree-card-jira-issue-display'
@@ -47,46 +45,16 @@ export function useWorktreeCardLinkedDetails({
           title: issue === null ? 'Issue details unavailable' : 'Loading issue...'
         }
       : null)
-  const linearStatus = useAppStore((s) => s.linearStatus)
   const linearIssue: LinearIssue | null | undefined = worktree.linkedLinearIssue
     ? (linearIssueEntry?.data ?? linearIssueFallbackEntry?.data)
     : null
 
-  // Why: build a fallback Linear URL from org key + identifier while full issue data is still loading, so the link stays navigable.
-  const linearOrgUrlKey = linearStatus?.viewer?.organizationUrlKey
-  const linearWorkspaceUrlKeys = linearStatus?.workspaces?.map((ws) => ({
-    id: ws.id,
-    organizationUrlKey: ws.organizationUrlKey
-  }))
-  const linearIssueUrlFallback = React.useMemo(() => {
-    if (!worktree.linkedLinearIssue || linearIssue?.url) {
-      return undefined
-    }
-
-    // Try to get the orgUrlKey from the issue's workspace if we have workspaceId
-    let orgUrlKey: string | undefined
-    if (linearIssue?.workspaceId && linearWorkspaceUrlKeys) {
-      const issueWorkspace = linearWorkspaceUrlKeys.find((ws) => ws.id === linearIssue.workspaceId)
-      orgUrlKey = issueWorkspace?.organizationUrlKey
-    }
-
-    // Fall back to current viewer's org if no workspace match
-    if (!orgUrlKey) {
-      orgUrlKey = linearOrgUrlKey
-    }
-
-    if (!orgUrlKey) {
-      return undefined
-    }
-
-    return `https://linear.app/${encodeURIComponent(orgUrlKey)}/issue/${encodeURIComponent(worktree.linkedLinearIssue)}`
-  }, [
-    worktree.linkedLinearIssue,
-    linearIssue?.url,
-    linearIssue?.workspaceId,
-    linearOrgUrlKey,
-    linearWorkspaceUrlKeys
-  ])
+  const linearReferences = getWorkspaceAttachments(worktree).filter(
+    (item) =>
+      item.provider === 'linear' &&
+      (item.identifier ?? item.linearIdentifier) === worktree.linkedLinearIssue
+  )
+  const linearIssueUrlFallback = linearReferences.length === 1 ? linearReferences[0].url : undefined
 
   const linearIssueDisplay = worktree.linkedLinearIssue
     ? linearIssue
@@ -95,6 +63,7 @@ export function useWorktreeCardLinkedDetails({
           title: linearIssue.title,
           url: linearIssue.url,
           stateName: linearIssue.state?.name,
+          stateType: linearIssue.state?.type,
           labels: linearIssue.labels
         }
       : {
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-review-details.ts b/src/renderer/src/components/sidebar/use-worktree-card-review-details.ts
index 9d217bd54bee..097d9a19bb42 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-review-details.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-review-details.ts
@@ -1,3 +1,7 @@
+import { useMemo } from 'react'
+import { getLinearReadScope, scopedLinearCacheKey } from '@/store/slices/linear/linear-slice-scope'
+import { getWorkspaceAttachmentSourceContext } from './workspace-attachment-source-result'
+import { getWorkspaceReferenceLinearWorkspaceId } from './workspace-reference-details'
 import { getWorktreeGitIdentityDisplay } from '@/lib/worktree-git-identity-display'
 import { useAppStore } from '@/store'
 import { getGitHubPRCacheKey } from '@/store/slices/github-cache-key'
@@ -79,8 +83,21 @@ export function useWorktreeCardReviewDetails({
           true
         )
       : ''
-  // Why: use 'all' — the issue may belong to a different Linear workspace than the selected one.
-  const linearIssueCacheKey = worktree.linkedLinearIssue ? `all::${worktree.linkedLinearIssue}` : ''
+  // Saved workspace bindings keep equal Linear identifiers separate.
+  const linearSourceContext = useMemo(
+    () => getWorkspaceAttachmentSourceContext('linear', repo, worktree),
+    [repo, worktree]
+  )
+  const linearWorkspaceId = getWorkspaceReferenceLinearWorkspaceId(
+    worktree.linkedLinearIssueWorkspaceId,
+    linearSourceContext
+  )
+  const linearIssueCacheKey = worktree.linkedLinearIssue
+    ? scopedLinearCacheKey(
+        getLinearReadScope(settings, linearSourceContext),
+        `${linearWorkspaceId}::${worktree.linkedLinearIssue}`
+      )
+    : ''
 
   // Subscribe to ONLY the specific cache entry, not entire review/issue caches.
   const hostedReviewEntry = useAppStore((s) =>
@@ -92,7 +109,9 @@ export function useWorktreeCardReviewDetails({
     linearIssueCacheKey ? s.linearIssueCache[linearIssueCacheKey] : undefined
   )
   const linearIssueFallbackEntry = useAppStore((s) =>
-    worktree.linkedLinearIssue ? s.linearIssueCache[worktree.linkedLinearIssue] : undefined
+    !linearSourceContext && worktree.linkedLinearIssue
+      ? s.linearIssueCache[worktree.linkedLinearIssue]
+      : undefined
   )
 
   const hostedReview: HostedReviewInfo | null | undefined =
@@ -188,6 +207,8 @@ export function useWorktreeCardReviewDetails({
     issueEntry,
     linearIssueEntry,
     linearIssueFallbackEntry,
+    linearSourceContext,
+    linearWorkspaceId,
     linkedGitHubPR,
     linkedGitLabMR,
     linkedBitbucketPR,
diff --git a/src/renderer/src/components/sidebar/use-worktree-card-secondary-details.ts b/src/renderer/src/components/sidebar/use-worktree-card-secondary-details.ts
index 5718ad0f2d66..41aaa49451b3 100644
--- a/src/renderer/src/components/sidebar/use-worktree-card-secondary-details.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-card-secondary-details.ts
@@ -1,4 +1,5 @@
 import React, { useCallback } from 'react'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
 import { toast } from 'sonner'
 
 import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
@@ -227,15 +228,17 @@ export function useWorktreeCardSecondaryDetails({
     },
     [linearIssue, openTaskPage]
   )
-  const hasDetails = hasWorktreeCardDetails({
-    issue: metaIssue,
-    linearIssue: metaLinearIssue,
-    jiraIssue: metaJiraIssue,
-    review: newCardStyle ? null : metaReview,
-    comment: metaComment,
-    automationProvenance: metaAutomationProvenance,
-    cliProvenance: metaCliProvenance
-  })
+  const hasDetails =
+    getWorkspaceAttachments(worktree).length > 0 ||
+    hasWorktreeCardDetails({
+      issue: metaIssue,
+      linearIssue: metaLinearIssue,
+      jiraIssue: metaJiraIssue,
+      review: newCardStyle ? null : metaReview,
+      comment: metaComment,
+      automationProvenance: metaAutomationProvenance,
+      cliProvenance: metaCliProvenance
+    })
   const hasPorts = showPorts && workspacePorts.length > 0
   const cacheStartedAt = usePromptCacheCountdownStartedAt(worktree.id, showAggregateCacheTimer)
   // Why: derived from the settings the card already subscribes to — a third store
diff --git a/src/renderer/src/components/sidebar/use-worktree-issue-link.ts b/src/renderer/src/components/sidebar/use-worktree-issue-link.ts
deleted file mode 100644
index 4a3aba425421..000000000000
--- a/src/renderer/src/components/sidebar/use-worktree-issue-link.ts
+++ /dev/null
@@ -1,280 +0,0 @@
-import { useCallback, useMemo, useRef, useState } from 'react'
-import { useAppStore } from '@/store'
-import { parseGitHubIssueOrPRNumber } from '@/lib/github-links'
-import { issueCacheKey as getIssueCacheKey } from '@/store/github/cache-identity'
-import { useMountedRef } from '@/hooks/useMountedRef'
-import { findIndexedWorktreeOwner } from '@/lib/worktree-runtime-owner-index'
-import { buildLinearIssueUrl, parseLinearIssueInput } from '../../../../shared/linear/links'
-import type { IssueLinkProvider } from '../../../../shared/issue-link-input'
-import type { TaskSourceContext } from '../../../../shared/task-source-context'
-import { parseExplicitGitHubIssueUrl } from './worktree-meta-updates'
-import { isWorkItemLinkQueryTooLarge } from '../../../../shared/new-workspace/work-item-link-query-bounds'
-
-// Why: both lookups cross an IPC or runtime-RPC boundary that can stop
-// answering — a hung SSH runtime leaves the await pending, and the button spins
-// for the life of the dialog. Set above the 30s Linear/GitHub client bounds, so a
-// slow-but-live transport reports its own failure rather than being called a bad
-// identifier here.
-const OPEN_ISSUE_TIMEOUT_MS = 35_000
-
-async function resolveIssueUrlWithinTimeout(
-  lookup: Promise<{ url?: string } | null>
-): Promise<string | null> {
-  let timer: ReturnType<typeof setTimeout> | undefined
-  try {
-    const issue = await Promise.race([
-      lookup,
-      new Promise<null>((resolve) => {
-        timer = setTimeout(() => resolve(null), OPEN_ISSUE_TIMEOUT_MS)
-      })
-    ])
-    return issue?.url ?? null
-  } catch {
-    // Why: the store's fetchers already log and normalize failures to null; a
-    // rejection here is a transport fault and reads the same to the user.
-    return null
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-/** Resolves the "open linked issue" affordance for the worktree meta dialog:
- *  explicit URLs open directly, GitHub numbers resolve via the issue cache or an
- *  owner-routed fetch, Linear identifiers via the stored org key or a lookup. */
-export function useWorktreeIssueLink(args: {
-  worktreeId: string
-  /** The repo bucket the opening row belongs to, for IDs the owner index reports
-   *  as ambiguous across hosts. Falls back to the index when absent. */
-  ownerRepoId?: string | null
-  issueInput: string
-  issueProvider: IssueLinkProvider
-  linearOrganizationUrlKey?: string | null
-  /** The persisted identifier the stored org key belongs to. */
-  linkedLinearIssue?: string | null
-  linearSourceContext?: TaskSourceContext | null
-}): {
-  canOpenIssue: boolean
-  openingIssue: boolean
-  /** A lookup came back empty: wrong identifier, no access, or provider offline. */
-  openIssueFailed: boolean
-  handleOpenIssue: () => Promise<void>
-  resetOpeningIssue: () => void
-} {
-  const {
-    worktreeId,
-    ownerRepoId,
-    issueInput,
-    issueProvider,
-    linearOrganizationUrlKey,
-    linkedLinearIssue,
-    linearSourceContext
-  } = args
-  const isLinear = issueProvider === 'linear'
-  const fetchIssue = useAppStore((s) => s.fetchIssue)
-  const fetchLinearIssue = useAppStore((s) => s.fetchLinearIssue)
-  const [openingIssue, setOpeningIssue] = useState(false)
-  const [failedIssueInput, setFailedIssueInput] = useState<string | null>(null)
-  const mountedRef = useMountedRef()
-  // Why: the field stays editable while a lookup is in flight, and Promise.race
-  // cannot cancel the losing promise. A result that lands after the value moved
-  // on — or after a reset — must not open the issue the user just replaced.
-  const openRequestRef = useRef(0)
-  const latestRequestKeyRef = useRef('')
-  latestRequestKeyRef.current = `${issueProvider}\u0000${issueInput}`
-
-  // Why: `matchGitHubItemPath` strips trailing slashes with an unanchored `/\/+$/`,
-  // which is quadratic — a 160 KB paste of slashes freezes the renderer for ~19s.
-  // These parses run on every keystroke, so they get the same bound the save gate
-  // applies. The check short-circuits on length, so it stays O(1) on a huge paste.
-  const boundedInput = useMemo(
-    () => (isWorkItemLinkQueryTooLarge(issueInput) ? '' : issueInput),
-    [issueInput]
-  )
-
-  const issueNumber = useMemo(
-    () => (isLinear ? null : parseGitHubIssueOrPRNumber(boundedInput)),
-    [isLinear, boundedInput]
-  )
-  const issueUrlFromInput = useMemo(
-    () => (isLinear ? null : parseExplicitGitHubIssueUrl(boundedInput)),
-    [isLinear, boundedInput]
-  )
-  const issueInputLooksLikeUrl = useMemo(
-    () => /^https?:\/\//i.test(boundedInput.trim()),
-    [boundedInput]
-  )
-  const parsedLinearIssue = useMemo(
-    () => (isLinear ? parseLinearIssueInput(boundedInput) : null),
-    [isLinear, boundedInput]
-  )
-  // Why: only an org key that is authoritative *for this identifier* may build a
-  // URL directly — the input's own, or the workspace's stored one while the typed
-  // identifier still is that issue. The connected viewer's key is not: a bare key
-  // for another of the user's Linear workspaces would open a not-found page, or a
-  // different issue on a team-prefix collision. Anything else falls through to the
-  // all-workspace lookup below, which answers with the issue's canonical URL.
-  const linearIssueUrl = useMemo(() => {
-    if (!parsedLinearIssue) {
-      return null
-    }
-    const storedKeyApplies =
-      typeof linkedLinearIssue === 'string' &&
-      linkedLinearIssue.toUpperCase() === parsedLinearIssue.identifier.toUpperCase()
-    return buildLinearIssueUrl({
-      identifier: parsedLinearIssue.identifier,
-      organizationUrlKey:
-        parsedLinearIssue.organizationUrlKey ?? (storedKeyApplies ? linearOrganizationUrlKey : null)
-    })
-  }, [parsedLinearIssue, linkedLinearIssue, linearOrganizationUrlKey])
-
-  const issueRepo = useAppStore((s) => {
-    const repoId = ownerRepoId ?? findIndexedWorktreeOwner(s.worktreesByRepo, worktreeId)?.repoId
-    return repoId ? s.repos.find((repo) => repo.id === repoId) : undefined
-  })
-  const cachedIssueUrl = useAppStore((s) => {
-    if (!issueRepo || issueNumber === null) {
-      return null
-    }
-    return (
-      s.issueCache[
-        getIssueCacheKey(
-          issueRepo.path,
-          issueRepo.id,
-          issueNumber,
-          s.settings,
-          issueRepo.connectionId,
-          issueRepo.executionHostId,
-          true
-        )
-      ]?.data?.url ?? null
-    )
-  })
-  const canOpenIssue = isLinear
-    ? Boolean(parsedLinearIssue)
-    : issueInputLooksLikeUrl
-      ? Boolean(issueUrlFromInput)
-      : Boolean(cachedIssueUrl || (issueRepo && issueNumber))
-
-  const handleOpenIssue = useCallback(async () => {
-    if (openingIssue) {
-      return
-    }
-    setFailedIssueInput(null)
-    const generation = ++openRequestRef.current
-    const requestKey = latestRequestKeyRef.current
-    // Why: the losing side of the timeout race keeps running, so every result
-    // has to prove it still belongs to the field the user is looking at.
-    const isCurrentRequest = (): boolean =>
-      mountedRef.current &&
-      openRequestRef.current === generation &&
-      latestRequestKeyRef.current === requestKey
-
-    if (isLinear) {
-      if (!parsedLinearIssue) {
-        return
-      }
-      if (linearIssueUrl) {
-        void window.api.shell.openUrl(linearIssueUrl)
-        return
-      }
-
-      setOpeningIssue(true)
-      try {
-        // Why: 'all' — the issue may belong to a different Linear workspace than
-        // the selected one, which is the usual case for a bare or pasted identifier.
-        const url = await resolveIssueUrlWithinTimeout(
-          fetchLinearIssue(parsedLinearIssue.identifier, 'all', {
-            sourceContext: linearSourceContext ?? null
-          })
-        )
-        if (!isCurrentRequest()) {
-          return
-        }
-        if (url) {
-          void window.api.shell.openUrl(url)
-        } else {
-          // Why: the fetchers normalize every failure — no Linear connection,
-          // unknown identifier, dead runtime — to null, so without this the
-          // button just stops spinning and the click looks ignored.
-          setFailedIssueInput(issueInput)
-        }
-      } finally {
-        if (mountedRef.current) {
-          setOpeningIssue(false)
-        }
-      }
-      return
-    }
-
-    if (issueUrlFromInput) {
-      void window.api.shell.openUrl(issueUrlFromInput)
-      return
-    }
-
-    if (issueInputLooksLikeUrl) {
-      return
-    }
-
-    if (cachedIssueUrl) {
-      void window.api.shell.openUrl(cachedIssueUrl)
-      return
-    }
-
-    if (!issueRepo || issueNumber === null) {
-      return
-    }
-
-    setOpeningIssue(true)
-    try {
-      const url = await resolveIssueUrlWithinTimeout(
-        fetchIssue(issueRepo.path, issueNumber, { repoId: issueRepo.id })
-      )
-      if (!isCurrentRequest()) {
-        return
-      }
-      if (url) {
-        void window.api.shell.openUrl(url)
-      } else {
-        setFailedIssueInput(issueInput)
-      }
-    } finally {
-      if (mountedRef.current) {
-        setOpeningIssue(false)
-      }
-    }
-  }, [
-    cachedIssueUrl,
-    fetchIssue,
-    fetchLinearIssue,
-    isLinear,
-    issueInput,
-    issueInputLooksLikeUrl,
-    issueNumber,
-    issueRepo,
-    issueUrlFromInput,
-    linearIssueUrl,
-    linearSourceContext,
-    mountedRef,
-    openingIssue,
-    parsedLinearIssue
-  ])
-
-  const resetOpeningIssue = useCallback(() => {
-    // Bumping the generation retires any in-flight lookup: a reset means this is
-    // a fresh dialog session, and the old result must not open or report here.
-    openRequestRef.current += 1
-    setOpeningIssue(false)
-    setFailedIssueInput(null)
-  }, [])
-
-  return {
-    canOpenIssue,
-    openingIssue,
-    // Why: the failure belongs to the value that produced it. Editing the field
-    // is the user's answer to it, so comparing rather than clearing on change
-    // retires the notice without an Effect that would lag a keystroke behind.
-    openIssueFailed: failedIssueInput !== null && failedIssueInput === issueInput,
-    handleOpenIssue,
-    resetOpeningIssue
-  }
-}
diff --git a/src/renderer/src/components/sidebar/use-worktree-meta-workspace.ts b/src/renderer/src/components/sidebar/use-worktree-meta-workspace.ts
index 6a68906f0bfd..2544fd7fb1be 100644
--- a/src/renderer/src/components/sidebar/use-worktree-meta-workspace.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-meta-workspace.ts
@@ -1,31 +1,24 @@
 import { useMemo } from 'react'
 import { useAppStore } from '@/store'
-import { findIndexedWorktreeOwner } from '@/lib/worktree-runtime-owner-index'
+import {
+  findIndexedWorktreeOwner,
+  findIndexedWorktreeOwnerForHost
+} from '@/lib/worktree-runtime-owner-index'
+import { getFolderWorkspaceHostId } from '@/store/folder-workspaces/folder-workspace-catalog'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
 import type { Worktree } from '../../../../shared/worktree/types'
 import { parseWorkspaceKey } from '../../../../shared/workspace-scope'
 import { folderWorkspaceToWorktree } from '../../../../shared/folder-workspace-worktree'
-import type { IssueLinkProvider } from '../../../../shared/issue-link-input'
-import type { WorktreeMetaLiveLinks } from './worktree-meta-updates'
 
-/** Resolves the workspace the meta dialog edits and the issue-link state it
- *  seeds from. Link state is read from the store rather than threaded through
- *  the untyped modalData bag — a call site that forgot a key would otherwise
- *  seed an empty field and silently destroy the link on save. */
+/** Resolves the edited workspace within its execution host, including folders. */
 export function useWorktreeMetaWorkspace(args: {
   worktreeId: string
   /** The repo bucket the opening row belongs to, when it knows. */
   ownerRepoId: string | null
-  executionHostId?: string
+  executionHostId?: ExecutionHostId
 }): {
   worktree: Worktree | undefined
-  linkedIssue: number | null
-  linkedLinearIssue: string | null
-  /** The persisted value and its provider, from one source so they cannot drift. */
-  currentIssue: string
-  currentProvider: IssueLinkProvider
   isFolderWorkspace: boolean
-  /** Link state as it stands now, for save-time displacement decisions. */
-  liveLinks: WorktreeMetaLiveLinks
 } {
   const { worktreeId, ownerRepoId, executionHostId } = args
   const workspaceScope = useMemo(() => parseWorkspaceKey(worktreeId), [worktreeId])
@@ -33,17 +26,11 @@ export function useWorktreeMetaWorkspace(args: {
     // Why: the same workspace ID can exist under two hosts, which the owner index
     // reports as ambiguous rather than guessing. The row that opened the dialog
     // knows which one it is; the index stays the fallback for callers that cannot.
-    const scoped = ownerRepoId
-      ? s.worktreesByRepo[ownerRepoId]?.find(
-          (item) => item.id === worktreeId && (!executionHostId || item.hostId === executionHostId)
-        )
-      : undefined
-    if (scoped) {
-      return scoped
-    }
-    const owner = findIndexedWorktreeOwner(s.worktreesByRepo, worktreeId)
-    return owner
-      ? s.worktreesByRepo[owner.repoId]?.find((item) => item.id === worktreeId)
+    const owner = executionHostId
+      ? findIndexedWorktreeOwnerForHost(s.worktreesByRepo, worktreeId, executionHostId)
+      : findIndexedWorktreeOwner(s.worktreesByRepo, worktreeId)
+    return owner && (!ownerRepoId || owner.repoId === ownerRepoId)
+      ? s.worktreesByRepo[owner.repoId]?.find((item) => item === owner)
       : undefined
   })
   // Why: folder workspaces are absent from worktreesByRepo, so the lookup above
@@ -51,57 +38,23 @@ export function useWorktreeMetaWorkspace(args: {
   // the stored record — a stable reference — and the projection happens outside
   // it, because a selector that built the object would return a fresh identity
   // on every store write and re-render the dialog continuously.
-  const folderWorkspace = useAppStore((s) =>
-    workspaceScope?.type === 'folder'
-      ? (s.folderWorkspaces.find((item) => item.id === workspaceScope.folderWorkspaceId) ?? null)
-      : null
-  )
+  const folderWorkspace = useAppStore((s) => {
+    if (workspaceScope?.type !== 'folder') {
+      return null
+    }
+    const candidates = s.folderWorkspaces.filter(
+      (item) =>
+        item.id === workspaceScope.folderWorkspaceId &&
+        (!executionHostId || getFolderWorkspaceHostId(item, s.projectGroups) === executionHostId)
+    )
+    return candidates.length === 1 ? candidates[0] : null
+  })
   const worktree = useMemo(
     () => (folderWorkspace ? folderWorkspaceToWorktree(folderWorkspace) : indexedWorktree),
     [folderWorkspace, indexedWorktree]
   )
-  const linkedIssue = worktree?.linkedIssue ?? null
-  const linkedLinearIssue = worktree?.linkedLinearIssue ?? null
-  // Why: `typeof` rather than a null check — an unhydrated projection can leave
-  // linkedIssue undefined, which `!== null` would read as a GitHub link.
-  const currentProvider: IssueLinkProvider =
-    typeof linkedIssue === 'number' ? 'github' : linkedLinearIssue ? 'linear' : 'github'
-  const currentIssue =
-    currentProvider === 'linear'
-      ? (linkedLinearIssue ?? '')
-      : typeof linkedIssue === 'number'
-        ? String(linkedIssue)
-        : ''
-  // Why: displacement is decided against live state, not the frozen snapshot —
-  // the dialog's warning reads the same values, so a link added by the CLI while
-  // the dialog was open cannot outlive a save that promised to displace it.
-  const liveLinks = useMemo<WorktreeMetaLiveLinks>(
-    () => ({
-      linkedPR: worktree?.linkedPR ?? null,
-      linkedIssue,
-      linkedLinearIssue,
-      linkedLinearIssueOrganizationUrlKey: worktree?.linkedLinearIssueOrganizationUrlKey ?? null,
-      linkedWorkItemProvider: worktree?.linkedWorkItem?.provider ?? null,
-      linkedWorkItemType: worktree?.linkedWorkItem?.type ?? null
-    }),
-    [
-      linkedIssue,
-      linkedLinearIssue,
-      worktree?.linkedPR,
-      worktree?.linkedLinearIssueOrganizationUrlKey,
-      worktree?.linkedWorkItem
-    ]
-  )
-
   return {
     worktree,
-    linkedIssue,
-    linkedLinearIssue,
-    currentIssue,
-    currentProvider,
-    // Why: folder workspaces persist links only through their creation-time
-    // linkedTask; updateWorktreeMeta drops link keys for them entirely.
-    isFolderWorkspace: workspaceScope?.type === 'folder',
-    liveLinks
+    isFolderWorkspace: workspaceScope?.type === 'folder'
   }
 }
diff --git a/src/renderer/src/components/sidebar/use-worktree-sleep-state.ts b/src/renderer/src/components/sidebar/use-worktree-sleep-state.ts
index 894d6872639d..328e10c03cd1 100644
--- a/src/renderer/src/components/sidebar/use-worktree-sleep-state.ts
+++ b/src/renderer/src/components/sidebar/use-worktree-sleep-state.ts
@@ -67,19 +67,21 @@ function selectWorktreeIdsWithLiveAgent(state: SleepStateInput): ReadonlySet<str
  * predicate, so the moon and the filter cannot disagree about which workspaces
  * are asleep.
  */
-export function useIsSleepingWorktree(worktreeId: string): boolean {
-  return useAppStore((state) =>
-    isInactiveWorkspace(
-      worktreeId,
-      state.tabsByWorktree,
-      state.ptyIdsByTabId,
-      state.browserTabsByWorktree,
-      selectWorktreeIdsWithLiveAgent(state),
-      getWorktreeIdsWithStructuredChat(state.unifiedTabsByWorktree)
-    )
+export function selectIsSleepingWorktree(state: SleepStateInput, worktreeId: string): boolean {
+  return isInactiveWorkspace(
+    worktreeId,
+    state.tabsByWorktree,
+    state.ptyIdsByTabId,
+    state.browserTabsByWorktree,
+    selectWorktreeIdsWithLiveAgent(state),
+    getWorktreeIdsWithStructuredChat(state.unifiedTabsByWorktree)
   )
 }
 
+export function useIsSleepingWorktree(worktreeId: string): boolean {
+  return useAppStore((state) => selectIsSleepingWorktree(state, worktreeId))
+}
+
 export function resetWorktreeSleepStateCacheForTests(): void {
   liveAgentGeneration = null
 }
diff --git a/src/renderer/src/components/sidebar/workspace-attachment-source-label.test.ts b/src/renderer/src/components/sidebar/workspace-attachment-source-label.test.ts
new file mode 100644
index 000000000000..4641fe9a97bd
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-attachment-source-label.test.ts
@@ -0,0 +1,168 @@
+import { expect, it } from 'vitest'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import type { TaskSourceContext } from '../../../../shared/task-source-context'
+import { getWorkspaceAttachmentSourceLabel } from './workspace-attachment-source-label'
+
+function source(
+  provider: TaskSourceContext['provider'],
+  providerIdentity: TaskSourceContext['providerIdentity'],
+  accountLabel?: string
+): TaskSourceContext {
+  return {
+    kind: 'task-source',
+    provider,
+    projectId: 'project',
+    hostId: 'runtime:host',
+    providerIdentity,
+    accountLabel
+  }
+}
+
+const linearSource = source(
+  'linear',
+  {
+    provider: 'linear',
+    workspaceId: 'internal-workspace-id',
+    workspaceName: 'Engineering'
+  },
+  'alice@example.com'
+)
+const linear: WorkspaceAttachment = {
+  provider: 'linear',
+  type: 'issue',
+  number: 0,
+  identifier: 'ENG-215',
+  url: 'https://linear.app/acme/issue/ENG-215/title',
+  taskSourceContext: linearSource
+}
+const jira: WorkspaceAttachment = {
+  provider: 'jira',
+  type: 'issue',
+  number: 0,
+  identifier: 'APP-18',
+  url: 'https://jira.example.com/team/browse/APP-18',
+  taskSourceContext: source(
+    'jira',
+    {
+      provider: 'jira',
+      siteId: 'internal-site-id',
+      siteUrl: 'https://jira.example.com/team/'
+    },
+    'alice@example.com'
+  )
+}
+const cases: { name: string; item: Partial<WorkspaceAttachment>; expected: string | null }[] = [
+  {
+    name: 'Linear workspace, organization and account',
+    item: linear,
+    expected: 'Engineering · acme · alice@example.com'
+  },
+  {
+    name: 'another Linear organization',
+    item: { ...linear, url: 'https://linear.app/other/issue/ENG-215/title' },
+    expected: 'Engineering · other · alice@example.com'
+  },
+  {
+    name: 'another Linear account',
+    item: { ...linear, taskSourceContext: { ...linearSource, accountLabel: 'bob@example.com' } },
+    expected: 'Engineering · acme · bob@example.com'
+  },
+  {
+    name: 'Jira site path and account',
+    item: jira,
+    expected: 'jira.example.com/team · alice@example.com'
+  },
+  {
+    name: 'Jira URL without stored context',
+    item: {
+      ...jira,
+      url: 'https://jira.example.com/other/browse/APP-18',
+      taskSourceContext: undefined
+    },
+    expected: 'jira.example.com/other'
+  },
+  {
+    name: 'GitHub Enterprise host',
+    item: { url: 'https://github.example.com/Owner/Repo/pull/7' },
+    expected: 'github.example.com/Owner/Repo'
+  },
+  {
+    name: 'GitHub issue',
+    item: { type: 'issue', url: 'https://github.com/Owner/Repo/issues/7' },
+    expected: 'Owner/Repo'
+  },
+  {
+    name: 'nested GitLab group',
+    item: {
+      provider: 'gitlab',
+      type: 'issue',
+      url: 'https://gitlab.example.com/Group/Subgroup/Repo/-/work_items/7'
+    },
+    expected: 'gitlab.example.com/Group/Subgroup/Repo'
+  },
+  {
+    name: 'legacy GitHub identity without URL',
+    item: {
+      taskSourceContext: source('github', { provider: 'github', owner: 'acme', repo: 'orca' })
+    },
+    expected: 'acme/orca'
+  },
+  {
+    name: 'legacy GitLab identity without URL',
+    item: {
+      provider: 'gitlab',
+      type: 'mr',
+      taskSourceContext: source('gitlab', {
+        provider: 'gitlab',
+        namespace: 'acme/team',
+        project: 'orca'
+      })
+    },
+    expected: 'acme/team/orca'
+  },
+  {
+    name: 'GitHub URL takes precedence over stale identity',
+    item: {
+      url: 'https://github.com/actual/repo/pull/7',
+      taskSourceContext: source('github', { provider: 'github', owner: 'old', repo: 'repo' })
+    },
+    expected: 'actual/repo'
+  },
+  {
+    name: 'Bitbucket scope excludes query secrets',
+    item: {
+      provider: 'bitbucket',
+      url: 'https://bitbucket.org/Team/Repo/pull-requests/7?token=secret'
+    },
+    expected: 'bitbucket.org/Team/Repo'
+  },
+  {
+    name: 'Jira rejects embedded credentials',
+    item: {
+      ...jira,
+      url: 'https://user:secret@jira.example.com/browse/APP-18',
+      taskSourceContext: undefined
+    },
+    expected: null
+  },
+  {
+    name: 'opaque identifiers are not human labels',
+    item: {
+      ...linear,
+      url: undefined,
+      linearWorkspaceId: 'opaque-workspace-id',
+      taskSourceContext: source('linear', {
+        provider: 'linear',
+        workspaceId: 'opaque-workspace-id',
+        workspaceName: '1a234567-1234-1234-1234-123456789abc'
+      })
+    },
+    expected: null
+  },
+  { name: 'missing source', item: {}, expected: null }
+]
+it.each(cases)('$name', ({ item, expected }) => {
+  expect(
+    getWorkspaceAttachmentSourceLabel({ provider: 'github', type: 'pr', number: 7, ...item })
+  ).toBe(expected)
+})
diff --git a/src/renderer/src/components/sidebar/workspace-attachment-source-label.ts b/src/renderer/src/components/sidebar/workspace-attachment-source-label.ts
new file mode 100644
index 000000000000..28edaa3821a8
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-attachment-source-label.ts
@@ -0,0 +1,89 @@
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import { parseGitHubIssueOrPRLink } from '../../../../shared/github/links'
+import { parseGitLabIssueOrMRLink } from '../../../../shared/new-workspace/gitlab-links'
+import { parseLinearIssueInput } from '../../../../shared/linear/links'
+import { parseJiraIssueUrl } from '../../../../shared/jira-issue-url'
+import { getWorkspaceAttachmentUrlScope } from '../../../../shared/workspace-attachment-normalization'
+
+function humanText(value: string | null | undefined): string | null {
+  const text = value?.trim()
+  return text && !/^[\da-f]{8}-(?:[\da-f]{4}-){3}[\da-f]{12}$/i.test(text) ? text : null
+}
+
+function joinSourceParts(...parts: (string | null | undefined)[]): string | null {
+  const labels = new Map<string, string>()
+  for (const part of parts) {
+    const label = humanText(part)
+    if (label && !labels.has(label.toLowerCase())) {
+      labels.set(label.toLowerCase(), label)
+    }
+  }
+  return labels.size ? [...labels.values()].join(' · ') : null
+}
+
+function urlLabel(value: string | null | undefined): string | null {
+  if (!value) {
+    return null
+  }
+  try {
+    const url = new URL(value)
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) {
+      return null
+    }
+    return `${url.host}${url.pathname.replace(/\/+$/, '')}`
+  } catch {
+    return null
+  }
+}
+
+export function getWorkspaceAttachmentSourceLabel(item: WorkspaceAttachment): string | null {
+  const source = item.taskSourceContext?.provider === item.provider ? item.taskSourceContext : null
+  const identity = source?.providerIdentity
+  if (item.provider === 'linear') {
+    const organization =
+      item.linearOrganizationUrlKey ??
+      (item.url ? parseLinearIssueInput(item.url)?.organizationUrlKey : null)
+    return joinSourceParts(
+      identity?.provider === 'linear' ? identity.workspaceName : null,
+      organization,
+      source?.accountLabel
+    )
+  }
+  if (item.provider === 'jira') {
+    const parsed = item.url ? parseJiraIssueUrl(item.url) : null
+    return joinSourceParts(
+      urlLabel(
+        identity?.provider === 'jira' && identity.siteUrl
+          ? identity.siteUrl
+          : parsed
+            ? `${parsed.origin}${parsed.sitePath}`
+            : null
+      ),
+      source?.accountLabel
+    )
+  }
+  if (item.provider === 'github') {
+    const repo =
+      (item.url ? parseGitHubIssueOrPRLink(item.url)?.slug : null) ??
+      (identity?.provider === 'github' ? identity : null)
+    if (repo) {
+      const host = repo.host && repo.host.toLowerCase() !== 'github.com' ? `${repo.host}/` : ''
+      return `${host}${repo.owner}/${repo.repo}`
+    }
+  }
+  if (item.provider === 'gitlab') {
+    const parsed = item.url ? parseGitLabIssueOrMRLink(item.url) : null
+    if (parsed) {
+      return `${parsed.slug.host}/${parsed.slug.path}`
+    }
+    if (identity?.provider === 'gitlab') {
+      return (
+        urlLabel(identity.webUrl) ??
+        (identity.namespace && identity.project
+          ? `${identity.namespace}/${identity.project}`
+          : null)
+      )
+    }
+  }
+  return urlLabel(getWorkspaceAttachmentUrlScope(item))
+}
diff --git a/src/renderer/src/components/sidebar/workspace-attachment-source-result.test.ts b/src/renderer/src/components/sidebar/workspace-attachment-source-result.test.ts
new file mode 100644
index 000000000000..8e911a878068
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-attachment-source-result.test.ts
@@ -0,0 +1,177 @@
+import { resolveWorkItemSourceRow } from '../new-workspace/work-item-source-selection'
+import { describe, expect, it } from 'vitest'
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import { normalizeTaskSourceContext } from '../../../../shared/task-source-context'
+import {
+  appendWorkspaceAttachment,
+  getWorkspaceAttachmentSourceContext,
+  isWorkspaceAttachmentLinked,
+  matchesWorkspaceAttachmentQuery
+} from './workspace-attachment-source-result'
+
+const repo: Repo = {
+  id: 'repo',
+  path: '/repo',
+  displayName: 'Orca',
+  badgeColor: '',
+  addedAt: 1,
+  connectionId: 'remote'
+}
+const worktree: Worktree = {
+  id: 'workspace',
+  repoId: 'repo',
+  path: '/repo/feature',
+  displayName: 'Feature',
+  branch: 'feature',
+  head: 'abc',
+  comment: '',
+  linkedIssue: null,
+  linkedPR: null,
+  linkedLinearIssue: null,
+  isBare: false,
+  isMainWorktree: false,
+  isArchived: false,
+  isUnread: false,
+  isPinned: false,
+  sortOrder: 0,
+  lastActivityAt: 1
+}
+const github = normalizeTaskSourceContext({
+  provider: 'github',
+  projectId: 'repo',
+  hostId: 'local'
+})
+const review: WorkspaceAttachment = {
+  provider: 'github',
+  type: 'pr',
+  number: 7,
+  url: 'https://github.com/acme/orca/pull/7',
+  repoId: 'repo'
+}
+
+describe('attachment source conversion', () => {
+  it('uses legacy SSH ownership and preserves the saved provider source', () => {
+    expect(getWorkspaceAttachmentSourceContext('gitlab', repo, worktree)?.hostId).toBe('ssh:remote')
+    const stored = normalizeTaskSourceContext({
+      provider: 'linear',
+      projectId: 'other',
+      hostId: 'runtime:saved'
+    })
+    const saved = { ...worktree, linkedTaskSourceContext: stored }
+    expect(getWorkspaceAttachmentSourceContext('linear', repo, saved)).toBe(stored)
+    expect(getWorkspaceAttachmentSourceContext('github', repo, saved)?.projectId).toBe('repo')
+    expect(getWorkspaceAttachmentSourceContext('github', repo, saved)?.hostId).toBe('ssh:remote')
+  })
+  it('binds searched reviews to the source repository and retains their title', () => {
+    const item = resolveWorkItemSourceRow(
+      {
+        kind: 'github',
+        value: 'github:7',
+        item: {
+          id: '7',
+          repoId: 'repo',
+          type: 'pr',
+          number: 7,
+          title: 'Seven',
+          state: 'open',
+          url: review.url ?? '',
+          labels: [],
+          updatedAt: '2026-10-05',
+          author: null
+        }
+      },
+      { github, gitlab: null, linear: null, jira: null }
+    )
+    expect(item).toMatchObject({
+      title: 'Seven',
+      number: 7,
+      taskSourceContext: { providerIdentity: { provider: 'github', owner: 'acme', repo: 'orca' } }
+    })
+  })
+  it('recognizes a rich URL whose older context has no provider identity', () => {
+    const old = { ...review, taskSourceContext: github ?? undefined }
+    const enriched = {
+      ...review,
+      taskSourceContext: github
+        ? {
+            ...github,
+            providerIdentity: { provider: 'github' as const, owner: 'acme', repo: 'orca' }
+          }
+        : undefined
+    }
+    expect(isWorkspaceAttachmentLinked([old], enriched)).toBe(true)
+    expect(
+      isWorkspaceAttachmentLinked([old], {
+        ...enriched,
+        taskSourceContext:
+          normalizeTaskSourceContext({
+            provider: 'github',
+            projectId: 'other',
+            hostId: 'runtime:other'
+          }) ?? undefined
+      })
+    ).toBe(false)
+    expect(
+      isWorkspaceAttachmentLinked([old], {
+        ...enriched,
+        url: 'https://github.com/other/orca/pull/7'
+      })
+    ).toBe(false)
+  })
+  it('enriches a legacy review without adding a duplicate', () => {
+    const bare: WorkspaceAttachment = { provider: 'github', type: 'pr', number: 7 }
+    const result = appendWorkspaceAttachment([bare], review)
+    expect(result).toEqual([review])
+  })
+  it.each(['issue', 'mr'] as const)(
+    'keeps a bare GitLab %s distinct from the same-number other type',
+    (type) => {
+      const query: WorkspaceAttachment = { provider: 'gitlab', type, number: 12 }
+      const other: WorkspaceAttachment = {
+        ...query,
+        type: type === 'issue' ? 'mr' : 'issue',
+        url: `https://gitlab.com/acme/orca/-/${type === 'issue' ? 'merge_requests' : 'issues'}/12`
+      }
+      expect(matchesWorkspaceAttachmentQuery(query, other)).toBe(false)
+      expect(matchesWorkspaceAttachmentQuery(query, { ...query })).toBe(true)
+    }
+  )
+  it.each(['issue', 'pr'] as const)(
+    'resolves a bare GitHub %s across its shared number sequence but keeps URLs typed',
+    (type) => {
+      const query: WorkspaceAttachment = { provider: 'github', type, number: 7 }
+      const other: WorkspaceAttachment = {
+        ...query,
+        type: type === 'issue' ? 'pr' : 'issue',
+        url: `https://github.com/acme/orca/${type === 'issue' ? 'pull' : 'issues'}/7`
+      }
+      expect(matchesWorkspaceAttachmentQuery(query, other)).toBe(true)
+      expect(
+        matchesWorkspaceAttachmentQuery(
+          {
+            ...query,
+            url: `https://github.com/acme/orca/${type === 'issue' ? 'issues' : 'pull'}/7`
+          },
+          other
+        )
+      ).toBe(false)
+    }
+  )
+  it('only enriches the same symbolic identifier and URL source', () => {
+    const task: WorkspaceAttachment = {
+      provider: 'linear',
+      type: 'issue',
+      number: 0,
+      identifier: 'STA-71'
+    }
+    expect(matchesWorkspaceAttachmentQuery(task, { ...task, identifier: 'STA-710' })).toBe(false)
+    expect(matchesWorkspaceAttachmentQuery(task, { ...task, identifier: 'sta-71' })).toBe(true)
+    expect(
+      matchesWorkspaceAttachmentQuery(review, {
+        ...review,
+        url: 'https://github.com/other/orca/pull/7'
+      })
+    ).toBe(false)
+  })
+})
diff --git a/src/renderer/src/components/sidebar/workspace-attachment-source-result.ts b/src/renderer/src/components/sidebar/workspace-attachment-source-result.ts
new file mode 100644
index 000000000000..f2b06060e2db
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-attachment-source-result.ts
@@ -0,0 +1,103 @@
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import {
+  buildTaskSourceContextFromRepo,
+  normalizeTaskSourceContext,
+  type TaskSourceContext,
+  type TaskProvider
+} from '../../../../shared/task-source-context'
+import {
+  getWorkspaceAttachmentUrlScope,
+  matchesWorkspaceAttachmentIdentity,
+  normalizeWorkspaceAttachments
+} from '../../../../shared/workspace-attachment-normalization'
+
+export function getWorkspaceAttachmentSourceContext(
+  provider: TaskProvider,
+  repo: Repo | undefined,
+  workspace: Worktree | undefined
+): TaskSourceContext | null {
+  const stored = workspace?.linkedTaskSourceContext
+  if (stored?.provider === provider) {
+    return stored
+  }
+  if (repo) {
+    return buildTaskSourceContextFromRepo({
+      provider,
+      projectId: workspace?.projectId ?? repo.id,
+      repo: { ...repo, executionHostId: workspace?.hostId ?? repo.executionHostId },
+      projectHostSetupId: workspace?.projectHostSetupId
+    })
+  }
+  return workspace
+    ? normalizeTaskSourceContext({
+        provider,
+        projectId: workspace.projectId ?? workspace.repoId,
+        hostId: workspace.hostId,
+        projectHostSetupId: workspace.projectHostSetupId
+      })
+    : null
+}
+
+export function matchesWorkspaceAttachmentQuery(
+  query: WorkspaceAttachment,
+  result: WorkspaceAttachment
+): boolean {
+  if (query.provider !== result.provider || query.number !== result.number) {
+    return false
+  }
+  // GitHub issues and PRs share numbers; GitLab issues and MRs have separate sequences.
+  if (query.type !== result.type && (query.provider !== 'github' || query.url)) {
+    return false
+  }
+  const identifier = query.identifier ?? query.linearIdentifier ?? query.jiraIdentifier
+  const resultIdentifier = result.identifier ?? result.linearIdentifier ?? result.jiraIdentifier
+  if (identifier && identifier.toLowerCase() !== resultIdentifier?.toLowerCase()) {
+    return false
+  }
+  return (
+    !query.url || getWorkspaceAttachmentUrlScope(query) === getWorkspaceAttachmentUrlScope(result)
+  )
+}
+
+export function isWorkspaceAttachmentLinked(
+  items: readonly WorkspaceAttachment[],
+  candidate: WorkspaceAttachment
+): boolean {
+  return items.some((item) => {
+    if (
+      matchesWorkspaceAttachmentIdentity(candidate, item) ||
+      matchesWorkspaceAttachmentIdentity(item, candidate)
+    ) {
+      return true
+    }
+    const sameReference =
+      item.provider === candidate.provider &&
+      item.type === candidate.type &&
+      item.number === candidate.number &&
+      (item.identifier ?? item.linearIdentifier ?? item.jiraIdentifier) ===
+        (candidate.identifier ?? candidate.linearIdentifier ?? candidate.jiraIdentifier)
+    const scope = getWorkspaceAttachmentUrlScope(item)
+    if (!sameReference || !scope || scope !== getWorkspaceAttachmentUrlScope(candidate)) {
+      return false
+    }
+    const oldContext = item.taskSourceContext
+    const newContext = candidate.taskSourceContext
+    return (
+      !oldContext ||
+      !newContext ||
+      (oldContext.hostId === newContext.hostId &&
+        oldContext.projectId === newContext.projectId &&
+        (!oldContext.accountLabel ||
+          !newContext.accountLabel ||
+          oldContext.accountLabel === newContext.accountLabel))
+    )
+  })
+}
+
+export function appendWorkspaceAttachment(
+  items: readonly WorkspaceAttachment[],
+  item: WorkspaceAttachment
+): WorkspaceAttachment[] {
+  return normalizeWorkspaceAttachments([...items, item])
+}
diff --git a/src/renderer/src/components/sidebar/workspace-hover-attachments.test.ts b/src/renderer/src/components/sidebar/workspace-hover-attachments.test.ts
new file mode 100644
index 000000000000..df07f181e9a7
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-hover-attachments.test.ts
@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest'
+import type { Worktree, WorkspaceAttachment } from '../../../../shared/worktree/types'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { getWorkspaceHoverAttachments } from './workspace-hover-attachments'
+const workspace: Worktree = {
+  id: 'repo::/repo/feature',
+  repoId: 'repo',
+  path: '/repo/feature',
+  displayName: 'Feature',
+  branch: 'feature',
+  head: 'abc',
+  isBare: false,
+  isMainWorktree: false,
+  isArchived: false,
+  isPinned: false,
+  isUnread: false,
+  sortOrder: 0,
+  lastActivityAt: 1,
+  comment: '',
+  linkedIssue: null,
+  linkedLinearIssue: null,
+  linkedPR: 57
+}
+const local: WorkspaceAttachment = {
+  provider: 'github',
+  type: 'pr',
+  number: 57,
+  url: 'https://github.com/acme/orca/pull/57'
+}
+const other: WorkspaceAttachment = { ...local, url: 'https://github.com/other/orca/pull/57' }
+describe('source-safe linked hover details', () => {
+  it('uses matching review URL to disambiguate the same number across repositories', () => {
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, linkedItems: [other, local] },
+      {
+        review: {
+          provider: 'github',
+          number: 57,
+          title: 'Local review',
+          url: local.url,
+          status: 'success'
+        }
+      }
+    )
+    expect(result.activeKey).toBe(getWorkspaceAttachmentKey(local))
+    expect(result.items[0]?.title).toBeUndefined()
+    expect(result.items[1]?.title).toBe('Local review')
+  })
+  it('does not guess active checks or assign cached titles when the source is unresolved', () => {
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, linkedItems: [other, local] },
+      { review: { provider: 'github', number: 57, title: 'Unknown review' } }
+    )
+    expect(result.activeKey).toBeNull()
+    expect(result.items.every((item) => !item.title)).toBe(true)
+  })
+  it('enriches legacy scalar tasks without introducing duplicate references', () => {
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, linkedPR: null, linkedIssue: 2, linkedLinearIssue: 'ENG-3' },
+      {
+        review: null,
+        issue: { number: 2, title: 'GitHub task', url: 'https://github.com/acme/orca/issues/2' },
+        linearIssue: {
+          identifier: 'ENG-3',
+          title: 'Linear task',
+          url: 'https://linear.app/acme/issue/ENG-3/title'
+        }
+      }
+    )
+    expect(result.items).toHaveLength(2)
+    expect(result.items.map((item) => item.title)).toEqual(['GitHub task', 'Linear task'])
+  })
+  it('does not attach review checks to folder workspaces', () => {
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, id: 'folder:docs', linkedItems: [local] },
+      { review: { provider: 'github', number: 57, title: 'Review', url: local.url } }
+    )
+    expect(result.activeKey).toBeNull()
+  })
+  it('does not choose between identical URLs owned by different source contexts', () => {
+    const localHost = {
+      ...local,
+      taskSourceContext: {
+        kind: 'task-source' as const,
+        provider: 'github' as const,
+        projectId: 'repo',
+        hostId: 'local' as const
+      }
+    }
+    const otherHost = {
+      ...local,
+      taskSourceContext: {
+        kind: 'task-source' as const,
+        provider: 'github' as const,
+        projectId: 'repo',
+        hostId: 'runtime:other' as const
+      }
+    }
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, linkedItems: [localHost, otherHost] },
+      { review: { provider: 'github', number: 57, title: 'Review', url: local.url } }
+    )
+    expect(result.activeKey).toBeNull()
+  })
+  it('uses a reference label rather than a review placeholder with no fetched URL', () => {
+    const result = getWorkspaceHoverAttachments(
+      { ...workspace, linkedItems: [{ provider: 'github', type: 'pr', number: 57 }] },
+      { review: { provider: 'github', number: 57, title: 'Unavailable placeholder' } }
+    )
+    expect(result.items[0]?.title).toBeUndefined()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/workspace-hover-attachments.ts b/src/renderer/src/components/sidebar/workspace-hover-attachments.ts
new file mode 100644
index 000000000000..96ddc18991d8
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-hover-attachments.ts
@@ -0,0 +1,96 @@
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { getWorkspaceAttachmentKey } from '../../../../shared/workspace-attachment-normalization'
+import { parseWorkspaceKey } from '../../../../shared/workspace-scope'
+import { getActiveWorkspaceReviewKey } from './worktree-attachment-editing'
+import type {
+  WorktreeCardIssueDisplay,
+  WorktreeCardLinearIssueDisplay,
+  WorktreeCardJiraIssueDisplay
+} from './worktree-card-meta-types'
+import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
+
+type LiveDetails = {
+  issue?: WorktreeCardIssueDisplay | null
+  linearIssue?: WorktreeCardLinearIssueDisplay | null
+  jiraIssue?: WorktreeCardJiraIssueDisplay | null
+  review: WorktreeCardPrDisplay | null
+}
+
+export function getWorkspaceHoverAttachments(
+  workspace: Worktree,
+  details: LiveDetails
+): {
+  items: WorkspaceAttachment[]
+  activeKey: string | null
+  referenceKeys: string[]
+} {
+  const items = getWorkspaceAttachments(workspace)
+  const matches = (item: WorkspaceAttachment): boolean => {
+    if (item.provider === 'github' && item.type === 'issue') {
+      return item.number === details.issue?.number
+    }
+    if (item.provider === 'linear') {
+      return (item.identifier ?? item.linearIdentifier) === details.linearIssue?.identifier
+    }
+    if (item.provider === 'jira') {
+      return (item.identifier ?? item.jiraIdentifier) === details.jiraIssue?.identifier
+    }
+    return (
+      item.type !== 'issue' &&
+      item.provider === details.review?.provider &&
+      item.number === details.review?.number
+    )
+  }
+  const enriched = items.map((item) => {
+    const live =
+      item.provider === 'github' && item.type === 'issue'
+        ? details.issue
+        : item.provider === 'linear'
+          ? details.linearIssue
+          : item.provider === 'jira'
+            ? details.jiraIssue
+            : details.review
+    const sameReference =
+      matches(item) &&
+      live &&
+      (!item.url || item.url === live.url) &&
+      items.filter(
+        (candidate) =>
+          candidate.provider === item.provider &&
+          candidate.type === item.type &&
+          matches(candidate) &&
+          (!candidate.url || candidate.url === live.url)
+      ).length === 1
+    return sameReference
+      ? {
+          ...item,
+          title: item.title || (item.type === 'issue' || live.url ? live.title : undefined),
+          url: item.url || live.url || undefined
+        }
+      : item
+  })
+  const legacyActive = getActiveWorkspaceReviewKey(workspace)
+  const selected = items.find((item) => getWorkspaceAttachmentKey(item) === legacyActive)
+  const candidates = selected
+    ? items.filter(
+        (item) =>
+          item.provider === selected.provider &&
+          item.type === selected.type &&
+          item.number === selected.number
+      )
+    : []
+  const sourceMatches = candidates.filter((item) => item.url && item.url === details.review?.url)
+  const active =
+    candidates.length > 1 ? (sourceMatches.length === 1 ? sourceMatches[0] : undefined) : selected
+  const activeIndex = active ? items.indexOf(active) : -1
+  const activeItem = enriched[activeIndex]
+  return {
+    items: enriched,
+    referenceKeys: items.map(getWorkspaceAttachmentKey),
+    activeKey:
+      parseWorkspaceKey(workspace.id)?.type === 'folder' || !activeItem
+        ? null
+        : getWorkspaceAttachmentKey(activeItem)
+  }
+}
diff --git a/src/renderer/src/components/sidebar/workspace-reference-detail-read.test.ts b/src/renderer/src/components/sidebar/workspace-reference-detail-read.test.ts
new file mode 100644
index 000000000000..af3c6c81a9cb
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-detail-read.test.ts
@@ -0,0 +1,231 @@
+// @vitest-environment happy-dom
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { HostedReviewInfo } from '../../../../shared/hosted-review'
+import type { LinearIssue } from '../../../../shared/linear/issue-types'
+import { normalizeTaskSourceContext } from '../../../../shared/task-source-context'
+import { readWorkspaceReferenceDetails } from './workspace-reference-detail-read'
+import { getWorkspaceReferenceRequest } from './workspace-reference-details'
+import {
+  referenceAttachment,
+  referenceRepo,
+  referenceWorkspace,
+  referenceReview,
+  referenceLinearIssue
+} from './workspace-reference-fixtures.test-support'
+
+const mocks = vi.hoisted(() => ({
+  review: vi.fn<(...args: unknown[]) => Promise<HostedReviewInfo | null>>(),
+  linear: vi.fn<(...args: unknown[]) => Promise<LinearIssue | null>>(),
+  jira: vi.fn(),
+  issue: vi.fn()
+}))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({
+      hostedReviewCache: {},
+      linearIssueCache: {},
+      jiraIssueSummaryCache: {},
+      issueCache: {},
+      fetchHostedReviewForBranch: mocks.review,
+      settings: { activeRuntimeEnvironmentId: 'focused-elsewhere' },
+      fetchLinearIssue: mocks.linear,
+      lookupJiraIssueSummary: mocks.jira,
+      fetchIssue: mocks.issue
+    })
+  }
+}))
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  Object.defineProperty(window, 'api', {
+    configurable: true,
+    value: { hostedReview: { forBranch: mocks.review } }
+  })
+})
+describe('source-scoped workspace reference status reads', () => {
+  it.each(['open', 'merged', 'draft'] as const)(
+    'loads the exact %s sibling without workspace HEAD filtering or branch cache mutation',
+    async (state) => {
+      mocks.review.mockResolvedValue(referenceReview(42, { state, baseRefName: 'release' }))
+      const item = referenceAttachment(42)
+      const detail = await readWorkspaceReferenceDetails(
+        getWorkspaceReferenceRequest(item, referenceWorkspace, referenceRepo)
+      )
+      expect(detail?.review?.state).toBe(state)
+      expect(mocks.review).toHaveBeenCalledWith(
+        '/repo',
+        'feature',
+        expect.objectContaining({
+          linkedGitHubPR: 42,
+          linkedGitLabMR: null,
+          repoOwnerExecutionHostId: 'local'
+        })
+      )
+      expect(mocks.review.mock.calls[0]?.[2]).not.toHaveProperty('currentHeadOid')
+    }
+  )
+  it.each(['runtime:owner', 'ssh:owner'] as const)(
+    'uses the %s repository owner',
+    async (executionHostId) => {
+      mocks.review.mockResolvedValue(referenceReview())
+      await readWorkspaceReferenceDetails(
+        getWorkspaceReferenceRequest(referenceAttachment(), referenceWorkspace, {
+          ...referenceRepo,
+          executionHostId
+        })
+      )
+      expect(mocks.review).toHaveBeenCalledWith(
+        '/repo',
+        'feature',
+        expect.objectContaining({ repoOwnerExecutionHostId: executionHostId })
+      )
+    }
+  )
+  it('rejects branch fallback, wrong provider and wrong repository responses', async () => {
+    const request = getWorkspaceReferenceRequest(
+      referenceAttachment(),
+      referenceWorkspace,
+      referenceRepo
+    )
+    for (const review of [
+      referenceReview(9),
+      referenceReview(7, { provider: 'gitlab' }),
+      referenceReview(7, { url: 'https://github.com/other/orca/pull/7' })
+    ]) {
+      mocks.review.mockResolvedValue(review)
+      expect(await readWorkspaceReferenceDetails(request)).toBeNull()
+    }
+  })
+  it('does not route folder or known foreign reviews through the current git repository', async () => {
+    expect(
+      await readWorkspaceReferenceDetails(
+        getWorkspaceReferenceRequest(referenceAttachment(), {
+          ...referenceWorkspace,
+          id: 'folder:docs'
+        })
+      )
+    ).toBeNull()
+    expect(
+      await readWorkspaceReferenceDetails(
+        getWorkspaceReferenceRequest(
+          { ...referenceAttachment(), url: 'https://github.com/other/orca/pull/7' },
+          referenceWorkspace,
+          referenceRepo
+        )
+      )
+    ).toBeNull()
+    expect(mocks.review).not.toHaveBeenCalled()
+  })
+  it('binds Linear workspace and host, then rejects same identifier from another organization', async () => {
+    const context = normalizeTaskSourceContext({
+      provider: 'linear',
+      projectId: 'project',
+      hostId: 'runtime:linear-owner',
+      providerIdentity: { provider: 'linear', workspaceId: 'workspace' }
+    })
+    const item = {
+      provider: 'linear' as const,
+      type: 'issue' as const,
+      number: 0,
+      identifier: 'ENG-1',
+      url: 'https://linear.app/acme/issue/ENG-1/task',
+      taskSourceContext: context ?? undefined
+    }
+    mocks.linear.mockResolvedValue(referenceLinearIssue())
+    const request = getWorkspaceReferenceRequest(item, referenceWorkspace, referenceRepo)
+    expect((await readWorkspaceReferenceDetails(request))?.stateName).toBe('In Progress')
+    expect(mocks.linear).toHaveBeenCalledWith('ENG-1', 'workspace', { sourceContext: context })
+    mocks.linear.mockResolvedValue(
+      referenceLinearIssue({ url: 'https://linear.app/other/issue/ENG-1/task' })
+    )
+    expect(await readWorkspaceReferenceDetails(request)).toBeNull()
+  })
+  it('keys equal numbers separately by owning host and task account', () => {
+    const local = getWorkspaceReferenceRequest(
+      referenceAttachment(),
+      referenceWorkspace,
+      referenceRepo
+    )
+    const remote = getWorkspaceReferenceRequest(referenceAttachment(), referenceWorkspace, {
+      ...referenceRepo,
+      connectionId: 'owner'
+    })
+    expect(local.key).not.toBe(remote.key)
+    const context = normalizeTaskSourceContext({
+      provider: 'github',
+      projectId: 'project',
+      hostId: 'local',
+      accountLabel: 'account-a'
+    })
+    const first = getWorkspaceReferenceRequest(
+      { ...referenceAttachment(), taskSourceContext: context ?? undefined },
+      referenceWorkspace,
+      referenceRepo
+    )
+    const second = getWorkspaceReferenceRequest(
+      {
+        ...referenceAttachment(),
+        taskSourceContext: context ? { ...context, accountLabel: 'account-b' } : undefined
+      },
+      referenceWorkspace,
+      referenceRepo
+    )
+    expect(first.key).not.toBe(second.key)
+    expect(
+      getWorkspaceReferenceRequest(referenceAttachment(), referenceWorkspace, {
+        ...referenceRepo,
+        ghAccount: { host: 'github.com', user: 'other' }
+      }).key
+    ).not.toBe(local.key)
+  })
+  it('uses the same all-workspaces cache slot as the existing card when no Linear workspace is bound', async () => {
+    const source = normalizeTaskSourceContext({
+      provider: 'linear',
+      projectId: 'project',
+      hostId: 'local'
+    })
+    const item = {
+      provider: 'linear' as const,
+      type: 'issue' as const,
+      number: 0,
+      identifier: 'ENG-1',
+      taskSourceContext: source ?? undefined
+    }
+    mocks.linear.mockResolvedValue(referenceLinearIssue())
+    expect(
+      (
+        await readWorkspaceReferenceDetails(
+          getWorkspaceReferenceRequest(item, referenceWorkspace, referenceRepo)
+        )
+      )?.stateType
+    ).toBe('started')
+    expect(mocks.linear).toHaveBeenCalledWith('ENG-1', 'all', { sourceContext: source })
+  })
+  it('fails closed for incompatible per-reference account, repository binding and bare provider', async () => {
+    for (const fields of [
+      { accountLabel: 'other-account' },
+      { repoId: 'foreign-repo' },
+      { providerIdentity: { provider: 'github' as const, owner: 'other', repo: 'orca' } }
+    ]) {
+      const context = normalizeTaskSourceContext({
+        provider: 'github',
+        projectId: 'project',
+        hostId: 'local',
+        ...fields
+      })
+      const request = getWorkspaceReferenceRequest(
+        { ...referenceAttachment(), taskSourceContext: context ?? undefined },
+        referenceWorkspace,
+        referenceRepo
+      )
+      expect(await readWorkspaceReferenceDetails(request)).toBeNull()
+    }
+    const wrongProvider = getWorkspaceReferenceRequest(
+      { provider: 'gitlab', type: 'mr', number: 7 },
+      referenceWorkspace,
+      referenceRepo
+    )
+    expect(await readWorkspaceReferenceDetails(wrongProvider)).toBeNull()
+    expect(mocks.review).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/sidebar/workspace-reference-detail-read.ts b/src/renderer/src/components/sidebar/workspace-reference-detail-read.ts
new file mode 100644
index 000000000000..36eb9e28da29
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-detail-read.ts
@@ -0,0 +1,147 @@
+import { useAppStore } from '@/store'
+import type { AppState } from '@/store/types'
+import { PrioritySemaphore } from '../../../../shared/priority-semaphore'
+import { getRepoExecutionHostId } from '../../../../shared/execution-host'
+import { getTaskSourceCacheScope } from '../../../../shared/task-source-context'
+import { canReadWorkspaceReferenceReview } from './workspace-reference-review-source'
+import { isWorkspaceRepositoryAttachment } from './worktree-attachment-editing'
+import {
+  matchesWorkspaceReferenceUrl,
+  getWorkspaceReferenceLinearWorkspaceId,
+  matchWorkspaceReferenceReview,
+  type WorkspaceReferenceDetails,
+  type WorkspaceReferenceRequest
+} from './workspace-reference-details'
+
+type Entry<T> = { data: T | null; fetchedAt: number; stale?: boolean }
+const reads = new PrioritySemaphore(3)
+
+function lookup<T>(
+  entry: Entry<T> | undefined,
+  read: () => Promise<T | null>,
+  project: (value: T) => WorkspaceReferenceDetails | null
+) {
+  return {
+    rawEntry: entry,
+    entry: entry && { ...entry, data: entry.data && project(entry.data) },
+    read: async () => {
+      const value = await read()
+      return value && project(value)
+    }
+  }
+}
+
+export function getWorkspaceReferenceLookup(request: WorkspaceReferenceRequest, state: AppState) {
+  const { item, workspace, repo, sourceContext } = request
+  if (item.type !== 'issue') {
+    if (!repo || !canReadWorkspaceReferenceReview(request, request.knownProvider)) {
+      return null
+    }
+    return lookup(
+      state.hostedReviewCache?.[request.key],
+      () =>
+        state.fetchHostedReviewForBranch(repo.path, workspace.branch ?? '', {
+          exactReviewKey: request.key,
+          repoId: repo.id,
+          repoOwnerExecutionHostId: getRepoExecutionHostId(repo),
+          admissionTier: request.admissionTier ?? 'interactive',
+          linkedGitHubPR: item.provider === 'github' ? item.number : null,
+          linkedGitLabMR: item.provider === 'gitlab' ? item.number : null,
+          linkedBitbucketPR: item.provider === 'bitbucket' ? item.number : null,
+          linkedAzureDevOpsPR: item.provider === 'azure-devops' ? item.number : null,
+          linkedGiteaPR: item.provider === 'gitea' ? item.number : null
+        }),
+      (review) =>
+        matchWorkspaceReferenceReview(item, review)
+          ? { title: review.title, url: review.url, review }
+          : null
+    )
+  }
+  if (!sourceContext) {
+    return null
+  }
+  const scope = getTaskSourceCacheScope(sourceContext)
+  const identifier = item.identifier ?? item.linearIdentifier ?? item.jiraIdentifier
+  if (item.provider === 'linear' && identifier && sourceContext.provider === 'linear') {
+    const workspaceId = getWorkspaceReferenceLinearWorkspaceId(
+      item.linearWorkspaceId,
+      sourceContext
+    )
+    return lookup(
+      state.linearIssueCache?.[`${scope}::${workspaceId}::${identifier}`],
+      () => state.fetchLinearIssue(identifier, workspaceId, { sourceContext }),
+      (issue) =>
+        issue.identifier.toLowerCase() === identifier.toLowerCase() &&
+        matchesWorkspaceReferenceUrl(item, issue.url) &&
+        (workspaceId === 'all' || issue.workspaceId === workspaceId)
+          ? {
+              title: issue.title,
+              url: issue.url,
+              stateName: issue.state.name,
+              stateType: issue.state.type
+            }
+          : null
+    )
+  }
+  if (item.provider === 'jira' && identifier && sourceContext.provider === 'jira') {
+    const identity = sourceContext.providerIdentity
+    const siteId = identity?.provider === 'jira' ? identity.siteId : null
+    if (!siteId) {
+      return null
+    }
+    return lookup(
+      state.jiraIssueSummaryCache?.[`${scope}::${siteId}::${identifier.toUpperCase()}`],
+      () => state.lookupJiraIssueSummary(sourceContext, identifier, siteId),
+      (issue) =>
+        issue.key.toLowerCase() === identifier.toLowerCase() &&
+        issue.siteId === siteId &&
+        matchesWorkspaceReferenceUrl(item, issue.url)
+          ? {
+              title: issue.title,
+              url: issue.url,
+              stateName: issue.status.name,
+              stateType:
+                issue.status.categoryKey === 'done'
+                  ? 'completed'
+                  : issue.status.categoryKey === 'indeterminate'
+                    ? 'started'
+                    : issue.status.categoryKey === 'new'
+                      ? 'unstarted'
+                      : undefined
+            }
+          : null
+    )
+  }
+  if (
+    item.provider === 'github' &&
+    repo &&
+    sourceContext.provider === 'github' &&
+    isWorkspaceRepositoryAttachment(item, repo)
+  ) {
+    return lookup(
+      state.issueCache?.[`${scope}::${repo.id}::${item.number}`],
+      () => state.fetchIssue(repo.path, item.number, { repoId: repo.id, sourceContext }),
+      (issue) =>
+        issue.number === item.number && matchesWorkspaceReferenceUrl(item, issue.url)
+          ? { title: issue.title, url: issue.url, issueState: issue.state }
+          : null
+    )
+  }
+  return null
+}
+
+export async function readWorkspaceReferenceDetails(
+  request: WorkspaceReferenceRequest,
+  signal?: AbortSignal
+): Promise<WorkspaceReferenceDetails | null> {
+  const release = await reads.acquire(request.admissionTier === 'background' ? 1 : 0, signal)
+  try {
+    if (signal?.aborted) {
+      return null
+    }
+    return (await getWorkspaceReferenceLookup(request, useAppStore.getState())?.read()) ?? null
+  } finally {
+    // Native reads retain admission until settlement, even after demand disappears.
+    release()
+  }
+}
diff --git a/src/renderer/src/components/sidebar/workspace-reference-details.ts b/src/renderer/src/components/sidebar/workspace-reference-details.ts
new file mode 100644
index 000000000000..c83f302f9a11
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-details.ts
@@ -0,0 +1,139 @@
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import type { Repo } from '../../../../shared/repo-types'
+import {
+  type TaskSourceContext,
+  getTaskSourceCacheScope,
+  buildTaskSourceContextFromRepo
+} from '../../../../shared/task-source-context'
+import { getRepoExecutionHostId, parseExecutionHostId } from '../../../../shared/execution-host'
+import {
+  getWorkspaceAttachmentKey,
+  getWorkspaceAttachmentUrlScope
+} from '../../../../shared/workspace-attachment-normalization'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { getWorkspaceAttachmentSourceContext } from './workspace-attachment-source-result'
+import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
+import type { HostedReviewProvider } from '../../../../shared/hosted-review'
+import { getProviderRuntimeContextKey } from '@/lib/provider-runtime-context'
+import { getRuntimeEnvironmentRevision } from '@/runtime/runtime-environment-revision'
+
+export type WorkspaceReferenceDetails = {
+  stale?: boolean
+  title: string
+  url: string
+  review?: WorktreeCardPrDisplay
+  stateName?: string
+  stateType?: string
+  issueState?: 'open' | 'closed'
+}
+export type WorkspaceReferenceDetailsMap = Readonly<
+  Record<string, WorkspaceReferenceDetails | undefined>
+>
+export type WorkspaceReferenceRequest = {
+  admissionTier?: 'interactive' | 'status' | 'background'
+  knownProvider?: HostedReviewProvider
+  key: string
+  item: WorkspaceAttachment
+  workspace: Worktree
+  repo?: Repo
+  sourceContext: TaskSourceContext | null
+}
+
+export function getWorkspaceReferenceLinearWorkspaceId(
+  workspaceId?: string | null,
+  source?: TaskSourceContext | null
+): string {
+  const identity = source?.providerIdentity
+  return workspaceId ?? (identity?.provider === 'linear' ? identity.workspaceId : null) ?? 'all'
+}
+
+export function getWorkspaceReferenceRequest(
+  item: WorkspaceAttachment,
+  workspace: Worktree,
+  repo?: Repo,
+  runtimeVersion = getWorkspaceReferenceRuntimeVersion(workspace, repo)
+): WorkspaceReferenceRequest {
+  const sourceContext =
+    item.taskSourceContext ??
+    (item.type !== 'issue' && repo && (item.provider === 'github' || item.provider === 'gitlab')
+      ? buildTaskSourceContextFromRepo({
+          provider: item.provider,
+          projectId: workspace.projectId ?? repo.id,
+          repo
+        })
+      : item.provider === 'github' ||
+          item.provider === 'gitlab' ||
+          item.provider === 'linear' ||
+          item.provider === 'jira'
+        ? getWorkspaceAttachmentSourceContext(item.provider, repo, workspace)
+        : null)
+  return {
+    item,
+    workspace,
+    repo,
+    sourceContext,
+    key: JSON.stringify([
+      getWorkspaceAttachmentKey(item),
+      repo
+        ? [repo.id, repo.path, getRepoExecutionHostId(repo), repo.gitRemoteIdentity?.canonicalKey]
+        : [workspace.hostId, workspace.projectId],
+      sourceContext ? getTaskSourceCacheScope(sourceContext) : null,
+      sourceContext?.accountLabel ?? null,
+      repo?.ghAccount ?? null,
+      runtimeVersion
+    ])
+  }
+}
+
+export function getWorkspaceReferenceRuntimeVersion(workspace: Worktree, repo?: Repo): string {
+  const contexts = getWorkspaceAttachments(workspace).map((item) => item.taskSourceContext?.hostId)
+  const hosts = [
+    repo ? getRepoExecutionHostId(repo) : workspace.hostId,
+    workspace.linkedTaskSourceContext?.hostId,
+    ...contexts
+  ]
+  const environments = hosts
+    .map((hostId) => parseExecutionHostId(hostId))
+    .flatMap((host) => (host?.kind === 'runtime' ? [host.environmentId] : []))
+  return JSON.stringify([
+    getProviderRuntimeContextKey(null),
+    ...[...new Set(environments)].sort().map((id) => [id, getRuntimeEnvironmentRevision(id)])
+  ])
+}
+
+export function matchesWorkspaceReferenceUrl(item: WorkspaceAttachment, url: string): boolean {
+  return (
+    !item.url ||
+    getWorkspaceAttachmentUrlScope(item) === getWorkspaceAttachmentUrlScope({ ...item, url })
+  )
+}
+
+export function matchWorkspaceReferenceReview(
+  item: WorkspaceAttachment,
+  review: WorktreeCardPrDisplay | null | undefined
+): boolean {
+  return Boolean(
+    item.type !== 'issue' &&
+    review?.url &&
+    item.provider === review.provider &&
+    item.number === review.number &&
+    matchesWorkspaceReferenceUrl(item, review.url)
+  )
+}
+
+export function workspaceReferenceReview(
+  item: WorkspaceAttachment,
+  details: WorkspaceReferenceDetails | undefined
+): WorktreeCardPrDisplay | null {
+  if (item.provider === 'linear' || item.provider === 'jira' || item.type === 'issue') {
+    return null
+  }
+  return (
+    details?.review ?? {
+      provider: item.provider,
+      number: item.number,
+      title: item.title ?? '',
+      url: item.url
+    }
+  )
+}
diff --git a/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.test.ts b/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.test.ts
new file mode 100644
index 000000000000..9c56bb8b1408
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.test.ts
@@ -0,0 +1,167 @@
+// @vitest-environment happy-dom
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import { useAppStore } from '@/store'
+import { makeDetectedResult } from '@/store/slices/worktrees-detected-listing-fixtures'
+import { createVisibleHostedReviewRefreshScheduler } from '@/store/github/visible-hosted-review-refresh-scheduler'
+import { getHostedReviewCacheKey } from '@/store/slices/hosted-review-cache-identity'
+import { getWorkspaceReferenceRefreshTargets } from './workspace-reference-refresh-targets'
+import {
+  referenceAttachment,
+  referenceRepo,
+  referenceWorkspace,
+  referenceReview
+} from './workspace-reference-fixtures.test-support'
+vi.mock('@/store', async () => {
+  const browserWindow = globalThis.window
+  const { createTestStore } = await import('@/store/slices/github-slice-test-harness')
+  globalThis.window = browserWindow
+  return { useAppStore: createTestStore() }
+})
+const read = vi.hoisted(() => vi.fn(async () => null))
+vi.mock('./workspace-reference-detail-read', () => ({ readWorkspaceReferenceDetails: read }))
+const workspace = { ...referenceWorkspace, linkedPR: null, linkedItems: [referenceAttachment()] }
+const update = () => getWorkspaceReferenceRefreshTargets(useAppStore.getState())
+beforeEach(() => {
+  vi.useFakeTimers()
+  vi.clearAllMocks()
+  useAppStore.setState({
+    settings: null,
+    repos: [referenceRepo],
+    worktreesByRepo: { repo: [workspace] },
+    detectedWorktreesByRepo: {},
+    visibleReviewWorktreeIds: [workspace.id],
+    activeWorktreeId: null,
+    activeWorkspaceExecutionHostId: null,
+    visibleWorkspaceHostIds: null,
+    workspaceHostScope: 'all',
+    hostedReviewCache: {},
+    prCache: {},
+    tabsByWorktree: {},
+    ptyIdsByTabId: {},
+    browserTabsByWorktree: {
+      [workspace.id]: [
+        {
+          id: 'browser',
+          worktreeId: workspace.id,
+          url: '',
+          title: '',
+          loading: false,
+          faviconUrl: null,
+          canGoBack: false,
+          canGoForward: false,
+          loadError: null,
+          createdAt: 1
+        }
+      ]
+    },
+    unifiedTabsByWorktree: {},
+    agentStatusByPaneKey: {},
+    agentStatusEpoch: 0,
+    sshConnectionStates: new Map()
+  })
+})
+afterEach(() => {
+  vi.useRealTimers()
+})
+it('pauses disconnected SSH owners and only admits the owning reconnect', () => {
+  useAppStore.setState({ repos: [{ ...referenceRepo, connectionId: 'ssh-a' }] })
+  expect(update()).toEqual([])
+  for (const [targetId, status, count] of [
+    ['other', 'connected', 0],
+    ['ssh-a', 'connected', 1],
+    ['ssh-a', 'connecting', 0]
+  ] as const) {
+    useAppStore
+      .getState()
+      .sshConnectionStates.set(targetId, { targetId, status, error: null, reconnectAttempt: 0 })
+    expect(update()).toHaveLength(count)
+  }
+})
+it('shares one scheduler timer and removes queued work when the workspace leaves the viewport', async () => {
+  useAppStore.setState({
+    worktreesByRepo: {
+      repo: [
+        {
+          ...workspace,
+          linkedItems: Array.from({ length: 12 }, (_, i) => referenceAttachment(i + 1))
+        }
+      ]
+    }
+  })
+  const scheduler = createVisibleHostedReviewRefreshScheduler()
+  try {
+    scheduler.update(update())
+    scheduler.setVisible(true)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(read).toHaveBeenCalledTimes(12)
+    expect(vi.getTimerCount()).toBe(1)
+    useAppStore.setState({ visibleReviewWorktreeIds: [] })
+    scheduler.update(update())
+    expect(vi.getTimerCount()).toBe(0)
+    await vi.advanceTimersByTimeAsync(600_000)
+    expect(read).toHaveBeenCalledTimes(12)
+  } finally {
+    scheduler.dispose()
+  }
+})
+it('uses the known branch provider for sparse enterprise references', () => {
+  const repo = {
+    ...referenceRepo,
+    gitRemoteIdentity: {
+      canonicalKey: 'enterprise.test/acme/orca',
+      remoteName: 'origin',
+      remoteUrl: 'https://enterprise.test/acme/orca.git'
+    }
+  }
+  const key = getHostedReviewCacheKey(repo.path, workspace.branch, null, repo.id, null, null, true)
+  useAppStore.setState({
+    repos: [repo],
+    worktreesByRepo: {
+      repo: [{ ...workspace, linkedItems: [{ provider: 'github', type: 'pr', number: 42 }] }]
+    }
+  })
+  expect(update()).toHaveLength(0)
+  useAppStore.setState({
+    hostedReviewCache: { [key]: { data: referenceReview(), fetchedAt: Date.now() } }
+  })
+  expect(update()).toHaveLength(1)
+})
+it('retains both explicit owners when equal visible workspace IDs exist on two hosts', () => {
+  const remoteRepo = {
+    ...referenceRepo,
+    executionHostId: 'ssh:remote' as const,
+    connectionId: 'remote'
+  }
+  useAppStore.setState({
+    repos: [referenceRepo, remoteRepo],
+    worktreesByRepo: {
+      local: [{ ...workspace, hostId: 'local' }],
+      remote: [{ ...workspace, hostId: 'ssh:remote' }]
+    },
+    sshConnectionStates: new Map([
+      ['remote', { targetId: 'remote', status: 'connected', error: null, reconnectAttempt: 0 }]
+    ])
+  })
+  const targets = update()
+  expect(targets).toHaveLength(2)
+  expect(new Set(targets.map((target) => target.key)).size).toBe(2)
+  useAppStore.setState({ visibleWorkspaceHostIds: ['local'] })
+  expect(update()).toHaveLength(1)
+  useAppStore.setState({
+    activeWorktreeId: workspace.id,
+    activeWorkspaceExecutionHostId: 'ssh:remote'
+  })
+  expect(
+    getWorkspaceReferenceRefreshTargets(useAppStore.getState(), { selectedOnly: true })
+  ).toHaveLength(1)
+})
+
+it('admits attached reviews on visible external detected worktrees', () => {
+  useAppStore.setState({
+    worktreesByRepo: {},
+    detectedWorktreesByRepo: {
+      repo: makeDetectedResult('repo', [workspace])
+    }
+  })
+  expect(update()).toHaveLength(1)
+})
diff --git a/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.ts b/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.ts
new file mode 100644
index 000000000000..9a9c5a564d45
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-refresh-targets.ts
@@ -0,0 +1,89 @@
+import type { AppState } from '@/store/types'
+import { useAppStore } from '@/store'
+import { getVisibleHostedReviewWorkspaces } from '@/store/github/visible-hosted-review-refresh-targets'
+import { getHostedReviewCacheKey } from '@/store/slices/hosted-review-cache-identity'
+import type { VisibleHostedReviewRefreshTarget } from '@/store/github/visible-hosted-review-refresh-scheduler'
+import { reviewRefreshIntervalMs } from '../../../../shared/review-refresh-policy'
+import { withTimeout } from '../../../../shared/promise-timeout-fallback'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import {
+  getWorkspaceReferenceRequest,
+  getWorkspaceReferenceRuntimeVersion,
+  matchWorkspaceReferenceReview
+} from './workspace-reference-details'
+import { canReadWorkspaceReferenceReview } from './workspace-reference-review-source'
+import { readWorkspaceReferenceDetails } from './workspace-reference-detail-read'
+import { selectIsSleepingWorktree } from './use-worktree-sleep-state'
+
+export function getWorkspaceReferenceRefreshTargets(
+  state: AppState,
+  options?: { selectedOnly?: boolean }
+): VisibleHostedReviewRefreshTarget[] {
+  const targets = new Map<string, VisibleHostedReviewRefreshTarget>()
+  for (const { worktree, repo, candidate, selected } of getVisibleHostedReviewWorkspaces(
+    state,
+    options
+  )) {
+    if (selectIsSleepingWorktree(state, worktree.id)) {
+      continue
+    }
+    const branchKey = getHostedReviewCacheKey(
+      repo.path,
+      candidate.branch,
+      state.settings,
+      repo.id,
+      repo.connectionId,
+      repo.executionHostId,
+      true
+    )
+    const knownProvider =
+      state.hostedReviewCache[branchKey]?.data?.provider ??
+      (state.prCache[candidate.cacheKey]?.data ? 'github' : undefined)
+    const runtimeVersion = getWorkspaceReferenceRuntimeVersion(worktree, repo)
+    for (const item of getWorkspaceAttachments(worktree)) {
+      if (item.type === 'issue') {
+        continue
+      }
+      const request = {
+        ...getWorkspaceReferenceRequest(item, worktree, repo, runtimeVersion),
+        knownProvider
+      }
+      if (!canReadWorkspaceReferenceReview(request, knownProvider)) {
+        continue
+      }
+      const key = request.key
+      if (targets.get(key)?.selected) {
+        continue
+      }
+      const entry = state.hostedReviewCache[key]
+      const review = matchWorkspaceReferenceReview(item, entry?.data) ? entry?.data : null
+      targets.set(key, {
+        key,
+        revision: key,
+        selected,
+        fetchedAt: entry?.fetchedAt ?? null,
+        intervalMs: reviewRefreshIntervalMs({
+          state: review?.state,
+          checksStatus: review?.status,
+          hasReview: review ? true : null,
+          selected
+        }),
+        refresh: (_force, signal) =>
+          withTimeout(
+            readWorkspaceReferenceDetails(
+              { ...request, admissionTier: selected ? 'interactive' : 'background' },
+              signal
+            ).then(
+              (data) =>
+                !signal?.aborted &&
+                data !== null &&
+                !useAppStore.getState().hostedReviewCache[key]?.stale
+            ),
+            30_000,
+            false
+          )
+      })
+    }
+  }
+  return [...targets.values()]
+}
diff --git a/src/renderer/src/components/sidebar/workspace-reference-review-source.ts b/src/renderer/src/components/sidebar/workspace-reference-review-source.ts
new file mode 100644
index 000000000000..423a9c98047a
--- /dev/null
+++ b/src/renderer/src/components/sidebar/workspace-reference-review-source.ts
@@ -0,0 +1,34 @@
+import { getRepoExecutionHostId } from '../../../../shared/execution-host'
+import type { HostedReviewProvider } from '../../../../shared/hosted-review'
+import {
+  canUseWorkspaceReviewForChecks,
+  isWorkspaceRepositoryAttachment
+} from './worktree-attachment-editing'
+import type { WorkspaceReferenceRequest } from './workspace-reference-details'
+
+export function canReadWorkspaceReferenceReview(
+  request: WorkspaceReferenceRequest,
+  knownProvider?: HostedReviewProvider
+): boolean {
+  const { item, sourceContext, repo } = request
+  if (!repo || !canUseWorkspaceReviewForChecks(item, repo, knownProvider)) {
+    return false
+  }
+  if (
+    sourceContext &&
+    (sourceContext.hostId !== getRepoExecutionHostId(repo) ||
+      (sourceContext.repoId && sourceContext.repoId !== repo.id) ||
+      (sourceContext.accountLabel &&
+        (item.provider !== 'github' || sourceContext.accountLabel !== repo.ghAccount?.user)))
+  ) {
+    return false
+  }
+  const identity = sourceContext?.providerIdentity
+  const identityUrl =
+    identity?.provider === 'github'
+      ? `https://${identity.host ?? 'github.com'}/${identity.owner}/${identity.repo}/pull/${item.number}`
+      : identity?.provider === 'gitlab' && identity.webUrl
+        ? `${identity.webUrl}/-/merge_requests/${item.number}`
+        : null
+  return !identityUrl || isWorkspaceRepositoryAttachment({ ...item, url: identityUrl }, repo)
+}
diff --git a/src/renderer/src/components/sidebar/worktree-attachment-editing.test.ts b/src/renderer/src/components/sidebar/worktree-attachment-editing.test.ts
new file mode 100644
index 000000000000..f51b8bb33dfd
--- /dev/null
+++ b/src/renderer/src/components/sidebar/worktree-attachment-editing.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { Repo } from '../../../../shared/repo-types'
+import type { WorkspaceAttachment } from '../../../../shared/worktree/types'
+import {
+  ATTACHMENT_INPUT_KINDS,
+  buildWorkspaceAttachmentEdits,
+  canUseWorkspaceReviewForChecks
+} from './worktree-attachment-editing'
+
+const language = vi.hoisted(() => ({ prefix: '' }))
+vi.mock('@/i18n/i18n', () => ({
+  translate: (_key: string, fallback: string) => language.prefix + fallback
+}))
+
+function repo(host: string): Repo {
+  return {
+    id: 'repo',
+    path: '/repo',
+    displayName: 'Repo',
+    badgeColor: '',
+    addedAt: 0,
+    gitRemoteIdentity: {
+      canonicalKey: `${host}/acme/repo`,
+      remoteName: 'origin',
+      remoteUrl: `https://${host}/acme/repo.git`
+    }
+  }
+}
+const review: WorkspaceAttachment = { provider: 'github', type: 'pr', number: 1 }
+
+describe('workspace attachment editing', () => {
+  it('translates reference type labels when rendered after a language change', () => {
+    expect(ATTACHMENT_INPUT_KINDS[0].label()).toBe('GitHub PR')
+    language.prefix = 'translated: '
+    expect(ATTACHMENT_INPUT_KINDS[0].label()).toBe('translated: GitHub PR')
+    language.prefix = ''
+  })
+  it('requires a compatible provider before a bare review can drive checks', () => {
+    expect(canUseWorkspaceReviewForChecks(review, repo('github.com'))).toBe(true)
+    expect(
+      canUseWorkspaceReviewForChecks(
+        { provider: 'gitlab', type: 'mr', number: 1 },
+        repo('github.com')
+      )
+    ).toBe(false)
+    expect(canUseWorkspaceReviewForChecks(review, repo('git.example.com'))).toBe(false)
+    expect(canUseWorkspaceReviewForChecks(review, repo('git.example.com'), 'github')).toBe(true)
+    expect(canUseWorkspaceReviewForChecks(review, undefined)).toBe(false)
+  })
+
+  it('submits base and draft snapshots without pre-merging concurrent changes', () => {
+    const initial = [{ ...review, title: 'Old' }]
+    const draft = [
+      { ...review, title: 'New', origins: [{ kind: 'observed' as const, tabId: 'tab' }] }
+    ]
+    expect(buildWorkspaceAttachmentEdits({ initial, draft })).toEqual({
+      linkedItemsBase: initial,
+      linkedItems: draft
+    })
+  })
+  it('removes a review through the collection without emitting a scalar selection', () => {
+    const mr: WorkspaceAttachment = { provider: 'gitlab', type: 'mr', number: 2 }
+    const initial = [review, mr]
+    expect(buildWorkspaceAttachmentEdits({ initial, draft: [mr] })).toEqual({
+      linkedItemsBase: initial,
+      linkedItems: [mr]
+    })
+  })
+  it('omits untouched collections', () => {
+    expect(buildWorkspaceAttachmentEdits({ initial: [review], draft: [{ ...review }] })).toEqual({})
+  })
+})
diff --git a/src/renderer/src/components/sidebar/worktree-attachment-editing.ts b/src/renderer/src/components/sidebar/worktree-attachment-editing.ts
new file mode 100644
index 000000000000..f4988487bff6
--- /dev/null
+++ b/src/renderer/src/components/sidebar/worktree-attachment-editing.ts
@@ -0,0 +1,262 @@
+import type { HostedReviewProvider } from '../../../../shared/hosted-review'
+import type { WorkspaceAttachmentMutation } from '../../../../shared/workspace-attachment-mutation'
+import { translate } from '@/i18n/i18n'
+import type { Repo } from '../../../../shared/repo-types'
+import { normalizeGitRemoteUrl } from '../../../../shared/git-remote-identity'
+import type { WorkspaceAttachment, Worktree } from '../../../../shared/worktree/types'
+import type { WorktreeMeta } from '../../../../shared/worktree/meta-types'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import {
+  getWorkspaceAttachmentKey,
+  getWorkspaceAttachmentUrlScope
+} from '../../../../shared/workspace-attachment-normalization'
+import { parseGitHubIssueOrPRLink } from '../../../../shared/github/links'
+import { parseGitLabIssueOrMRLink } from '../../../../shared/new-workspace/gitlab-links'
+import { parseLinearIssueInput } from '../../../../shared/linear/links'
+import { parseJiraIssueUrl } from '../../../../shared/jira-issue-url'
+import { isWorkItemLinkQueryTooLarge } from '../../../../shared/new-workspace/work-item-link-query-bounds'
+
+export const ATTACHMENT_INPUT_KINDS = [
+  { value: 'github-pr', label: () => translate('workspace.links.kind.github_pr', 'GitHub PR') },
+  {
+    value: 'github-issue',
+    label: () => translate('workspace.links.kind.github_issue', 'GitHub issue')
+  },
+  {
+    value: 'linear-issue',
+    label: () => translate('workspace.links.kind.linear_task', 'Linear task')
+  },
+  { value: 'gitlab-mr', label: () => translate('workspace.links.kind.gitlab_mr', 'GitLab MR') },
+  {
+    value: 'gitlab-issue',
+    label: () => translate('workspace.links.kind.gitlab_issue', 'GitLab issue')
+  },
+  {
+    value: 'jira-issue',
+    label: () => translate('workspace.links.kind.jira_task_url', 'Jira task (URL)')
+  },
+  {
+    value: 'bitbucket-pr',
+    label: () => translate('workspace.links.kind.bitbucket_pr', 'Bitbucket PR')
+  },
+  {
+    value: 'azure-devops-pr',
+    label: () => translate('workspace.links.kind.azure_devops_pr', 'Azure DevOps PR')
+  },
+  { value: 'gitea-pr', label: () => translate('workspace.links.kind.gitea_pr', 'Gitea PR') }
+] as const
+export type AttachmentInputKind = (typeof ATTACHMENT_INPUT_KINDS)[number]['value']
+
+export function isAttachmentInputKind(value: string): value is AttachmentInputKind {
+  return ATTACHMENT_INPUT_KINDS.some((kind) => kind.value === value)
+}
+
+export function workspaceAttachmentProviderLabel(item: WorkspaceAttachment): string {
+  const labels = {
+    github: 'GitHub',
+    gitlab: 'GitLab',
+    linear: 'Linear',
+    jira: 'Jira',
+    bitbucket: 'Bitbucket',
+    'azure-devops': 'Azure DevOps',
+    gitea: 'Gitea'
+  }
+  return labels[item.provider]
+}
+
+export function workspaceAttachmentLabel(item: WorkspaceAttachment): string {
+  if (item.provider === 'linear' || item.provider === 'jira') {
+    return item.identifier ?? item.linearIdentifier ?? item.jiraIdentifier ?? `#${item.number}`
+  }
+  if (item.type === 'mr') {
+    return translate('workspace.links.mrReference', 'MR !{{number}}', { number: item.number })
+  }
+  if (item.type === 'pr') {
+    return translate('workspace.links.prReference', 'PR #{{number}}', { number: item.number })
+  }
+  return translate('workspace.links.issueReference', 'Issue #{{number}}', { number: item.number })
+}
+
+export function parseWorkspaceAttachmentInput(
+  input: string,
+  kind: AttachmentInputKind
+): WorkspaceAttachment | null {
+  const value = input.trim()
+  if (!value || isWorkItemLinkQueryTooLarge(value)) {
+    return null
+  }
+  const github = parseGitHubIssueOrPRLink(value)
+  const gitlab = parseGitLabIssueOrMRLink(value)
+  const jira = parseJiraIssueUrl(value)
+  const linear = parseLinearIssueInput(value)
+  if (/^https?:\/\//i.test(value)) {
+    const otherReview = parseOtherReviewUrl(value)
+    if (otherReview) {
+      return otherReview
+    }
+    if (github) {
+      return { provider: 'github', type: github.type, number: github.number, url: value }
+    }
+    if (gitlab && Number.isSafeInteger(gitlab.number) && gitlab.number > 0) {
+      return { provider: 'gitlab', type: gitlab.type, number: gitlab.number, url: value }
+    }
+    if (jira) {
+      return {
+        provider: 'jira',
+        type: 'issue',
+        number: 0,
+        identifier: jira.issueKey,
+        jiraIdentifier: jira.issueKey,
+        url: value
+      }
+    }
+    if (linear) {
+      return {
+        provider: 'linear',
+        type: 'issue',
+        number: 0,
+        identifier: linear.identifier,
+        linearIdentifier: linear.identifier,
+        url: value,
+        linearOrganizationUrlKey: linear.organizationUrlKey
+      }
+    }
+    return null
+  }
+  if (kind === 'linear-issue') {
+    return linear
+      ? {
+          provider: 'linear',
+          type: 'issue',
+          number: 0,
+          identifier: linear.identifier,
+          linearIdentifier: linear.identifier
+        }
+      : null
+  }
+  if (kind === 'jira-issue') {
+    return null
+  }
+  const number = Number(value.replace(/^[#!]/, ''))
+  if (!/^[#!]?\d+$/.test(value) || !Number.isSafeInteger(number) || number <= 0) {
+    return null
+  }
+  if (kind === 'gitlab-mr' || kind === 'gitlab-issue') {
+    return { provider: 'gitlab', type: kind === 'gitlab-mr' ? 'mr' : 'issue', number }
+  }
+  if (kind === 'bitbucket-pr' || kind === 'azure-devops-pr' || kind === 'gitea-pr') {
+    const provider =
+      kind === 'bitbucket-pr' ? 'bitbucket' : kind === 'gitea-pr' ? 'gitea' : 'azure-devops'
+    return { provider, type: 'pr', number }
+  }
+  return { provider: 'github', type: kind === 'github-pr' ? 'pr' : 'issue', number }
+}
+
+export function buildWorkspaceAttachmentEdits({
+  initial,
+  draft
+}: {
+  initial: readonly WorkspaceAttachment[]
+  draft: readonly WorkspaceAttachment[]
+}): Partial<WorktreeMeta> & WorkspaceAttachmentMutation {
+  return JSON.stringify(initial) === JSON.stringify(draft)
+    ? {}
+    : { linkedItemsBase: [...initial], linkedItems: [...draft] }
+}
+
+export function getActiveWorkspaceReviewKey(worktree: Worktree | undefined): string | null {
+  if (!worktree) {
+    return null
+  }
+  const active = getWorkspaceAttachments(worktree).find((item) =>
+    item.provider === 'github' && item.type === 'pr'
+      ? worktree.linkedPR === item.number
+      : item.provider === 'gitlab' && item.type === 'mr'
+        ? worktree.linkedGitLabMR === item.number
+        : item.provider === 'bitbucket'
+          ? worktree.linkedBitbucketPR === item.number
+          : item.provider === 'azure-devops'
+            ? worktree.linkedAzureDevOpsPR === item.number
+            : item.provider === 'gitea'
+              ? worktree.linkedGiteaPR === item.number
+              : false
+  )
+  return active ? getWorkspaceAttachmentKey(active) : null
+}
+
+function parseOtherReviewUrl(value: string): WorkspaceAttachment | null {
+  let url: URL
+  try {
+    url = new URL(value)
+  } catch {
+    return null
+  }
+  if (url.username || url.password) {
+    return null
+  }
+  const match = /\/(pull-requests|pullrequest|pulls)\/(\d+)\/?$/.exec(url.pathname)
+  if (!match) {
+    return null
+  }
+  const number = Number(match[2])
+  if (!Number.isSafeInteger(number) || number <= 0) {
+    return null
+  }
+  const provider =
+    match[1] === 'pull-requests'
+      ? 'bitbucket'
+      : match[1] === 'pullrequest'
+        ? 'azure-devops'
+        : 'gitea'
+  return { provider, type: 'pr', number, url: value }
+}
+
+export function canUseWorkspaceReviewForChecks(
+  item: WorkspaceAttachment,
+  repo: Repo | undefined,
+  knownProvider?: HostedReviewProvider
+): boolean {
+  if (item.type === 'issue') {
+    return false
+  }
+  const host = repo?.gitRemoteIdentity?.canonicalKey.split('/')[0].toLowerCase()
+  const provider =
+    knownProvider ??
+    (host === 'github.com'
+      ? 'github'
+      : host === 'gitlab.com'
+        ? 'gitlab'
+        : host === 'bitbucket.org'
+          ? 'bitbucket'
+          : host === 'dev.azure.com' ||
+              host === 'ssh.dev.azure.com' ||
+              host?.endsWith('.visualstudio.com')
+            ? 'azure-devops'
+            : host === 'codeberg.org'
+              ? 'gitea'
+              : undefined)
+  if (provider && item.provider !== provider) {
+    return false
+  }
+  return (
+    (!item.url ? provider === item.provider : true) && isWorkspaceRepositoryAttachment(item, repo)
+  )
+}
+
+export function isWorkspaceRepositoryAttachment(
+  item: WorkspaceAttachment,
+  repo: Repo | undefined
+): boolean {
+  if (!item.url) {
+    return true
+  }
+  const remoteKey = repo?.gitRemoteIdentity?.canonicalKey
+  if (!remoteKey) {
+    return false
+  }
+  try {
+    return normalizeGitRemoteUrl(getWorkspaceAttachmentUrlScope(item)) === remoteKey
+  } catch {
+    return false
+  }
+}
diff --git a/src/renderer/src/components/sidebar/worktree-card-meta-types.ts b/src/renderer/src/components/sidebar/worktree-card-meta-types.ts
index c35ad3c9fa54..a20f309a2196 100644
--- a/src/renderer/src/components/sidebar/worktree-card-meta-types.ts
+++ b/src/renderer/src/components/sidebar/worktree-card-meta-types.ts
@@ -1,10 +1,13 @@
 import type { IssueInfo } from '../../../../shared/github/pull-request-types'
 import type {
+  Worktree,
+  WorkspaceAttachment,
   AutomationWorkspaceProvenance,
   CliWorkspaceProvenance
 } from '../../../../shared/worktree/types'
 import type { WorktreeCardPrDisplay } from './worktree-card-pr-display'
 import type { WorktreeCardDetailsHoverControl } from './worktree-card-details-hover-state'
+import type { WorkspaceReferenceDetailsMap } from './workspace-reference-details'
 
 export type WorktreeCardIssueDisplay =
   | IssueInfo
@@ -21,6 +24,7 @@ export type WorktreeCardLinearIssueDisplay = {
   title: string
   url?: string
   stateName?: string
+  stateType?: string
   labels?: string[]
 }
 
@@ -31,6 +35,9 @@ export type WorktreeCardJiraIssueDisplay = {
 }
 
 export type WorktreeCardMetaBadgesProps = {
+  referenceItems?: readonly WorkspaceAttachment[]
+  referenceDetails?: WorkspaceReferenceDetailsMap
+  linkedItemCount?: number
   issue: WorktreeCardIssueDisplay | null
   linearIssue: WorktreeCardLinearIssueDisplay | null
   jiraIssue?: WorktreeCardJiraIssueDisplay | null
@@ -44,6 +51,8 @@ export type WorktreeCardMetaBadgesRootProps = WorktreeCardMetaBadgesProps &
   React.HTMLAttributes<HTMLDivElement>
 
 export type WorktreeCardDetailsHoverProps = WorktreeCardMetaBadgesProps & {
+  workspace?: Worktree
+  onManageLinks?: (event: React.MouseEvent) => void
   children: React.ReactElement
   branchName?: string
   workspaceTitle?: string
diff --git a/src/renderer/src/components/sidebar/worktree-card-parent-content.tsx b/src/renderer/src/components/sidebar/worktree-card-parent-content.tsx
index e5aea802b84d..e5d45f60ca79 100644
--- a/src/renderer/src/components/sidebar/worktree-card-parent-content.tsx
+++ b/src/renderer/src/components/sidebar/worktree-card-parent-content.tsx
@@ -1,6 +1,7 @@
 import React from 'react'
 
 import { cn } from '@/lib/utils'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
 import { WorktreeCardHeader } from './worktree-card-header'
 import { WorktreeCardMetaRow } from './worktree-card-meta-row'
 import { WorktreeCardDetailsHover } from './WorktreeCardMeta'
@@ -27,10 +28,12 @@ export function WorktreeCardParentContent({
     stopQuickActionPointerPropagation,
     handleToggleUnreadQuick,
     statusLaneReview,
+    reviewChecks,
     branchIdentityDisplay,
     showInlineAgentList,
     titleRenaming,
     isDeleting,
+    referenceDetails,
     hoverIssue,
     hoverLinearIssue,
     hoverJiraIssue,
@@ -42,6 +45,7 @@ export function WorktreeCardParentContent({
     detailsHoverControl,
     handleRenameTitle,
     handleEditIssue,
+    handleManageLinks,
     handleEditComment,
     handleOpenGitHubIssueInOrca,
     handleOpenIssueInBrowser,
@@ -77,6 +81,9 @@ export function WorktreeCardParentContent({
   const identityContentWithHover =
     hasHoverDetails && !titleRenaming ? (
       <WorktreeCardDetailsHover
+        workspace={worktree}
+        referenceDetails={referenceDetails}
+        onManageLinks={affiliateListMode ? undefined : handleManageLinks}
         issue={hoverIssue}
         linearIssue={hoverLinearIssue}
         jiraIssue={hoverJiraIssue}
@@ -147,6 +154,7 @@ export function WorktreeCardParentContent({
             onPointerDown={stopQuickActionPointerPropagation}
             onToggleUnread={handleToggleUnreadQuick}
             prDisplay={statusLaneReview}
+            reviewChecks={reviewChecks.total > 0 ? reviewChecks : undefined}
             newCardStyle={newCardStyle}
             hasBranchIdentity={Boolean(branchIdentityDisplay)}
           />
@@ -158,7 +166,9 @@ export function WorktreeCardParentContent({
         className={cn(
           'flex min-w-0 flex-1 flex-col gap-1.5',
           // Why: inline agent rows intentionally outdent into the card gutter; inner elements handle truncation.
-          showInlineAgentList || (!newCardStyle && lineageChildren)
+          showInlineAgentList ||
+            getWorkspaceAttachments(worktree).length > 1 ||
+            (!newCardStyle && lineageChildren)
             ? 'overflow-visible'
             : 'overflow-hidden'
         )}
diff --git a/src/renderer/src/components/sidebar/worktree-card-presentation.tsx b/src/renderer/src/components/sidebar/worktree-card-presentation.tsx
index 25376e330544..b1c7a3696db0 100644
--- a/src/renderer/src/components/sidebar/worktree-card-presentation.tsx
+++ b/src/renderer/src/components/sidebar/worktree-card-presentation.tsx
@@ -1,4 +1,5 @@
 import React from 'react'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
 
 import {
   getFlushWorktreeCardPaddingLeft,
@@ -41,6 +42,11 @@ export function buildWorktreeCardPresentation(card: WorktreeCardController) {
     remoteBranchConflict,
     visibleCardTitle,
     workspacePorts,
+    referenceDetails,
+    showPR,
+    showIssue,
+    showLinearIssue,
+    showJiraIssue,
     metaIssue,
     metaLinearIssue,
     metaJiraIssue,
@@ -55,6 +61,7 @@ export function buildWorktreeCardPresentation(card: WorktreeCardController) {
     hoverComment,
     linearIssue,
     handleEditIssue,
+    handleManageLinks,
     handleEditComment,
     handleOpenGitHubIssueInOrca,
     handleOpenIssueInBrowser,
@@ -128,68 +135,23 @@ export function buildWorktreeCardPresentation(card: WorktreeCardController) {
       : undefined
   const hasHoverIdentity = Boolean(hoverWorkspaceTitle || hoverBranchName)
   const hasHoverDetails =
-    newCardStyle &&
-    (hasWorktreeCardDetails({
-      issue: hoverIssue,
-      linearIssue: hoverLinearIssue,
-      jiraIssue: hoverJiraIssue,
-      review: hoverReview,
-      comment: hoverComment,
-      automationProvenance: metaAutomationProvenance,
-      cliProvenance: metaCliProvenance
-    }) ||
+    (newCardStyle || compactCards) &&
+    (getWorkspaceAttachments(worktree).length > 0 ||
+      hasWorktreeCardDetails({
+        issue: hoverIssue,
+        linearIssue: hoverLinearIssue,
+        jiraIssue: hoverJiraIssue,
+        review: hoverReview,
+        comment: hoverComment,
+        automationProvenance: metaAutomationProvenance,
+        cliProvenance: metaCliProvenance
+      }) ||
       workspacePorts.length > 0 ||
       hasHoverIdentity)
   // Why: the parent row owns metadata hover; don't stack the title's truncation tooltip on the details popover.
-  const titleWrapper = newCardStyle
-    ? hasHoverDetails
-      ? (title: React.ReactElement): React.ReactElement => title
-      : undefined
-    : compactCards && (showBranchIdentityHover || hasDetails || hasPorts)
-      ? (title: React.ReactElement): React.ReactElement => (
-          <WorktreeCardDetailsHover
-            issue={metaIssue}
-            linearIssue={metaLinearIssue}
-            jiraIssue={metaJiraIssue}
-            review={metaReview}
-            comment={metaComment}
-            automationProvenance={metaAutomationProvenance}
-            cliProvenance={metaCliProvenance}
-            branchName={showBranchIdentityHover ? branch : undefined}
-            workspaceTitle={worktree.displayName}
-            identityOrder="branch-first"
-            detailsAfter={hasPorts ? <WorktreeCardPortsDetails ports={workspacePorts} /> : null}
-            openDelay={100}
-            // Why: compact mode also renders the plug/badge hover root; sharing one open-state made hovering the
-            // plug force-open the wider title card and race it closed (#9304), so let this title hover own its state.
-            onEditIssue={affiliateListMode ? undefined : handleEditIssue}
-            onEditComment={affiliateListMode ? undefined : handleEditComment}
-            onOpenGitHubIssueInOrca={
-              metaIssue && 'url' in metaIssue && metaIssue.url
-                ? handleOpenGitHubIssueInOrca
-                : undefined
-            }
-            onOpenIssueInBrowser={
-              metaIssue && 'url' in metaIssue && metaIssue.url
-                ? handleOpenIssueInBrowser
-                : undefined
-            }
-            onOpenLinearIssueInOrca={linearIssue?.url ? handleOpenLinearIssueInOrca : undefined}
-            onOpenReviewInOrca={
-              metaReview?.url && metaReview.provider === 'github'
-                ? handleOpenReviewInOrca
-                : undefined
-            }
-            onOpenReviewInBrowser={metaReview?.url ? handleOpenReviewInBrowser : undefined}
-            onOpenAutomation={affiliateListMode ? undefined : handleOpenAutomation}
-            onOpenAutomationRun={affiliateListMode ? undefined : handleOpenAutomationRun}
-            // Why: compact mode hides the metadata badge row, so title hover carries the review affordance.
-            onUnlinkReview={!affiliateListMode && canUnlinkReview ? handleUnlinkReview : undefined}
-          >
-            {title}
-          </WorktreeCardDetailsHover>
-        )
-      : undefined
+  const titleWrapper = hasHoverDetails
+    ? (title: React.ReactElement): React.ReactElement => title
+    : undefined
   // Why: sidebar rows need a small surface inset while content stays aligned with the pre-inset layout.
   const applyNewCardStyleStatusLaneOffset = newCardStyle && showCombinedStatusSlot
   const cardPaddingLeft = flushSurface
@@ -202,12 +164,27 @@ export function buildWorktreeCardPresentation(card: WorktreeCardController) {
       ? getNewCardStyleParentContentMarginLeft(contentIndent)
       : 0
   const cardStyle = cardPaddingLeft ? { paddingLeft: cardPaddingLeft } : undefined
+  const allReferenceItems = getWorkspaceAttachments(worktree)
+  const referenceItems = allReferenceItems.filter((item) =>
+    item.type !== 'issue'
+      ? showPR &&
+        (!newCardStyle ||
+          allReferenceItems.filter((candidate) => candidate.type !== 'issue').length > 1)
+      : item.provider === 'linear'
+        ? showLinearIssue
+        : item.provider === 'jira'
+          ? showJiraIssue
+          : showIssue
+  )
   const detailsAndPortsContent =
     hasDetails || hasPorts ? (
       <div className="flex shrink-0 items-center gap-1">
         {hasPorts && <WorktreeCardPortsTrigger ports={workspacePorts} />}
         {hasDetails && (
           <WorktreeCardMetaBadges
+            linkedItemCount={allReferenceItems.length}
+            referenceItems={referenceItems}
+            referenceDetails={referenceDetails}
             issue={metaIssue}
             linearIssue={metaLinearIssue}
             jiraIssue={metaJiraIssue}
@@ -221,8 +198,11 @@ export function buildWorktreeCardPresentation(card: WorktreeCardController) {
       </div>
     ) : null
   const detailsAndPorts =
-    detailsAndPortsContent && !newCardStyle ? (
+    detailsAndPortsContent && !newCardStyle && !compactCards ? (
       <WorktreeCardDetailsHover
+        workspace={worktree}
+        referenceDetails={referenceDetails}
+        onManageLinks={affiliateListMode ? undefined : handleManageLinks}
         issue={metaIssue}
         linearIssue={metaLinearIssue}
         jiraIssue={metaJiraIssue}
diff --git a/src/renderer/src/components/sidebar/worktree-issue-displacement.ts b/src/renderer/src/components/sidebar/worktree-issue-displacement.ts
deleted file mode 100644
index bfc74e7162e4..000000000000
--- a/src/renderer/src/components/sidebar/worktree-issue-displacement.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { translate } from '@/i18n/i18n'
-import type { IssueLinkProvider } from '../../../../shared/issue-link-input'
-import {
-  isIssueFieldDirty,
-  type WorktreeMetaDraft,
-  type WorktreeMetaSnapshot
-} from './worktree-meta-updates'
-
-function formatLinkLabel(provider: IssueLinkProvider, value: string): string {
-  return provider === 'linear'
-    ? translate(
-        'auto.components.sidebar.worktreeIssueDisplacement.3f61c0a8d2',
-        'Linear {{value}}',
-        { value }
-      )
-    : translate(
-        'auto.components.sidebar.worktreeIssueDisplacement.9c4b7e1f60',
-        'GitHub #{{value}}',
-        { value }
-      )
-}
-
-/** Names the persisted links a save would drop. A workspace tracks one issue, so
- *  a changed field displaces the other provider's slot and clearing drops both.
- *  Only a dirty field displaces anything — the dialog opens focused on Comment,
- *  and an untouched row must leave every link alone. */
-export function getDisplacedLinkLabels(args: {
-  draft: WorktreeMetaDraft
-  snapshot: WorktreeMetaSnapshot
-  isFolderWorkspace: boolean
-  linkedIssue: number | null
-  linkedLinearIssue: string | null
-}): string[] | null {
-  const { draft, snapshot, isFolderWorkspace, linkedIssue, linkedLinearIssue } = args
-  if (isFolderWorkspace || !isIssueFieldDirty(draft, snapshot)) {
-    return null
-  }
-
-  const keeping = draft.issueInput.trim() === '' ? null : draft.issueProvider
-  const displaced: string[] = []
-  if (keeping !== 'linear' && linkedLinearIssue) {
-    displaced.push(formatLinkLabel('linear', linkedLinearIssue))
-  }
-  if (keeping !== 'github' && typeof linkedIssue === 'number') {
-    displaced.push(formatLinkLabel('github', String(linkedIssue)))
-  }
-  return displaced.length > 0 ? displaced : null
-}
diff --git a/src/renderer/src/components/sidebar/worktree-meta-dialog-owner.ts b/src/renderer/src/components/sidebar/worktree-meta-dialog-owner.ts
new file mode 100644
index 000000000000..b1e47898710f
--- /dev/null
+++ b/src/renderer/src/components/sidebar/worktree-meta-dialog-owner.ts
@@ -0,0 +1,16 @@
+import { parseExecutionHostId } from '../../../../shared/execution-host'
+
+export function getWorktreeMetaDialogOwner(state: {
+  activeModal: string
+  modalData: Record<string, unknown>
+}): string | null {
+  if (state.activeModal !== 'edit-meta') {
+    return null
+  }
+  const { worktreeId, repoId, executionHostId } = state.modalData
+  return JSON.stringify([
+    typeof worktreeId === 'string' ? worktreeId : '',
+    typeof repoId === 'string' ? repoId : null,
+    typeof executionHostId === 'string' ? (parseExecutionHostId(executionHostId)?.id ?? null) : null
+  ])
+}
diff --git a/src/renderer/src/components/sidebar/worktree-meta-updates.test.ts b/src/renderer/src/components/sidebar/worktree-meta-updates.test.ts
deleted file mode 100644
index 654724b89673..000000000000
--- a/src/renderer/src/components/sidebar/worktree-meta-updates.test.ts
+++ /dev/null
@@ -1,399 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { WorktreeMeta } from '../../../../shared/worktree/meta-types'
-import {
-  buildWorktreeMetaUpdates,
-  parseGitLabMergeRequestNumberForMetaField,
-  type WorktreeMetaDraft,
-  type WorktreeMetaLiveLinks,
-  type WorktreeMetaSnapshot,
-  type WorktreeReviewProvider
-} from './worktree-meta-updates'
-
-function makeDraft(overrides: Partial<WorktreeMetaDraft> = {}): WorktreeMetaDraft {
-  return {
-    displayNameInput: 'Workspace',
-    issueInput: '',
-    issueProvider: 'github',
-    reviewInput: '',
-    commentInput: '',
-    ...overrides
-  }
-}
-
-function makeSnapshot(overrides: Partial<WorktreeMetaSnapshot> = {}): WorktreeMetaSnapshot {
-  return {
-    displayName: 'Workspace',
-    comment: '',
-    issueInput: '',
-    issueProvider: 'github',
-    prInput: '',
-    ...overrides
-  }
-}
-
-/** Persistence raw-spreads updates, so a present-but-undefined key erases the
- *  stored value — the invariant is asserted on every build in this suite. */
-function buildUpdates(
-  draft: Partial<WorktreeMetaDraft>,
-  snapshot: Partial<WorktreeMetaSnapshot> = {},
-  live: WorktreeMetaLiveLinks = {},
-  reviewProvider: WorktreeReviewProvider = 'github'
-): Partial<WorktreeMeta> {
-  const updates = buildWorktreeMetaUpdates(
-    makeDraft(draft),
-    makeSnapshot(snapshot),
-    live,
-    reviewProvider
-  )
-  const undefinedKeys = Object.keys(updates).filter(
-    (key) => updates[key as keyof WorktreeMeta] === undefined
-  )
-  expect(undefinedKeys).toEqual([])
-  return updates
-}
-
-const LINEAR_LINK_KEYS = [
-  'linkedLinearIssue',
-  'linkedLinearIssueWorkspaceId',
-  'linkedLinearIssueOrganizationUrlKey'
-] as const
-
-describe('buildWorktreeMetaUpdates', () => {
-  it('writes only the GitLab MR slot in GitLab mode', () => {
-    expect(buildUpdates({ reviewInput: '!42' }, {}, {}, 'gitlab')).toEqual({
-      linkedGitLabMR: 42
-    })
-    expect(buildUpdates({ reviewInput: '' }, {}, {}, 'gitlab')).toEqual({ linkedGitLabMR: null })
-  })
-
-  it('accepts only positive MR references for the GitLab review row', () => {
-    expect(parseGitLabMergeRequestNumberForMetaField('42')).toBe(42)
-    expect(parseGitLabMergeRequestNumberForMetaField('!42')).toBe(42)
-    expect(
-      parseGitLabMergeRequestNumberForMetaField(
-        'https://gitlab.example.com/group/project/-/merge_requests/42'
-      )
-    ).toBe(42)
-    for (const invalid of [
-      '#42',
-      '0',
-      '!0',
-      '9007199254740992',
-      'https://gitlab.example.com/group/project/-/issues/42',
-      'https://gitlab.example.com/group/project/-/work_items/42',
-      'ftp://gitlab.example.com/group/project/-/merge_requests/42'
-    ]) {
-      expect(parseGitLabMergeRequestNumberForMetaField(invalid)).toBeNull()
-    }
-  })
-  // The dialog opens focused on Comment, so this is the common save path; a
-  // regression here silently destroys the user's existing link.
-  it('emits no link keys when the issue field is untouched', () => {
-    const updates = buildUpdates(
-      { issueInput: 'STA-335', issueProvider: 'linear', commentInput: 'shipping today' },
-      { issueInput: 'STA-335', issueProvider: 'linear' }
-    )
-
-    expect(updates.comment).toBe('shipping today')
-    expect(updates).not.toHaveProperty('linkedPR')
-    expect(updates).not.toHaveProperty('linkedIssue')
-    for (const key of LINEAR_LINK_KEYS) {
-      expect(updates).not.toHaveProperty(key)
-    }
-  })
-
-  it('writes a GitHub issue number and clears the Linear slots', () => {
-    expect(buildUpdates({ issueInput: '12' }, {}, { linkedLinearIssue: 'STA-335' })).toEqual({
-      linkedIssue: 12,
-      linkedLinearIssue: null,
-      linkedLinearIssueWorkspaceId: null,
-      linkedLinearIssueOrganizationUrlKey: null
-    })
-  })
-
-  // Persistence gates the remote Linear capability on key presence, so a clear
-  // for a link that never existed fails a GitHub-only save on an older runtime.
-  it('emits no Linear clear when the workspace holds no Linear link', () => {
-    const updates = buildUpdates({ issueInput: '12' })
-
-    expect(updates).toEqual({ linkedIssue: 12 })
-    for (const key of LINEAR_LINK_KEYS) {
-      expect(updates).not.toHaveProperty(key)
-    }
-  })
-
-  it('writes a bare Linear identifier and clears the stored organization key', () => {
-    expect(buildUpdates({ issueInput: 'sta-335', issueProvider: 'linear' })).toEqual({
-      linkedIssue: null,
-      linkedLinearIssue: 'STA-335',
-      linkedLinearIssueWorkspaceId: null,
-      linkedLinearIssueOrganizationUrlKey: null
-    })
-  })
-
-  it('clears every provider slot when the issue field is emptied', () => {
-    expect(
-      buildUpdates(
-        { issueInput: '  ' },
-        { issueInput: '42' },
-        { linkedIssue: 42, linkedLinearIssue: 'STA-335' }
-      )
-    ).toEqual({
-      linkedIssue: null,
-      linkedLinearIssue: null,
-      linkedLinearIssueWorkspaceId: null,
-      linkedLinearIssueOrganizationUrlKey: null
-    })
-  })
-
-  it('treats a provider switch with unchanged text as dirty', () => {
-    const updates = buildUpdates(
-      { issueInput: 'STA-335', issueProvider: 'linear' },
-      { issueInput: 'STA-335', issueProvider: 'github' }
-    )
-
-    expect(updates.linkedLinearIssue).toBe('STA-335')
-    expect(updates.linkedIssue).toBeNull()
-  })
-
-  it('displaces a Linear linked work item when the issue field changes', () => {
-    const updates = buildUpdates(
-      { issueInput: '12' },
-      {},
-      {
-        linkedLinearIssue: 'STA-335',
-        linkedWorkItemProvider: 'linear',
-        linkedWorkItemType: 'issue'
-      }
-    )
-
-    expect(updates).toHaveProperty('linkedWorkItem', null)
-    expect(updates).toHaveProperty('linkedTaskSourceContext', null)
-  })
-
-  // linkedWorkItem also records the PR or MR a workspace was created from, which
-  // the Issue row does not own and must not drop.
-  it('leaves a PR-typed work item alone', () => {
-    const updates = buildUpdates(
-      { issueInput: '12' },
-      {},
-      { linkedWorkItemProvider: 'github', linkedWorkItemType: 'pr' }
-    )
-
-    expect(updates).not.toHaveProperty('linkedWorkItem')
-    expect(updates).not.toHaveProperty('linkedTaskSourceContext')
-  })
-
-  // The row cannot render a GitLab or Jira issue, so clearing one would destroy a
-  // link the user was never shown — and neither has another editor to restore it.
-  it('leaves work items owned by other providers alone', () => {
-    for (const provider of ['jira', 'gitlab'] as const) {
-      const updates = buildUpdates(
-        { issueInput: '12' },
-        {},
-        { linkedWorkItemProvider: provider, linkedWorkItemType: 'issue' }
-      )
-
-      expect(updates).not.toHaveProperty('linkedWorkItem')
-      expect(updates).not.toHaveProperty('linkedTaskSourceContext')
-    }
-  })
-
-  // Only the spelling changed, so the field names the same issue it already
-  // holds — treating that as an edit would clear the title and source context.
-  it('emits nothing when a GitHub number is respelled with a hash', () => {
-    const updates = buildUpdates(
-      { issueInput: '#42' },
-      { issueInput: '42' },
-      { linkedIssue: 42, linkedWorkItemProvider: 'github', linkedWorkItemType: 'issue' }
-    )
-
-    expect(updates).toEqual({})
-  })
-
-  it('emits nothing when a Linear identifier is respelled in lower case', () => {
-    const updates = buildUpdates(
-      { issueInput: 'sta-335', issueProvider: 'linear' },
-      { issueInput: 'STA-335', issueProvider: 'linear' },
-      { linkedLinearIssue: 'STA-335' }
-    )
-
-    expect(updates).toEqual({})
-  })
-
-  it('emits nothing when a Linear identifier is respelled as its stored URL', () => {
-    const updates = buildUpdates(
-      { issueInput: 'https://linear.app/acme/issue/STA-335/fix-auth', issueProvider: 'linear' },
-      {
-        issueInput: 'STA-335',
-        issueProvider: 'linear',
-        linkedLinearIssueOrganizationUrlKey: 'acme'
-      },
-      { linkedLinearIssue: 'STA-335' }
-    )
-
-    expect(updates).toEqual({})
-  })
-
-  // The URL adds the org key the stored link lacked, which is worth persisting —
-  // but it still names the same issue, so its title and routing context stay.
-  it('records an organization key for a stored bare identifier without displacing it', () => {
-    const updates = buildUpdates(
-      { issueInput: 'https://linear.app/acme/issue/STA-335', issueProvider: 'linear' },
-      { issueInput: 'STA-335', issueProvider: 'linear' },
-      {
-        linkedLinearIssue: 'STA-335',
-        linkedWorkItemProvider: 'linear',
-        linkedWorkItemType: 'issue'
-      }
-    )
-
-    expect(updates.linkedLinearIssueOrganizationUrlKey).toBe('acme')
-    expect(updates).not.toHaveProperty('linkedWorkItem')
-    expect(updates).not.toHaveProperty('linkedTaskSourceContext')
-  })
-
-  // Same identifier, different organization: a team-prefix collision across two
-  // Linear workspaces is a different issue, so the stale title has to go.
-  it('displaces the work item when a URL names another organization', () => {
-    const updates = buildUpdates(
-      { issueInput: 'https://linear.app/other/issue/STA-335', issueProvider: 'linear' },
-      {
-        issueInput: 'STA-335',
-        issueProvider: 'linear',
-        linkedLinearIssueOrganizationUrlKey: 'acme'
-      },
-      {
-        linkedLinearIssue: 'STA-335',
-        linkedLinearIssueOrganizationUrlKey: 'acme',
-        linkedWorkItemProvider: 'linear',
-        linkedWorkItemType: 'issue'
-      }
-    )
-
-    expect(updates.linkedLinearIssueOrganizationUrlKey).toBe('other')
-    expect(updates).toHaveProperty('linkedWorkItem', null)
-    expect(updates).toHaveProperty('linkedTaskSourceContext', null)
-  })
-
-  // A CLI or background write can land while the dialog is open. Displacement
-  // reads live state, so the save cannot leave both provider slots populated.
-  it('clears a Linear link added after the snapshot was taken', () => {
-    const updates = buildUpdates({ issueInput: '12' }, {}, { linkedLinearIssue: 'STA-999' })
-
-    expect(updates.linkedIssue).toBe(12)
-    expect(updates.linkedLinearIssue).toBeNull()
-  })
-
-  it('clears a Linear link added after the snapshot when the field is emptied', () => {
-    const updates = buildUpdates(
-      { issueInput: '' },
-      { issueInput: '42' },
-      { linkedLinearIssue: 'STA-999' }
-    )
-
-    expect(updates.linkedIssue).toBeNull()
-    expect(updates.linkedLinearIssue).toBeNull()
-  })
-
-  it('ignores a provider switch on an empty field', () => {
-    const updates = buildUpdates(
-      { issueInput: '', issueProvider: 'linear' },
-      { issueInput: '', issueProvider: 'github' }
-    )
-
-    expect(updates).not.toHaveProperty('linkedIssue')
-    for (const key of LINEAR_LINK_KEYS) {
-      expect(updates).not.toHaveProperty(key)
-    }
-  })
-
-  it('does not displace a Linear work item when the issue field is clean', () => {
-    const updates = buildUpdates({ commentInput: 'note' }, {}, { linkedWorkItemProvider: 'linear' })
-
-    expect(updates).not.toHaveProperty('linkedWorkItem')
-    expect(updates).not.toHaveProperty('linkedTaskSourceContext')
-  })
-
-  it('leaves links untouched for unparseable issue input', () => {
-    const updates = buildUpdates(
-      { issueInput: 'not an issue', displayNameInput: 'Renamed', commentInput: 'note' },
-      { displayName: 'Workspace' }
-    )
-
-    expect(updates).toEqual({
-      comment: 'note',
-      displayName: 'Renamed'
-    })
-  })
-
-  it('clears a display name with empty string, never a present-undefined key', () => {
-    const updates = buildUpdates({ displayNameInput: '   ' }, { displayName: 'Custom Name' })
-
-    expect(updates.displayName).toBe('')
-  })
-
-  it('rejects issue URLs in the PR input', () => {
-    expect(buildUpdates({ reviewInput: 'https://github.com/stablyai/orca/issues/6933' })).toEqual(
-      {}
-    )
-  })
-
-  it('accepts PR URLs in the PR input', () => {
-    expect(buildUpdates({ reviewInput: 'https://github.com/stablyai/orca/pull/6934' })).toEqual({
-      linkedPR: 6934
-    })
-  })
-
-  it('records suppression when the user clears an explicit PR link', () => {
-    expect(buildUpdates({ reviewInput: '' }, { prInput: '6934' }, { linkedPR: 6934 })).toEqual({
-      linkedPR: null,
-      suppressedGitHubPR: 6934
-    })
-  })
-
-  it('does not invent suppression for an already-unlinked PR field', () => {
-    expect(buildUpdates({ reviewInput: '' }, {}, { linkedPR: null })).toEqual({})
-  })
-
-  it('does not suppress a PR linked in the background when the PR field is untouched', () => {
-    expect(buildUpdates({ commentInput: 'note' }, {}, { linkedPR: 6934 })).toEqual({
-      comment: 'note'
-    })
-  })
-
-  it('accepts issue URLs in the issue input', () => {
-    expect(
-      buildUpdates(
-        { issueInput: 'https://github.com/stablyai/orca/issues/6933' },
-        {},
-        { linkedLinearIssue: 'STA-335' }
-      )
-    ).toEqual({
-      linkedIssue: 6933,
-      linkedLinearIssue: null,
-      linkedLinearIssueWorkspaceId: null,
-      linkedLinearIssueOrganizationUrlKey: null
-    })
-  })
-
-  it('rejects PR URLs in the issue input', () => {
-    expect(buildUpdates({ issueInput: 'https://github.com/stablyai/orca/pull/6934' })).toEqual({})
-  })
-
-  // Persistence stamps lastActivityAt on any comment write, so re-emitting an
-  // unchanged note reorders the workspace under the time-decay sidebar sort.
-  it('emits no comment when the note is unchanged', () => {
-    const updates = buildUpdates(
-      { issueInput: '12', commentInput: 'shipping today' },
-      { comment: 'shipping today' }
-    )
-
-    expect(updates).not.toHaveProperty('comment')
-    expect(updates.linkedIssue).toBe(12)
-  })
-
-  it('clears a comment with empty string, never a present-undefined key', () => {
-    expect(buildUpdates({ commentInput: '  ' }, { comment: 'old note' }).comment).toBe('')
-  })
-})
diff --git a/src/renderer/src/components/sidebar/worktree-meta-updates.ts b/src/renderer/src/components/sidebar/worktree-meta-updates.ts
deleted file mode 100644
index f12bb38e0a70..000000000000
--- a/src/renderer/src/components/sidebar/worktree-meta-updates.ts
+++ /dev/null
@@ -1,309 +0,0 @@
-import { parseGitHubIssueOrPRLink, parseGitHubIssueOrPRNumber } from '@/lib/github-links'
-import {
-  buildLinearIssueLinkUpdates,
-  LINEAR_ISSUE_LINK_CLEARED
-} from '../../../../shared/linear/links'
-import { parseIssueLinkInput, type IssueLinkProvider } from '../../../../shared/issue-link-input'
-import type { WorkspaceSourceProvider } from '../../../../shared/new-workspace/workspace-source'
-import type { WorktreeMeta } from '../../../../shared/worktree/meta-types'
-import type { WorkspaceLinkedItem } from '../../../../shared/worktree/types'
-import { parseGitLabIssueOrMRLink } from '../../../../shared/new-workspace/gitlab-links'
-
-export type WorktreeReviewProvider = 'github' | 'gitlab'
-
-export type WorktreeMetaSavedPayload = {
-  worktreeId: string
-  updates: Partial<WorktreeMeta>
-}
-
-/** What the user currently has typed in the dialog. */
-export type WorktreeMetaDraft = {
-  displayNameInput: string
-  issueInput: string
-  issueProvider: IssueLinkProvider
-  reviewInput: string
-  commentInput: string
-}
-
-/** The persisted state the dialog was seeded from. Captured once when the
- *  dialog opens: comparing a frozen draft against a live store would let a
- *  background write move the baseline and make an untouched field "dirty". */
-export type WorktreeMetaSnapshot = {
-  displayName: string
-  comment: string
-  issueInput: string
-  issueProvider: IssueLinkProvider
-  prInput: string
-  /** Stands in for an org key the typed value omits, so re-saving a stored bare
-   *  identifier does not read as a change. */
-  linkedLinearIssueOrganizationUrlKey?: string | null
-}
-
-/** The link state as it stands now, read at save time rather than at open.
- *  Displacement is decided against this: a CLI or background write that landed
- *  while the dialog was open must not survive a save the dialog warned would
- *  displace it, and a clear must not be emitted for a slot that is already empty
- *  — persistence gates the remote Linear capability on key presence, not value. */
-export type WorktreeMetaLiveLinks = {
-  linkedPR?: number | null
-  linkedIssue?: number | null
-  linkedLinearIssue?: string | null
-  linkedLinearIssueOrganizationUrlKey?: string | null
-  linkedWorkItemProvider?: WorkspaceSourceProvider | null
-  /** `linkedWorkItem` also describes PRs and MRs, which this row does not own. */
-  linkedWorkItemType?: WorkspaceLinkedItem['type'] | null
-}
-
-export function parseExplicitGitHubIssueUrl(input: string): string | null {
-  const trimmed = input.trim()
-  const link = parseGitHubIssueOrPRLink(trimmed)
-  if (!link || link.type !== 'issue') {
-    return null
-  }
-
-  return trimmed
-}
-
-export function parseGitHubWorkItemNumberForMetaField(
-  input: string,
-  expectedType: 'issue' | 'pr'
-): number | null {
-  const link = parseGitHubIssueOrPRLink(input)
-  if (link) {
-    // Why: issue and PR numbers live in separate GitHub namespaces for refs;
-    // a URL path mismatch must not silently link the other field.
-    return link.type === expectedType ? link.number : null
-  }
-
-  return parseGitHubIssueOrPRNumber(input)
-}
-
-export function parseGitLabMergeRequestNumberForMetaField(input: string): number | null {
-  const trimmed = input.trim()
-  const direct = trimmed.startsWith('!') ? trimmed.slice(1) : trimmed
-  if (/^\d+$/.test(direct)) {
-    const number = Number(direct)
-    return Number.isSafeInteger(number) && number > 0 ? number : null
-  }
-  let url: URL
-  try {
-    url = new URL(trimmed)
-  } catch {
-    return null
-  }
-  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-    return null
-  }
-  const link = parseGitLabIssueOrMRLink(trimmed)
-  return link?.type === 'mr' && Number.isSafeInteger(link.number) && link.number > 0
-    ? link.number
-    : null
-}
-
-// Why: blanking the field means "fall back to the branch/folder name", and the
-// empty string is how that intent is persisted. Emitting `undefined` instead
-// put a present-but-undefined key into the store spread, wiping the live name
-// and crashing the worktree palette (crash a1f81ea1).
-function buildDisplayNameUpdate(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot
-): Partial<WorktreeMeta> {
-  const trimmed = draft.displayNameInput.trim()
-  return trimmed === current.displayName ? {} : { displayName: trimmed }
-}
-
-// Why: persistence bumps lastActivityAt whenever a `comment` key is present, so
-// re-emitting an unchanged note reorders the workspace under the time-decay
-// sidebar sort on a save that only touched the issue link.
-function buildCommentUpdate(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot
-): Partial<WorktreeMeta> {
-  const trimmed = draft.commentInput.trim()
-  return trimmed === current.comment ? {} : { comment: trimmed }
-}
-
-/** Which issue a value names, ignoring spelling: `42` and `#42` are one GitHub
- *  link, `sta-335`, `STA-335` and its linear.app URL are one Linear link. A
- *  Linear URL still refines a
- *  stored org key, so the key belongs to the identity — with the stored one
- *  standing in when the input omits it. Unparseable text compares as raw text:
- *  there is nothing to normalize, and the builder writes nothing for it anyway. */
-function issueLinkIdentity(
-  input: string,
-  provider: IssueLinkProvider,
-  storedLinearOrganizationUrlKey: string | null
-): string {
-  const trimmed = input.trim()
-  if (trimmed === '') {
-    return ''
-  }
-  const parsed = parseIssueLinkInput(trimmed, provider)
-  if (!parsed) {
-    return `raw:${provider}:${trimmed}`
-  }
-  if (parsed.provider === 'github') {
-    return `github:${parsed.number}`
-  }
-  const organizationUrlKey = parsed.organizationUrlKey ?? storedLinearOrganizationUrlKey ?? ''
-  return `linear:${parsed.identifier}:${organizationUrlKey.trim().toLowerCase()}`
-}
-
-// Why: normalized identity rather than trimmed text. Retyping the same issue in
-// another spelling — `42` to `#42`, `STA-335` to its URL — would otherwise enter
-// the displacement path and clear the title and source context of the very link
-// it re-states. A provider switch is only visible through the identity when
-// there is a value to reinterpret, which is the intent an empty field lacks.
-export function isIssueFieldDirty(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot
-): boolean {
-  const storedOrganizationUrlKey = current.linkedLinearIssueOrganizationUrlKey ?? null
-  return (
-    issueLinkIdentity(draft.issueInput, draft.issueProvider, storedOrganizationUrlKey) !==
-    issueLinkIdentity(current.issueInput, current.issueProvider, storedOrganizationUrlKey)
-  )
-}
-
-/** Whether the value being saved names the very issue `linkedWorkItem` already
- *  describes. Org keys only disagree when both are known: a stored link without
- *  one is not evidence of a different organization, so a URL that supplies it
- *  refines the link rather than replacing it. */
-function keepsLinkedWorkItem(
-  input: string,
-  provider: IssueLinkProvider,
-  live: WorktreeMetaLiveLinks
-): boolean {
-  const parsed = parseIssueLinkInput(input.trim(), provider)
-  if (!parsed || live.linkedWorkItemType !== 'issue') {
-    return false
-  }
-  if (parsed.provider === 'github') {
-    return live.linkedWorkItemProvider === 'github' && parsed.number === live.linkedIssue
-  }
-  if (
-    live.linkedWorkItemProvider !== 'linear' ||
-    parsed.identifier.toUpperCase() !== live.linkedLinearIssue?.trim().toUpperCase()
-  ) {
-    return false
-  }
-  const storedOrganizationUrlKey = live.linkedLinearIssueOrganizationUrlKey?.trim()
-  const nextOrganizationUrlKey = parsed.organizationUrlKey?.trim()
-  return (
-    !storedOrganizationUrlKey ||
-    !nextOrganizationUrlKey ||
-    storedOrganizationUrlKey.toLowerCase() === nextOrganizationUrlKey.toLowerCase()
-  )
-}
-
-/** Owns both provider slot families. One issue per workspace: writing one
- *  provider clears the other. Emits nothing at all unless the field changed —
- *  the dialog opens focused on Comment, so an untouched field must never
- *  destroy a link the user came here to keep. */
-function buildIssueLinkUpdates(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot,
-  live: WorktreeMetaLiveLinks
-): Partial<WorktreeMeta> {
-  if (!isIssueFieldDirty(draft, current)) {
-    return {}
-  }
-
-  const trimmed = draft.issueInput.trim()
-  // Why: the linked work item and its source context describe the issue being
-  // replaced. Leaving them would keep a stale title badge and mis-scope Linear
-  // reads — but only when the save names a *different* issue: a value that
-  // re-states the same one, such as a URL adding an org key, must keep its own
-  // title and SSH/runtime routing context. Narrow on purpose: `type` because the
-  // field also records the PR or MR a workspace was created from, and provider
-  // because GitLab and Jira issues have no slot in this row — displacing what it
-  // cannot display would destroy a link the user was never shown and has no
-  // other editor to restore it from.
-  const displacedWorkItem: Partial<WorktreeMeta> =
-    !keepsLinkedWorkItem(trimmed, draft.issueProvider, live) &&
-    (live.linkedWorkItemProvider === 'github' || live.linkedWorkItemProvider === 'linear') &&
-    live.linkedWorkItemType === 'issue'
-      ? { linkedWorkItem: null, linkedTaskSourceContext: null }
-      : {}
-
-  // Why: persistence gates the remote Linear capability on key presence, not
-  // value. A synthetic clear on a workspace that never held a Linear link would
-  // fail a GitHub-only save against an older runtime, citing Linear. Read live,
-  // not from the snapshot: a link added since the dialog opened would otherwise
-  // outlive a save that just promised to displace it.
-  const displacedLinear: Partial<WorktreeMeta> = live.linkedLinearIssue
-    ? LINEAR_ISSUE_LINK_CLEARED
-    : {}
-
-  if (trimmed === '') {
-    return {
-      linkedIssue: null,
-      ...displacedLinear,
-      ...displacedWorkItem
-    }
-  }
-
-  const parsed = parseIssueLinkInput(trimmed, draft.issueProvider)
-  if (!parsed) {
-    // Why: unparseable input leaves every link untouched. `canSave` already
-    // blocks this path, but the builder stays pure rather than relying on it.
-    return {}
-  }
-
-  if (parsed.provider === 'github') {
-    return {
-      linkedIssue: parsed.number,
-      ...displacedLinear,
-      ...displacedWorkItem
-    }
-  }
-
-  const linearUpdates = buildLinearIssueLinkUpdates(trimmed)
-  return linearUpdates ? { linkedIssue: null, ...linearUpdates, ...displacedWorkItem } : {}
-}
-
-function buildReviewLinkUpdate(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot,
-  live: WorktreeMetaLiveLinks,
-  provider: WorktreeReviewProvider
-): Partial<WorktreeMeta> {
-  const trimmed = draft.reviewInput.trim()
-  if (provider === 'github' && trimmed === current.prInput.trim()) {
-    return {}
-  }
-  if (trimmed === '') {
-    return provider === 'gitlab'
-      ? { linkedGitLabMR: null }
-      : {
-          linkedPR: null,
-          ...(typeof live.linkedPR === 'number' ? { suppressedGitHubPR: live.linkedPR } : {})
-        }
-  }
-  const number =
-    provider === 'gitlab'
-      ? parseGitLabMergeRequestNumberForMetaField(trimmed)
-      : parseGitHubWorkItemNumberForMetaField(trimmed, 'pr')
-  if (number === null) {
-    return {}
-  }
-  return provider === 'gitlab' ? { linkedGitLabMR: number } : { linkedPR: number }
-}
-
-/** Pure save-payload builder for the worktree meta dialog: empty inputs clear
- *  the link (null), unparseable inputs leave it untouched (omitted). No key is
- *  ever emitted holding `undefined` — persistence raw-spreads updates, so a
- *  present-but-undefined key erases the stored value. */
-export function buildWorktreeMetaUpdates(
-  draft: WorktreeMetaDraft,
-  current: WorktreeMetaSnapshot,
-  live: WorktreeMetaLiveLinks,
-  reviewProvider: WorktreeReviewProvider = 'github'
-): Partial<WorktreeMeta> {
-  return {
-    ...buildCommentUpdate(draft, current),
-    ...buildDisplayNameUpdate(draft, current),
-    ...buildIssueLinkUpdates(draft, current, live),
-    ...buildReviewLinkUpdate(draft, current, live, reviewProvider)
-  }
-}
diff --git a/src/renderer/src/components/sidebar/worktree-review-helpers.tsx b/src/renderer/src/components/sidebar/worktree-review-helpers.tsx
index b1d7eb6f0265..0b7e4d3c254d 100644
--- a/src/renderer/src/components/sidebar/worktree-review-helpers.tsx
+++ b/src/renderer/src/components/sidebar/worktree-review-helpers.tsx
@@ -30,22 +30,26 @@ export function getProviderName(review: WorktreeCardPrDisplay): string {
 // cards render one while a linked review is loading or its details failed) has no
 // state glyph to contradict, so it still flags problems — but never claims success,
 // since emerald would assert an open review we have not confirmed.
-function getCheckTone(review: WorktreeCardPrDisplay): string | null {
-  if (review.state && review.state !== 'open') {
-    return null
-  }
-  if (review.status === 'failure') {
+export function getReviewChecksTone(status: WorktreeCardPrDisplay['status']): string | null {
+  if (status === 'failure') {
     return 'text-rose-500/85'
   }
-  if (review.status === 'pending') {
+  if (status === 'pending') {
     return 'text-amber-500/85'
   }
-  if (review.state === 'open' && review.status === 'success') {
+  if (status === 'success') {
     return 'text-emerald-500/80'
   }
   return null
 }
 
+function getCheckTone(review: WorktreeCardPrDisplay): string | null {
+  if ((review.state && review.state !== 'open') || (!review.state && review.status === 'success')) {
+    return null
+  }
+  return getReviewChecksTone(review.status)
+}
+
 function getStateTone(state: WorktreeCardPrDisplay['state']): string {
   if (state === 'merged') {
     return 'text-purple-600/70 dark:text-purple-400/70'
diff --git a/src/renderer/src/components/task-page/github/Rows.tsx b/src/renderer/src/components/task-page/github/Rows.tsx
index 5894a60003ae..2597095f5ae6 100644
--- a/src/renderer/src/components/task-page/github/Rows.tsx
+++ b/src/renderer/src/components/task-page/github/Rows.tsx
@@ -70,7 +70,8 @@ export function TaskPageGitHubRows({
             allWorktrees,
             item.repoId,
             item.type,
-            item.number
+            item.number,
+            item.url
           )
           const attachedWorkspaceLabel = attachedWorkspace
             ? getWorktreeAttachmentLabel(attachedWorkspace)
diff --git a/src/renderer/src/components/ui/command.tsx b/src/renderer/src/components/ui/command.tsx
index 2178933ea08c..97237799c1f4 100644
--- a/src/renderer/src/components/ui/command.tsx
+++ b/src/renderer/src/components/ui/command.tsx
@@ -10,12 +10,27 @@ import { cn } from '@/lib/utils'
 import { handleImeOverlayEscape } from '@/lib/ime-overlay-escape'
 import { useImeTextFieldProps } from '@/lib/ime-text-field'
 
-function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>) {
+const commandSurfaceVariants = cva('', {
+  variants: {
+    surface: {
+      default: 'bg-popover text-popover-foreground',
+      inline: 'bg-transparent text-foreground'
+    }
+  },
+  defaultVariants: { surface: 'default' }
+})
+
+function Command({
+  className,
+  surface,
+  ...props
+}: React.ComponentProps<typeof CommandPrimitive> & VariantProps<typeof commandSurfaceVariants>) {
   return (
     <CommandPrimitive
       data-slot="command"
       className={cn(
-        'flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground',
+        'flex h-full w-full flex-col overflow-hidden rounded-md',
+        commandSurfaceVariants({ surface }),
         className
       )}
       {...props}
@@ -92,26 +107,35 @@ function CommandDialog({
   )
 }
 
+const commandInputVariants = cva('flex items-center bg-muted/30 px-3 py-1', {
+  variants: {
+    variant: {
+      default: 'border-b border-border',
+      framed: 'rounded-md border border-input'
+    }
+  },
+  defaultVariants: { variant: 'default' }
+})
+
 function CommandInput({
   className,
+  variant,
   wrapperClassName,
   iconClassName,
   trailing,
   ref,
   ...props
-}: React.ComponentProps<typeof CommandPrimitive.Input> & {
-  wrapperClassName?: string
-  iconClassName?: string
-  /** Rendered after the field, inside the input frame (e.g. a filter control). */
-  trailing?: React.ReactNode
-}) {
+}: React.ComponentProps<typeof CommandPrimitive.Input> &
+  VariantProps<typeof commandInputVariants> & {
+    wrapperClassName?: string
+    iconClassName?: string
+    /** Rendered after the field, inside the input frame (e.g. a filter control). */
+    trailing?: React.ReactNode
+  }) {
   const imeProps = useImeTextFieldProps<HTMLInputElement>(props)
   return (
     <div
-      className={cn(
-        'flex items-center border-b border-border bg-muted/30 px-3 py-1',
-        wrapperClassName
-      )}
+      className={cn(commandInputVariants({ variant }), wrapperClassName)}
       data-cmdk-input-wrapper=""
     >
       <SearchIcon className={cn('mr-2 h-4 w-4 shrink-0 opacity-50', iconClassName)} />
diff --git a/src/renderer/src/components/ui/hover-card.tsx b/src/renderer/src/components/ui/hover-card.tsx
index a6b69b003a1b..3c00c4b26c42 100644
--- a/src/renderer/src/components/ui/hover-card.tsx
+++ b/src/renderer/src/components/ui/hover-card.tsx
@@ -2,6 +2,7 @@
 
 import * as React from 'react'
 import * as HoverCardPrimitive from 'radix-ui/hover-card'
+import { cva, type VariantProps } from 'class-variance-authority'
 
 import { cn } from '@/lib/utils'
 
@@ -13,12 +14,25 @@ function HoverCardTrigger({ ...props }: React.ComponentProps<typeof HoverCardPri
   return <HoverCardPrimitive.Trigger data-slot="hover-card-trigger" {...props} />
 }
 
+const hoverCardContentVariants = cva('', {
+  variants: {
+    variant: {
+      default: 'w-64 p-4',
+      'workspace-details':
+        'w-[360px] max-w-[calc(100vw-2rem)] max-h-[28rem] overflow-y-auto p-3 text-xs scrollbar-sleek'
+    }
+  },
+  defaultVariants: { variant: 'default' }
+})
+
 function HoverCardContent({
   className,
+  variant,
   align = 'center',
   sideOffset = 4,
   ...props
-}: React.ComponentProps<typeof HoverCardPrimitive.Content>) {
+}: React.ComponentProps<typeof HoverCardPrimitive.Content> &
+  VariantProps<typeof hoverCardContentVariants>) {
   return (
     <HoverCardPrimitive.Portal data-slot="hover-card-portal">
       <HoverCardPrimitive.Content
@@ -31,7 +45,8 @@ function HoverCardContent({
         // dark canvas (#171717 vs #0a0a0a, ~3% white lift) with a near-
         // invisible border.
         className={cn(
-          'z-50 w-64 origin-(--radix-hover-card-content-transform-origin) rounded-md border border-black/14 bg-[rgba(255,255,255,0.82)] p-4 text-popover-foreground shadow-[0_16px_36px_rgba(0,0,0,0.24),inset_0_1px_0_rgba(255,255,255,0.14)] backdrop-blur-2xl outline-hidden dark:border-white/14 dark:bg-[rgba(0,0,0,0.72)] dark:shadow-[0_20px_44px_rgba(0,0,0,0.42),inset_0_1px_0_rgba(255,255,255,0.04)] data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95',
+          'z-50 origin-(--radix-hover-card-content-transform-origin) rounded-md border border-black/14 bg-[rgba(255,255,255,0.82)] text-popover-foreground shadow-[0_16px_36px_rgba(0,0,0,0.24),inset_0_1px_0_rgba(255,255,255,0.14)] backdrop-blur-2xl outline-hidden dark:border-white/14 dark:bg-[rgba(0,0,0,0.72)] dark:shadow-[0_20px_44px_rgba(0,0,0,0.42),inset_0_1px_0_rgba(255,255,255,0.04)] data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95',
+          hoverCardContentVariants({ variant }),
           className
         )}
         {...props}
diff --git a/src/renderer/src/components/use-task-page-workspace-actions.ts b/src/renderer/src/components/use-task-page-workspace-actions.ts
index 5e2cb6f2aab5..7373643b90c0 100644
--- a/src/renderer/src/components/use-task-page-workspace-actions.ts
+++ b/src/renderer/src/components/use-task-page-workspace-actions.ts
@@ -54,7 +54,8 @@ export function useTaskPageWorkspaceActions(model: TaskPageSearchActionsModel) {
         useAppStore.getState().allWorktrees(),
         item.repoId,
         item.type,
-        item.number
+        item.number,
+        item.url
       )
       if (!currentAttached) {
         handleUseWorkItem(item)
diff --git a/src/renderer/src/components/worktree-jump-palette-create-worktree.ts b/src/renderer/src/components/worktree-jump-palette-create-worktree.ts
index 463c4f4f6aa2..b04a341f5811 100644
--- a/src/renderer/src/components/worktree-jump-palette-create-worktree.ts
+++ b/src/renderer/src/components/worktree-jump-palette-create-worktree.ts
@@ -1,3 +1,6 @@
+import { worktreeMatchesGitHubNumber } from '@/lib/github-work-item-workspace-attachment'
+import { getPaletteWorktreeExecutionHostId } from '@/lib/palette-repo-resolution'
+import { findRepoForHost } from '@/store/slices/repo-host-identity'
 import { parseGitHubIssueOrPRLink, parseGitHubIssueOrPRNumber } from '@/lib/github-links'
 import {
   getLinkedWorkItemSuggestedName,
@@ -211,7 +214,14 @@ export function createWorktreeJumpPaletteWorktreeHandler({
       const matches = allWorktrees.filter(
         (worktree) =>
           !worktree.isArchived &&
-          (worktree.linkedIssue === ghNumber || worktree.linkedPR === ghNumber)
+          worktreeMatchesGitHubNumber(
+            worktree,
+            ghNumber,
+            findRepoForHost(state.repos, worktree.repoId, {
+              hostId: getPaletteWorktreeExecutionHostId(worktree),
+              settings: state.settings
+            }) ?? undefined
+          )
       )
       const activeMatch =
         matches.find((worktree) => worktree.repoId === state.activeRepoId) ?? matches[0]
diff --git a/src/renderer/src/i18n/en-runtime-required.json b/src/renderer/src/i18n/en-runtime-required.json
index fb8572dee168..c2d354195b9e 100644
--- a/src/renderer/src/i18n/en-runtime-required.json
+++ b/src/renderer/src/i18n/en-runtime-required.json
@@ -1995,6 +1995,22 @@
           "34f733dda2": "Go to Worktree",
           "3e5f66564e": "Workspace unavailable"
         },
+        "WorktreeIssueLinkField": {
+          "0a7a2c6efd": "Not a GitHub issue number or issue URL.",
+          "161b2d053a": "Open linked issue",
+          "25852bfc59": "Linear",
+          "269198eeda": "Couldn't open that issue. Check the number and your GitHub connection.",
+          "2c245ac134": "Saving unlinks {{link}} — a workspace tracks one issue.",
+          "5b440069e6": "GitHub",
+          "662ae142f8": "Issue #, or a GitHub or Linear URL",
+          "72486800ff": "Saving unlinks {{first}} and {{second}} — a workspace tracks one issue.",
+          "929c98d05a": "Issue provider",
+          "964d9bc00a": "Not a Linear issue key or linear.app issue URL.",
+          "ad78f9bee2": "Issue",
+          "d4785f9954": "Issue links are set when a folder workspace is created and can't be changed here yet.",
+          "d8c8a30d1f": "Couldn't open that issue. Check the identifier and your Linear connection.",
+          "f047887705": "Paste a GitHub or Linear URL, or enter a number. Leave blank to remove the link."
+        },
         "WorktreeList": {
           "2ca6e29a3c": "repo",
           "45fbfe0335": "rename",
@@ -2005,10 +2021,23 @@
         },
         "WorktreeMetaDialog": {
           "029ea5ec57": "Open GitHub issue",
+          "077a4f7b5c": "PR # or GitHub URL",
+          "1b91db7e14": "GH PR",
+          "382fd11a3e": "Edit Worktree Details",
+          "459ad7f650": "Only changes the name shown in the sidebar — the folder on disk stays the same. Leave blank to use the branch or folder name.",
+          "5ae06f40fd": "Paste a pull request URL, or enter a number. Leave blank to remove the link.",
           "645fa4a0fd": "GH Issue",
           "65770ad0f0": "Edit GitHub links and notes for this workspace.",
           "741279e7b7": "Issue # or GitHub URL",
-          "7c454be4c5": "Paste an issue URL, or enter a number. Leave blank to remove the link."
+          "7c454be4c5": "Paste an issue URL, or enter a number. Leave blank to remove the link.",
+          "7f0be5e9a6": "Supports **markdown** — bold, lists, `code`, links. Press Enter or",
+          "9c1d1e9b71": "Comment",
+          "a0d191b7a7": "Edit issue links, pull request links, and notes for this workspace.",
+          "b48c271d39": "to save, Shift+Enter for a new line.",
+          "gitlabDescription": "Edit issue links, merge request links, and notes for this workspace.",
+          "gitlabHelp": "Paste a merge request URL, or enter a number. Leave blank to remove the link.",
+          "gitlabMR": "GitLab MR",
+          "gitlabPlaceholder": "MR ! or GitLab URL"
         },
         "WorktreeOpenInMenu": {
           "3ec372b664": "file-manager"
@@ -2061,6 +2090,10 @@
               }
             }
           }
+        },
+        "worktreeIssueDisplacement": {
+          "3f61c0a8d2": "Linear {{value}}",
+          "9c4b7e1f60": "GitHub #{{value}}"
         }
       },
       "skills": {
@@ -3128,76 +3161,6 @@
     "finishEditing": "Save or cancel the preset to continue creating your workspace.",
     "pathHelp": "One repository-relative directory per line. Spaces within a path are preserved."
   },
-  "workspace": {
-    "links": {
-      "addItem": "Add {{label}}",
-      "addNotes": "Add notes",
-      "addReference": "Add reference",
-      "allReviewChecks": "Reviews: {{count}} · Checks: {{status}}",
-      "checksFailed": "Failed",
-      "checksNeutral": "Neutral",
-      "checksPassing": "Passing",
-      "checksPending": "Pending",
-      "checksUnknown": "Unknown",
-      "clearSearch": "Clear search",
-      "commentHelp": "Markdown supported. Enter or {{shortcut}} to save · Shift+Enter for a new line.",
-      "count": "{{count}} linked",
-      "description": "Attach reviews and tasks, and keep notes for this workspace.",
-      "details": "Workspace details",
-      "duplicate": "This link is already attached.",
-      "empty": "Keep every review and task for this workspace together.",
-      "foreignIssue": "This issue belongs to another repository. Add issues from this workspace’s repository.",
-      "foreignReview": "This review belongs to another repository. Add reviews from this workspace’s repository.",
-      "inlineSearchHint": "Select a result to attach it.",
-      "issueReference": "Issue #{{number}}",
-      "jiraModeRequired": "Select Smart or Jira to load this issue.",
-      "kind": {
-        "azure_devops_pr": "Azure DevOps PR",
-        "bitbucket_pr": "Bitbucket PR",
-        "gitea_pr": "Gitea PR",
-        "github_issue": "GitHub issue",
-        "github_pr": "GitHub PR",
-        "gitlab_issue": "GitLab issue",
-        "gitlab_mr": "GitLab MR",
-        "jira_task_url": "Jira task (URL)",
-        "linear_task": "Linear task"
-      },
-      "lastKnownStatus": "Last known status",
-      "linearConnectRequired": "Connect Linear in Settings to link this issue.",
-      "linearModeRequired": "Select Smart or Linear to load this issue.",
-      "linearReadFailed": "Couldn’t load this Linear issue. Check the URL and connected workspace.",
-      "loadingLinear": "Loading Linear issue…",
-      "manage": "Manage links…",
-      "mrReference": "MR !{{number}}",
-      "nameHelp": "Shown in the sidebar. The folder name stays the same.",
-      "noReferences": "No matching references. Try a title, number, or URL.",
-      "notes": "Notes",
-      "notesOptional": "Optional · Markdown",
-      "open": "Open link",
-      "openItem": "Open {{label}}",
-      "prReference": "PR #{{number}}",
-      "referenceType": "Reference type",
-      "repositoryLoading": "Repository identity is still loading. Try again once it is available.",
-      "retrySource": "Retry",
-      "reviewTarget": "Target: {{branch}}",
-      "reviewUrlRequired": "Paste the review URL to verify its repository and provider.",
-      "reviews": "Reviews",
-      "saveHint": "Changes apply when you save",
-      "searchLabel": "Search references",
-      "searchReferences": "Search reviews and tasks, or paste a link",
-      "seenIn": "Seen in {{label}}",
-      "sessions": "Sessions & terminals",
-      "sessionsForItem": "Sessions & terminals for {{label}} · {{count}}",
-      "show": "Show {{count}} linked reviews and tasks",
-      "stackSummary": "{{count}} linked: {{references}}",
-      "tasks": "Issues & tasks",
-      "terminal": "Terminal",
-      "title": "Linked work",
-      "unavailableTab": "Tab unavailable",
-      "unlink": "Unlink from workspace",
-      "unlinkItem": "Unlink {{label}}"
-    }
-  },
   "worktreeJumpPalette": {
     "filter": {
       "chipOverflow": "+{{value0}}",
diff --git a/src/renderer/src/lib/fix-checks-agent-launch.ts b/src/renderer/src/lib/fix-checks-agent-launch.ts
index 5f6131566f41..daa59baad3dd 100644
--- a/src/renderer/src/lib/fix-checks-agent-launch.ts
+++ b/src/renderer/src/lib/fix-checks-agent-launch.ts
@@ -141,7 +141,12 @@ export async function startFixChecksAgent(args: StartFixChecksAgentArgs): Promis
   const attachedWorkspace =
     args.worktreeId || !args.item
       ? null
-      : findGithubPrWorkspaceAttachment(store.allWorktrees(), args.repoId, args.item.number)
+      : findGithubPrWorkspaceAttachment(
+          store.allWorktrees(),
+          args.repoId,
+          args.item.number,
+          args.item.url
+        )
   const targetWorktreeId = args.worktreeId ?? attachedWorkspace?.id ?? null
   if (targetWorktreeId) {
     const targetWorktree = store.allWorktrees().find((worktree) => worktree.id === targetWorktreeId)
diff --git a/src/renderer/src/lib/github-work-item-workspace-attachment.test.ts b/src/renderer/src/lib/github-work-item-workspace-attachment.test.ts
index c3d3870f8033..dcc704a0453c 100644
--- a/src/renderer/src/lib/github-work-item-workspace-attachment.test.ts
+++ b/src/renderer/src/lib/github-work-item-workspace-attachment.test.ts
@@ -94,3 +94,49 @@ describe('GitHub work-item workspace attachment', () => {
     expect(findGithubIssueWorkspaceAttachment([gitlabOnly], 'repo-1', 42)).toBeNull()
   })
 })
+
+describe('multiple GitHub attachments', () => {
+  it('finds secondary reviews and issues', () => {
+    const attached = worktree({
+      linkedPR: 1,
+      linkedIssue: 2,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 3 },
+        { provider: 'github', type: 'issue', number: 4 }
+      ]
+    })
+    expect(findGithubPrWorkspaceAttachment([attached], attached.repoId, 3)).toBe(attached)
+    expect(findGithubIssueWorkspaceAttachment([attached], attached.repoId, 4)).toBe(attached)
+  })
+})
+
+describe('GitHub attachment repository scope', () => {
+  it('matches a foreign task by URL across workspace repositories', () => {
+    const attached = worktree({
+      linkedItems: [
+        {
+          provider: 'github',
+          type: 'issue',
+          number: 42,
+          url: 'https://github.com/foreign/project/issues/42'
+        }
+      ]
+    })
+    expect(
+      findGithubIssueWorkspaceAttachment(
+        [attached],
+        'foreign-repo',
+        42,
+        'https://github.com/foreign/project/issues/42'
+      )
+    ).toBe(attached)
+    expect(
+      findGithubIssueWorkspaceAttachment(
+        [attached],
+        'repo-1',
+        42,
+        'https://github.com/current/project/issues/42'
+      )
+    ).toBeNull()
+  })
+})
diff --git a/src/renderer/src/lib/github-work-item-workspace-attachment.ts b/src/renderer/src/lib/github-work-item-workspace-attachment.ts
index e8baf7f05e9b..457c67e5d371 100644
--- a/src/renderer/src/lib/github-work-item-workspace-attachment.ts
+++ b/src/renderer/src/lib/github-work-item-workspace-attachment.ts
@@ -1,4 +1,10 @@
+import type { Repo } from '../../../shared/repo-types'
+import { normalizeGitRemoteUrl } from '../../../shared/git-remote-identity'
+import { getWorkspaceAttachmentUrlScope } from '../../../shared/workspace-attachment-normalization'
+import { parseGitHubIssueOrPRLink } from '../../../shared/github/links'
+import { githubRepoIdentityKey } from '../../../shared/github/repository-identity-key'
 import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
+import { getWorkspaceAttachments } from '../../../shared/workspace-attachments'
 import type { Worktree } from '../../../shared/worktree/types'
 
 type GitHubWorkItemType = GitHubWorkItem['type']
@@ -7,19 +13,33 @@ export function findGithubWorkItemWorkspaceAttachment(
   worktrees: readonly Worktree[],
   repoId: string | null | undefined,
   type: GitHubWorkItemType,
-  number: number
+  number: number,
+  sourceUrl?: string
 ): Worktree | null {
   if (!repoId) {
     return null
   }
 
+  const source = sourceUrl ? parseGitHubIssueOrPRLink(sourceUrl) : null
   return (
     worktrees.find((worktree) => {
-      if (worktree.repoId !== repoId || worktree.isArchived) {
+      if (worktree.isArchived) {
         return false
       }
 
-      return type === 'pr' ? worktree.linkedPR === number : worktree.linkedIssue === number
+      return getWorkspaceAttachments(worktree).some((item) => {
+        if (item.provider !== 'github' || item.type !== type || item.number !== number) {
+          return false
+        }
+        const linked = item.url ? parseGitHubIssueOrPRLink(item.url) : null
+        if (source && linked) {
+          return githubRepoIdentityKey(source.slug) === githubRepoIdentityKey(linked.slug)
+        }
+        if (linked && !source) {
+          return item.repoId === repoId && worktree.repoId === repoId
+        }
+        return worktree.repoId === repoId && (!item.repoId || item.repoId === repoId)
+      })
     }) ?? null
   )
 }
@@ -27,15 +47,42 @@ export function findGithubWorkItemWorkspaceAttachment(
 export function findGithubPrWorkspaceAttachment(
   worktrees: readonly Worktree[],
   repoId: string | null | undefined,
-  prNumber: number
+  prNumber: number,
+  sourceUrl?: string
 ): Worktree | null {
-  return findGithubWorkItemWorkspaceAttachment(worktrees, repoId, 'pr', prNumber)
+  return findGithubWorkItemWorkspaceAttachment(worktrees, repoId, 'pr', prNumber, sourceUrl)
 }
 
 export function findGithubIssueWorkspaceAttachment(
   worktrees: readonly Worktree[],
   repoId: string | null | undefined,
-  issueNumber: number
+  issueNumber: number,
+  sourceUrl?: string
 ): Worktree | null {
-  return findGithubWorkItemWorkspaceAttachment(worktrees, repoId, 'issue', issueNumber)
+  return findGithubWorkItemWorkspaceAttachment(worktrees, repoId, 'issue', issueNumber, sourceUrl)
+}
+
+export function worktreeMatchesGitHubNumber(
+  worktree: Worktree,
+  number: number,
+  repo: Repo | undefined
+): boolean {
+  return getWorkspaceAttachments(worktree).some((item) => {
+    if (item.provider !== 'github' || item.number !== number) {
+      return false
+    }
+    if (item.repoId && item.repoId !== worktree.repoId) {
+      return false
+    }
+    if (item.taskSourceContext?.repoId && item.taskSourceContext.repoId !== worktree.repoId) {
+      return false
+    }
+    if (!item.url) {
+      return true
+    }
+    const remoteKey = repo?.gitRemoteIdentity?.canonicalKey
+    return Boolean(
+      remoteKey && normalizeGitRemoteUrl(getWorkspaceAttachmentUrlScope(item)) === remoteKey
+    )
+  })
 }
diff --git a/src/renderer/src/lib/hosted-review-repo-read.ts b/src/renderer/src/lib/hosted-review-repo-read.ts
new file mode 100644
index 000000000000..710b61a04d4f
--- /dev/null
+++ b/src/renderer/src/lib/hosted-review-repo-read.ts
@@ -0,0 +1,26 @@
+import { callRuntimeRpc, getActiveRuntimeTarget } from '@/runtime/runtime-rpc-client'
+import { settingsForHostedReviewRepoOwner } from '@/store/slices/hosted-review-cache-state'
+import type { AppState } from '@/store/types'
+import { getRepoExecutionHostId } from '../../../shared/execution-host'
+import type { HostedReviewForBranchArgs, HostedReviewInfo } from '../../../shared/hosted-review'
+import type { Repo } from '../../../shared/repo-types'
+
+export function readHostedReviewForRepo(
+  repo: Repo,
+  settings: AppState['settings'],
+  query: Omit<HostedReviewForBranchArgs, 'repoPath' | 'repoId' | 'repoOwnerExecutionHostId'>
+): Promise<HostedReviewInfo | null> {
+  const args = { ...query, repoPath: repo.path, repoId: repo.id }
+  const target = getActiveRuntimeTarget(settingsForHostedReviewRepoOwner(settings, repo))
+  return target.kind === 'environment'
+    ? callRuntimeRpc<HostedReviewInfo | null>(
+        target,
+        'hostedReview.forBranch',
+        { repo: repo.id, ...args },
+        { timeoutMs: 30_000 }
+      )
+    : window.api.hostedReview.forBranch({
+        ...args,
+        repoOwnerExecutionHostId: getRepoExecutionHostId(repo)
+      })
+}
diff --git a/src/renderer/src/lib/linear-issue-workspace-attachment.test.ts b/src/renderer/src/lib/linear-issue-workspace-attachment.test.ts
index 2273b6a267a0..546e1b38bde7 100644
--- a/src/renderer/src/lib/linear-issue-workspace-attachment.test.ts
+++ b/src/renderer/src/lib/linear-issue-workspace-attachment.test.ts
@@ -181,3 +181,33 @@ describe('Linear issue workspace attachment', () => {
     expect(findLinearIssueWorkspaceAttachmentInIndex(index, { identifier: 'STA-9999' })).toBeNull()
   })
 })
+
+describe('multiple Linear attachments', () => {
+  it('indexes secondary identifiers and keeps organization scope', () => {
+    const attached = worktree({
+      linkedLinearIssue: 'STA-1',
+      linkedItems: [
+        {
+          provider: 'linear',
+          type: 'issue',
+          number: 0,
+          identifier: 'STA-2',
+          linearOrganizationUrlKey: 'acme'
+        }
+      ]
+    })
+    const index = buildLinearIssueWorkspaceAttachmentIndex([attached])
+    expect(
+      findLinearIssueWorkspaceAttachmentInIndex(index, {
+        identifier: 'STA-2',
+        url: 'https://linear.app/acme/issue/STA-2'
+      })
+    ).toBe(attached)
+    expect(
+      findLinearIssueWorkspaceAttachmentInIndex(index, {
+        identifier: 'STA-2',
+        url: 'https://linear.app/other/issue/STA-2'
+      })
+    ).toBeNull()
+  })
+})
diff --git a/src/renderer/src/lib/linear-issue-workspace-attachment.ts b/src/renderer/src/lib/linear-issue-workspace-attachment.ts
index d9a9472b1dc0..cda559960c6b 100644
--- a/src/renderer/src/lib/linear-issue-workspace-attachment.ts
+++ b/src/renderer/src/lib/linear-issue-workspace-attachment.ts
@@ -1,4 +1,5 @@
 import type { LinearIssue } from '../../../shared/linear/issue-types'
+import { getWorkspaceAttachments } from '../../../shared/workspace-attachments'
 import type { Worktree } from '../../../shared/worktree/types'
 import {
   getLinearOrganizationUrlKeyFromIssueUrl,
@@ -53,12 +54,24 @@ function findScopedAttachment(
   let best: Worktree | null = null
   let bestScore = -1
   for (const worktree of candidates) {
-    const score = scopeMatchScore({
-      issueWorkspaceId: issue.workspaceId,
-      worktreeWorkspaceId: worktree.linkedLinearIssueWorkspaceId,
-      issueOrganizationUrlKey,
-      worktreeOrganizationUrlKey: worktree.linkedLinearIssueOrganizationUrlKey
-    })
+    const identifier = normalizeLinearIdentifier(issue.identifier)
+    const scores = getWorkspaceAttachments(worktree)
+      .filter(
+        (item) =>
+          item.provider === 'linear' &&
+          normalizeLinearIdentifier(item.identifier ?? item.linearIdentifier) === identifier
+      )
+      .map((item) =>
+        scopeMatchScore({
+          issueWorkspaceId: issue.workspaceId,
+          worktreeWorkspaceId: item.linearWorkspaceId,
+          issueOrganizationUrlKey,
+          worktreeOrganizationUrlKey:
+            item.linearOrganizationUrlKey ?? getLinearOrganizationUrlKeyFromIssueUrl(item.url)
+        })
+      )
+      .filter((score): score is number => score !== null)
+    const score = scores.length ? Math.max(...scores) : null
     if (
       score != null &&
       (score > bestScore ||
@@ -83,7 +96,12 @@ export function findLinearIssueWorkspaceAttachment(
   return findScopedAttachment(
     worktrees.filter(
       (worktree) =>
-        !worktree.isArchived && normalizeLinearIdentifier(worktree.linkedLinearIssue) === identifier
+        !worktree.isArchived &&
+        getWorkspaceAttachments(worktree).some(
+          (item) =>
+            item.provider === 'linear' &&
+            normalizeLinearIdentifier(item.identifier ?? item.linearIdentifier) === identifier
+        )
     ),
     issue
   )
@@ -99,15 +117,21 @@ export function buildLinearIssueWorkspaceAttachmentIndex(
     if (worktree.isArchived) {
       continue
     }
-    const identifier = normalizeLinearIdentifier(worktree.linkedLinearIssue)
-    if (!identifier) {
-      continue
-    }
-    const bucket = index.get(identifier)
-    if (bucket) {
-      bucket.push(worktree)
-    } else {
-      index.set(identifier, [worktree])
+    const identifiers = new Set(
+      getWorkspaceAttachments(worktree)
+        .filter((item) => item.provider === 'linear')
+        .map((item) => normalizeLinearIdentifier(item.identifier ?? item.linearIdentifier))
+    )
+    for (const identifier of identifiers) {
+      if (!identifier) {
+        continue
+      }
+      const bucket = index.get(identifier)
+      if (bucket) {
+        bucket.push(worktree)
+      } else {
+        index.set(identifier, [worktree])
+      }
     }
   }
   return index
diff --git a/src/renderer/src/lib/worktree-palette-attachment-urls.test.ts b/src/renderer/src/lib/worktree-palette-attachment-urls.test.ts
new file mode 100644
index 000000000000..a9b8424e7061
--- /dev/null
+++ b/src/renderer/src/lib/worktree-palette-attachment-urls.test.ts
@@ -0,0 +1,83 @@
+import { worktreeMatchesGitHubNumber } from './github-work-item-workspace-attachment'
+import { describe, expect, it } from 'vitest'
+import type { Worktree } from '../../../shared/worktree/types'
+import {
+  referenceWorkspace,
+  referenceRepo
+} from '@/components/sidebar/workspace-reference-fixtures.test-support'
+import {
+  matchWorktreePaletteTaskUrl,
+  parseCmdJTaskSourceUrl
+} from './worktree-palette-task-url-match'
+
+describe('multiple workspace task attachments', () => {
+  it.each([
+    { provider: 'github', type: 'pr', number: 42, url: 'https://github.com/acme/orca/pull/42' },
+    {
+      provider: 'gitlab',
+      type: 'mr',
+      number: 42,
+      url: 'https://gitlab.com/team/orca/-/merge_requests/42'
+    },
+    {
+      provider: 'linear',
+      type: 'issue',
+      number: 0,
+      identifier: 'STA-42',
+      url: 'https://linear.app/acme/issue/STA-42/title'
+    },
+    {
+      provider: 'jira',
+      type: 'issue',
+      number: 0,
+      identifier: 'STA-42',
+      url: 'https://acme.atlassian.net/browse/STA-42'
+    }
+  ] as const)('matches secondary $provider links by their full URL', (attachment) => {
+    const intent = parseCmdJTaskSourceUrl(attachment.url)
+    if (!intent) {
+      throw new Error('Fixture URL should parse')
+    }
+    const worktree = { ...referenceWorkspace, linkedPR: 1, linkedItems: [attachment] }
+    expect(matchWorktreePaletteTaskUrl({ worktree, intent })).not.toBeNull()
+  })
+  it('does not match a same-number review in another repository', () => {
+    const intent = parseCmdJTaskSourceUrl('https://github.com/other/project/pull/42')
+    if (!intent) {
+      throw new Error('Fixture URL should parse')
+    }
+    const worktree: Worktree = {
+      ...referenceWorkspace,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 42, url: 'https://github.com/acme/orca/pull/42' }
+      ]
+    }
+    expect(matchWorktreePaletteTaskUrl({ worktree, intent })).toBeNull()
+  })
+})
+
+describe('bare GitHub number activation', () => {
+  it.each([
+    { repoId: 'foreign' },
+    { url: 'https://github.com/foreign/project/pull/42' },
+    { repoId: 'repo', url: 'https://github.com/foreign/project/issues/42' },
+    { url: 'https://github.example.com/acme/orca/pull/42' }
+  ])('rejects foreign references even without a repo id: %j', (scope) => {
+    const worktree: Worktree = {
+      ...referenceWorkspace,
+      linkedItems: [{ provider: 'github', type: 'pr', number: 42, ...scope }]
+    }
+    expect(worktreeMatchesGitHubNumber(worktree, 42, referenceRepo)).toBe(false)
+  })
+  it('matches secondary local references and legacy bare numbers', () => {
+    const worktree: Worktree = {
+      ...referenceWorkspace,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 42, url: 'https://github.com/acme/orca/pull/42' }
+      ]
+    }
+    expect(worktreeMatchesGitHubNumber(worktree, 42, referenceRepo)).toBe(true)
+    expect(worktreeMatchesGitHubNumber(referenceWorkspace, 7, referenceRepo)).toBe(true)
+    expect(worktreeMatchesGitHubNumber(worktree, 42, undefined)).toBe(false)
+  })
+})
diff --git a/src/renderer/src/lib/worktree-palette-document.ts b/src/renderer/src/lib/worktree-palette-document.ts
index 8efa20fba222..0fa5c7c1dee9 100644
--- a/src/renderer/src/lib/worktree-palette-document.ts
+++ b/src/renderer/src/lib/worktree-palette-document.ts
@@ -3,6 +3,7 @@ import { issueCacheKey as getIssueCacheKey } from '@/store/github/cache-identity
 import { buildPaletteDocument, type PaletteDocument } from './palette-match/palette-document'
 import type { PaletteComposedEvidence } from './palette-match/evidence-composer'
 import {
+  buildWorktreeAttachmentEvidence,
   buildWorktreeAutomationEvidence,
   buildWorktreeCommentEvidence,
   buildWorktreeIssueEvidence,
@@ -17,6 +18,8 @@ import {
 } from './worktree-default-display-name'
 import type { HostedReviewInfo } from '../../../shared/hosted-review'
 import type { Repo } from '../../../shared/repo-types'
+import { getWorkspaceAttachments } from '../../../shared/workspace-attachments'
+import { getWorkspaceAttachmentKey } from '../../../shared/workspace-attachment-normalization'
 import type { Worktree } from '../../../shared/worktree/types'
 import { isGitHubPRSuppressed } from '../../../shared/worktree/github-pr-suppression'
 import {
@@ -129,6 +132,10 @@ function buildEvidence(
       number: worktree.linkedIssue,
       title: resolveIssueTitle(worktree, repo, sources)
     }),
+    ...getWorkspaceAttachments({ linkedItems: worktree.linkedItems }).map((item) => {
+      const evidence = buildWorktreeAttachmentEvidence(item)
+      return evidence ? { ...evidence, id: `attachment:${getWorkspaceAttachmentKey(item)}` } : null
+    }),
     ...ports.map((port) => buildWorktreePortEvidence(port))
   ]
   return units.filter((unit): unit is PaletteComposedEvidence => unit !== null)
diff --git a/src/renderer/src/lib/worktree-palette-evidence.ts b/src/renderer/src/lib/worktree-palette-evidence.ts
index 5a667bff16c5..951083fd61e2 100644
--- a/src/renderer/src/lib/worktree-palette-evidence.ts
+++ b/src/renderer/src/lib/worktree-palette-evidence.ts
@@ -5,7 +5,7 @@ import {
 import { extractWorktreePaletteCommentSnippet } from './worktree-palette-comment-snippet'
 import type { MatchRange } from './palette-match/normalized-text'
 import type { HostedReviewInfo } from '../../../shared/hosted-review'
-import type { Worktree } from '../../../shared/worktree/types'
+import type { WorkspaceAttachment, Worktree } from '../../../shared/worktree/types'
 
 /** Chip label kinds the worktree row can render for a supporting-evidence unit. */
 export type PaletteSupportingKind =
@@ -201,3 +201,28 @@ export function buildWorktreePortEvidence(
     ]
   })
 }
+
+export function buildWorktreeAttachmentEvidence(
+  item: WorkspaceAttachment
+): PaletteComposedEvidence | null {
+  if (item.type !== 'issue' && item.provider !== 'linear' && item.provider !== 'jira') {
+    return buildWorktreeReviewEvidence({
+      provider: item.provider,
+      number: item.number,
+      title: item.title
+    })
+  }
+  if (item.provider === 'github' || item.provider === 'gitlab') {
+    return buildWorktreeIssueEvidence(item)
+  }
+  const identifier = item.identifier ?? item.linearIdentifier ?? item.jiraIdentifier ?? ''
+  return composePaletteEvidence({
+    id: `task:${identifier}`,
+    kind: 'task',
+    accessibilityLabel: 'Linked task',
+    parts: [
+      { key: 'identifier', text: identifier, profile: 'identifier', identifier: { kind: 'key' } },
+      { key: 'title', text: item.title ?? '', profile: 'prose' }
+    ]
+  })
+}
diff --git a/src/renderer/src/lib/worktree-palette-gitlab-url-match.ts b/src/renderer/src/lib/worktree-palette-gitlab-url-match.ts
index f606ba395667..fd0e0fa25b94 100644
--- a/src/renderer/src/lib/worktree-palette-gitlab-url-match.ts
+++ b/src/renderer/src/lib/worktree-palette-gitlab-url-match.ts
@@ -10,6 +10,7 @@ import {
   type ProjectSlug
 } from '../../../shared/new-workspace/gitlab-links'
 import type { Repo } from '../../../shared/repo-types'
+import { getWorkspaceAttachments } from '../../../shared/workspace-attachments'
 import type { Worktree } from '../../../shared/worktree/types'
 
 export type GitLabIssueOrMRLink = NonNullable<ReturnType<typeof parseGitLabIssueOrMRLink>>
@@ -61,39 +62,26 @@ export function worktreeMatchesGitLabUrl(
   repo: Repo | undefined,
   review: HostedReviewInfo | null | undefined
 ): boolean {
-  const linkedUrl = worktree.linkedWorkItem?.url
-    ? parseGitLabIssueOrMRLink(worktree.linkedWorkItem.url)
-    : null
-  if (linkedUrl && gitLabLinksEqual(linkedUrl, link)) {
-    return true
-  }
-
+  const attachments = getWorkspaceAttachments(worktree).filter((item) => item.provider === 'gitlab')
+  const attached = attachments.some((item) => {
+    const itemUrl = item.url ? parseGitLabIssueOrMRLink(item.url) : null
+    if (itemUrl) {
+      return gitLabLinksEqual(itemUrl, link)
+    }
+    return (
+      item.type === link.type &&
+      item.number === link.number &&
+      repoMatchesGitLabSlug(repo, link.slug) !== false
+    )
+  })
   const reviewUrl =
     review?.provider === 'gitlab' && review.url ? parseGitLabIssueOrMRLink(review.url) : null
-  if (reviewUrl && gitLabLinksEqual(reviewUrl, link)) {
-    return true
-  }
-
-  const linkedItem = worktree.linkedWorkItem
-  const linkedItemMatches =
-    linkedItem?.provider === 'gitlab' &&
-    linkedItem.type === link.type &&
-    linkedItem.number === link.number
-  const numberMatches =
-    linkedItemMatches ||
-    (link.type === 'mr'
-      ? worktree.linkedGitLabMR === link.number
-      : worktree.linkedGitLabIssue === link.number)
-  if (!numberMatches) {
-    return false
-  }
-
-  // Why: iids are per-project, so a bare number only survives when the repo remote agrees.
-  const repoMatch = repoMatchesGitLabSlug(repo, link.slug)
-  if (repoMatch !== 'unknown') {
-    return repoMatch
-  }
-  // Identity unresolvable: stay permissive unless the stored URL names the same type+number in a
-  // different project, which is a contradiction rather than a plausible cross-project reference.
-  return !(linkedUrl && linkedUrl.type === link.type && linkedUrl.number === link.number)
+  const legacyItem = worktree.linkedWorkItem
+  const legacyNumberMatch =
+    !legacyItem?.url &&
+    legacyItem?.provider === 'gitlab' &&
+    legacyItem.type === link.type &&
+    legacyItem.number === link.number &&
+    repoMatchesGitLabSlug(repo, link.slug) !== false
+  return attached || legacyNumberMatch || Boolean(reviewUrl && gitLabLinksEqual(reviewUrl, link))
 }
diff --git a/src/renderer/src/lib/worktree-palette-search.test.ts b/src/renderer/src/lib/worktree-palette-search.test.ts
index f7d28483a36e..44afd6fb360e 100644
--- a/src/renderer/src/lib/worktree-palette-search.test.ts
+++ b/src/renderer/src/lib/worktree-palette-search.test.ts
@@ -543,3 +543,25 @@ describe('worktree-palette-search', () => {
     ).toHaveLength(1)
   })
 })
+
+describe('secondary workspace attachments in palette search', () => {
+  it('searches the number, identifier, and title of secondary links', () => {
+    const worktree = makeWorktree({
+      linkedPR: 1,
+      linkedItems: [
+        { provider: 'github', type: 'pr', number: 42, title: 'Secondary payment review' },
+        {
+          provider: 'linear',
+          type: 'issue',
+          number: 0,
+          identifier: 'STA-84',
+          title: 'Secondary payment task'
+        }
+      ]
+    })
+    const repoMap = new Map<string, Repo>()
+    expect(searchWorktrees([worktree], '#42', repoMap)).toHaveLength(1)
+    expect(searchWorktrees([worktree], 'STA-84', repoMap)).toHaveLength(1)
+    expect(searchWorktrees([worktree], 'payment', repoMap)).toHaveLength(1)
+  })
+})
diff --git a/src/renderer/src/lib/worktree-palette-task-url-match.ts b/src/renderer/src/lib/worktree-palette-task-url-match.ts
index 2e433bf5f59b..36ad2cc5c412 100644
--- a/src/renderer/src/lib/worktree-palette-task-url-match.ts
+++ b/src/renderer/src/lib/worktree-palette-task-url-match.ts
@@ -15,6 +15,7 @@ import { parseGitLabIssueOrMRLink } from '../../../shared/new-workspace/gitlab-l
 import { parseJiraIssueUrl, type ParsedJiraIssueUrl } from '../../../shared/jira-issue-url'
 import { parseLinearIssueUrlIntent, type LinearIssueUrlIntent } from '../../../shared/linear/links'
 import type { Repo } from '../../../shared/repo-types'
+import { getWorkspaceAttachments } from '../../../shared/workspace-attachments'
 import type { Worktree } from '../../../shared/worktree/types'
 import { normalizeLinearIdentifier } from './linear-issue-workspace-attachment'
 import {
@@ -202,74 +203,66 @@ function worktreeMatchesGitHubUrl(
   repo: Repo | undefined,
   review: HostedReviewInfo | null | undefined
 ): boolean {
-  const linkedUrl = worktree.linkedWorkItem?.url
-    ? parseGitHubIssueOrPRLink(worktree.linkedWorkItem.url)
-    : null
-  if (linkedUrl && githubLinksEqual(linkedUrl, link)) {
-    return true
-  }
-
+  const attachments = getWorkspaceAttachments(worktree).filter((item) => item.provider === 'github')
+  const attachmentMatch = attachments.some((item) => {
+    const itemUrl = item.url ? parseGitHubIssueOrPRLink(item.url) : null
+    if (itemUrl) {
+      return githubLinksEqual(itemUrl, link)
+    }
+    return (
+      item.type === link.type &&
+      item.number === link.number &&
+      repoMatchesGitHubSlug(repo, link.slug) !== false
+    )
+  })
   const reviewUrl = review?.url ? parseGitHubIssueOrPRLink(review.url) : null
-  if (reviewUrl && githubLinksEqual(reviewUrl, link)) {
-    return true
-  }
-
-  const linkedItem = worktree.linkedWorkItem
-  const linkedItemMatches =
-    linkedItem?.provider === 'github' &&
-    linkedItem.type === link.type &&
-    linkedItem.number === link.number
-  const numberMatches =
-    linkedItemMatches ||
-    (link.type === 'pr' ? worktree.linkedPR === link.number : worktree.linkedIssue === link.number)
-  if (!numberMatches) {
-    return false
-  }
-
-  return repoMatchesGitHubSlug(repo, link.slug) !== false
+  const legacyItem = worktree.linkedWorkItem
+  const legacyNumberMatch =
+    !legacyItem?.url &&
+    legacyItem?.provider === 'github' &&
+    legacyItem.type === link.type &&
+    legacyItem.number === link.number &&
+    repoMatchesGitHubSlug(repo, link.slug) !== false
+  return (
+    attachmentMatch || legacyNumberMatch || Boolean(reviewUrl && githubLinksEqual(reviewUrl, link))
+  )
 }
 
 function worktreeMatchesLinearUrl(worktree: Worktree, intent: LinearIssueUrlIntent): boolean {
   const identifier = normalizeLinearIdentifier(intent.identifier)
-  const linkedIdentifier =
-    normalizeLinearIdentifier(worktree.linkedLinearIssue) ??
-    normalizeLinearIdentifier(worktree.linkedWorkItem?.linearIdentifier)
-  if (!identifier || linkedIdentifier !== identifier) {
-    const linkedUrl = worktree.linkedWorkItem?.url
-      ? parseLinearIssueUrlIntent(worktree.linkedWorkItem.url)
-      : null
-    if (
-      !linkedUrl ||
-      linkedUrl.identifier !== intent.identifier ||
-      linkedUrl.organizationUrlKey.toLowerCase() !== intent.organizationUrlKey.toLowerCase()
-    ) {
+  return getWorkspaceAttachments(worktree).some((item) => {
+    if (item.provider !== 'linear') {
       return false
     }
-  }
-
-  const worktreeOrg = worktree.linkedLinearIssueOrganizationUrlKey?.trim().toLowerCase()
-  if (worktreeOrg && worktreeOrg !== intent.organizationUrlKey.toLowerCase()) {
-    return false
-  }
-  return true
+    const linkedUrl = item.url ? parseLinearIssueUrlIntent(item.url) : null
+    const linkedIdentifier = normalizeLinearIdentifier(
+      item.identifier ?? item.linearIdentifier ?? linkedUrl?.identifier
+    )
+    if (!identifier || linkedIdentifier !== identifier) {
+      return false
+    }
+    const org = (item.linearOrganizationUrlKey ?? linkedUrl?.organizationUrlKey)
+      ?.trim()
+      .toLowerCase()
+    return !org || org === intent.organizationUrlKey.toLowerCase()
+  })
 }
 
 function worktreeMatchesJiraUrl(worktree: Worktree, parsed: ParsedJiraIssueUrl): boolean {
-  const linkedUrl = worktree.linkedWorkItem?.url
-    ? parseJiraIssueUrl(worktree.linkedWorkItem.url)
-    : null
-  // Why url first: issue keys are per-project, not per-tenant, so two Jira sites
-  // routinely both have a PROJ-123. The stored URL is the only tenant evidence
-  // here, so where it exists it decides — matching on the bare identifier would
-  // jump to another tenant's worktree.
-  if (linkedUrl) {
-    return (
-      linkedUrl.issueKey === parsed.issueKey &&
-      linkedUrl.origin === parsed.origin &&
-      linkedUrl.sitePath === parsed.sitePath
-    )
-  }
-  return worktree.linkedWorkItem?.jiraIdentifier?.toUpperCase() === parsed.issueKey
+  return getWorkspaceAttachments(worktree).some((item) => {
+    if (item.provider !== 'jira') {
+      return false
+    }
+    const linkedUrl = item.url ? parseJiraIssueUrl(item.url) : null
+    if (linkedUrl) {
+      return (
+        linkedUrl.issueKey === parsed.issueKey &&
+        linkedUrl.origin === parsed.origin &&
+        linkedUrl.sitePath === parsed.sitePath
+      )
+    }
+    return (item.identifier ?? item.jiraIdentifier)?.toUpperCase() === parsed.issueKey
+  })
 }
 
 export function matchWorktreePaletteTaskUrl(args: {
diff --git a/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.test.ts b/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.test.ts
index a020347895d3..6feded76e872 100644
--- a/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.test.ts
+++ b/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.test.ts
@@ -40,6 +40,45 @@ describe('visible hosted review scheduler', () => {
     vi.useRealTimers()
   })
 
+  it.each(['remove', 'hide', 'dispose'])(
+    'aborts abandoned demand on %s without releasing native work early',
+    async (action) => {
+      const signals: (AbortSignal | undefined)[] = []
+      const finish: ((value: boolean) => void)[] = []
+      const row = target({
+        fetchedAt: null,
+        refresh: vi.fn((_force, signal) => {
+          signals.push(signal)
+          return new Promise<boolean>((resolve) => finish.push(resolve))
+        })
+      })
+      const scheduler = setup([row])
+      expect(signals[0]?.aborted).toBe(false)
+      if (action === 'remove') {
+        scheduler.update([])
+      } else if (action === 'hide') {
+        scheduler.setVisible(false)
+      } else {
+        scheduler.dispose()
+      }
+      expect(signals[0]?.aborted).toBe(true)
+      if (action !== 'dispose') {
+        scheduler.update([row])
+        scheduler.setVisible(true)
+        await vi.advanceTimersByTimeAsync(10_000)
+        expect(row.refresh).toHaveBeenCalledTimes(1)
+      }
+      finish[0](false)
+      await vi.advanceTimersByTimeAsync(0)
+      if (action !== 'dispose') {
+        expect(row.refresh).toHaveBeenCalledTimes(2)
+        expect(signals[1]?.aborted).toBe(false)
+        finish[1](true)
+        await vi.advanceTimersByTimeAsync(0)
+      }
+    }
+  )
+
   it('paces selected and other branches independently with one timer', async () => {
     const selected = target({ key: 'selected', intervalMs: 60_000, selected: true })
     const other = target()
@@ -51,8 +90,8 @@ describe('visible hosted review scheduler', () => {
     await vi.advanceTimersByTimeAsync(60_000)
     expect(selected.refresh).toHaveBeenCalledTimes(2)
     expect(other.refresh).toHaveBeenCalledTimes(1)
-    expect(selected.refresh).toHaveBeenCalledWith(false)
-    expect(other.refresh).toHaveBeenCalledWith(false)
+    expect(selected.refresh).toHaveBeenCalledWith(false, expect.any(AbortSignal))
+    expect(other.refresh).toHaveBeenCalledWith(false, expect.any(AbortSignal))
   })
 
   it('starts no hidden or offscreen requests and removes timers on disposal', async () => {
@@ -65,7 +104,7 @@ describe('visible hosted review scheduler', () => {
     scheduler.setVisible(true)
     await vi.advanceTimersByTimeAsync(0)
     expect(row.refresh).toHaveBeenCalledTimes(1)
-    expect(row.refresh).toHaveBeenCalledWith(true)
+    expect(row.refresh).toHaveBeenCalledWith(true, expect.any(AbortSignal))
     scheduler.setVisible(false)
     expect(vi.getTimerCount()).toBe(0)
     scheduler.update([])
@@ -149,7 +188,7 @@ describe('visible hosted review scheduler', () => {
       expect(row.refresh).toHaveBeenCalledTimes(calls)
       await vi.advanceTimersByTimeAsync(1)
       expect(row.refresh).toHaveBeenCalledTimes(calls + 1)
-      expect(row.refresh).toHaveBeenLastCalledWith(true)
+      expect(row.refresh).toHaveBeenLastCalledWith(true, expect.any(AbortSignal))
     }
   })
 
diff --git a/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.ts b/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.ts
index c0b8d6c2c76f..d081967614e0 100644
--- a/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.ts
+++ b/src/renderer/src/store/github/visible-hosted-review-refresh-scheduler.ts
@@ -7,7 +7,7 @@ export type VisibleHostedReviewRefreshTarget = {
   fetchedAt: number | null
   intervalMs: number | null
   selected: boolean
-  refresh: (force?: boolean) => Promise<boolean>
+  refresh: (force?: boolean, signal?: AbortSignal) => Promise<boolean>
 }
 
 type Entry = {
@@ -39,7 +39,10 @@ function discoveryIdentityChanged(
 export function createVisibleHostedReviewRefreshScheduler() {
   const entries = new Map<string, Entry>()
   const recent = new Map<string, Entry>()
-  const inFlight = new Map<string, VisibleHostedReviewRefreshTarget>()
+  const inFlight = new Map<
+    string,
+    { target: VisibleHostedReviewRefreshTarget; controller: AbortController }
+  >()
   let timer: ReturnType<typeof setTimeout> | null = null
   let visible = false
   let disposed = false
@@ -83,13 +86,17 @@ export function createVisibleHostedReviewRefreshScheduler() {
     target: VisibleHostedReviewRefreshTarget,
     succeeded: boolean
   ): void => {
+    const cancelled = inFlight.get(key)?.controller.signal.aborted
+    inFlight.get(key)?.controller.abort()
     inFlight.delete(key)
     if (disposed) {
       return
     }
     const entry = entries.get(key) ?? recent.get(key)
     if (entry && entry.lastAttemptAt === startedAt) {
-      if (!succeeded || !discoveryIdentityChanged(target, entry.target)) {
+      if (cancelled) {
+        entry.discovery = true
+      } else if (!succeeded || !discoveryIdentityChanged(target, entry.target)) {
         entry.discovery = false
         entry.failures = succeeded ? 0 : entry.failures + 1
         entry.retryAt = succeeded
@@ -130,9 +137,10 @@ export function createVisibleHostedReviewRefreshScheduler() {
       entry.lastAttemptAt = now
       entry.discovery = false
       const startedTarget = entry.target
-      inFlight.set(key, startedTarget)
+      const controller = new AbortController()
+      inFlight.set(key, { target: startedTarget, controller })
       try {
-        void entry.target.refresh(force).then(
+        void entry.target.refresh(force, controller.signal).then(
           (succeeded) => finish(key, now, startedTarget, succeeded),
           () => finish(key, now, startedTarget, false)
         )
@@ -163,6 +171,7 @@ export function createVisibleHostedReviewRefreshScheduler() {
       const keep = new Set(targets.map((target) => target.key))
       for (const [key, entry] of entries) {
         if (!keep.has(key)) {
+          inFlight.get(key)?.controller.abort()
           entries.delete(key)
           remember(key, entry)
         }
@@ -191,7 +200,7 @@ export function createVisibleHostedReviewRefreshScheduler() {
         } else if (
           (target.fetchedAt ?? -Infinity) > (entry.target.fetchedAt ?? -Infinity) &&
           (!inFlight.has(target.key) ||
-            !discoveryIdentityChanged(inFlight.get(target.key) ?? target, target))
+            !discoveryIdentityChanged(inFlight.get(target.key)?.target ?? target, target))
         ) {
           entry.failures = 0
           entry.retryAt = null
@@ -206,6 +215,11 @@ export function createVisibleHostedReviewRefreshScheduler() {
         return
       }
       visible = next
+      if (!visible) {
+        for (const request of inFlight.values()) {
+          request.controller.abort()
+        }
+      }
       if (visible) {
         for (const entry of entries.values()) {
           if (
@@ -220,6 +234,9 @@ export function createVisibleHostedReviewRefreshScheduler() {
     },
     dispose(): void {
       disposed = true
+      for (const request of inFlight.values()) {
+        request.controller.abort()
+      }
       clearTimer()
       entries.clear()
       recent.clear()
diff --git a/src/renderer/src/store/github/visible-hosted-review-refresh-targets.test.ts b/src/renderer/src/store/github/visible-hosted-review-refresh-targets.test.ts
index fdde17237c6b..aa9f9046fb03 100644
--- a/src/renderer/src/store/github/visible-hosted-review-refresh-targets.test.ts
+++ b/src/renderer/src/store/github/visible-hosted-review-refresh-targets.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { AppState } from '../types'
 import type { Repo } from '../../../../shared/repo-types'
 import type { HostedReviewInfo } from '../../../../shared/hosted-review'
 import { createGlobalSettingsFixture } from '../../../../shared/global-settings-test-fixture'
@@ -390,6 +391,45 @@ describe('visible hosted review refresh targets', () => {
     ).toEqual([])
   })
 
+  it.each<Partial<AppState>>([
+    { activeWorkspaceExecutionHostId: 'ssh:other' },
+    { visibleWorkspaceHostIds: ['local'] },
+    { workspaceHostScope: 'local' }
+  ])('updates reference demand when owner visibility changes: %j', (patch) => {
+    const store = setup()
+    const previous = store.getState()
+    const next = { ...previous, ...patch }
+    expect(visibleHostedReviewRefreshInputsChanged(next, previous)).toBe(true)
+  })
+
+  it('does not send a colliding runtime owner through the legacy unqualified GitHub action', () => {
+    const first: Repo = {
+      ...repo,
+      executionHostId: 'runtime:first',
+      gitRemoteIdentity: {
+        canonicalKey: 'github.com/acme/orca',
+        remoteName: 'origin',
+        remoteUrl: 'https://github.com/acme/orca.git'
+      }
+    }
+    const second: Repo = { ...first, executionHostId: 'runtime:second' }
+    const store = setup(first)
+    store.setState({
+      repos: [first, second],
+      activeWorktreeId: worktree.id,
+      activeWorkspaceExecutionHostId: 'runtime:second',
+      worktreesByRepo: {
+        first: [{ ...worktree, hostId: 'runtime:first' }],
+        second: [{ ...worktree, hostId: 'runtime:second' }]
+      }
+    })
+    expect(
+      getVisibleHostedReviewRefreshTargets(store.getState(), store.getState, { selectedOnly: true })
+    ).toEqual([])
+    expect(mockApi.gh.prForBranch).not.toHaveBeenCalled()
+    expect(runtimeEnvironmentCall).not.toHaveBeenCalled()
+  })
+
   it('lets normal hosted-review refreshes share the host cache but forces discovery', async () => {
     const store = setup()
     await targets(store)[0].refresh(false)
diff --git a/src/renderer/src/store/github/visible-hosted-review-refresh-targets.ts b/src/renderer/src/store/github/visible-hosted-review-refresh-targets.ts
index 240d3e684c1b..e860c8ae8fb2 100644
--- a/src/renderer/src/store/github/visible-hosted-review-refresh-targets.ts
+++ b/src/renderer/src/store/github/visible-hosted-review-refresh-targets.ts
@@ -3,13 +3,78 @@ import {
   getHostedReviewCacheKey,
   linkedReviewHintKey
 } from '../slices/hosted-review-cache-identity'
-import { getRepoExecutionHostId } from '../../../../shared/execution-host'
+import {
+  getRepoExecutionHostId,
+  getSettingsFocusedExecutionHostId
+} from '../../../../shared/execution-host'
 import { reviewRefreshIntervalMs } from '../../../../shared/review-refresh-policy'
-import { buildPRRefreshCandidate, findWorktreeById } from './worktree-refresh'
+import {
+  buildPRRefreshCandidate,
+  getWorktreeLookupIndex,
+  findWorktreeById
+} from './worktree-refresh'
+import { findIndexedDetectedWorktrees } from '@/lib/worktree-runtime-owner-index'
+import { findKnownWorktreeById } from '../slices/worktrees/listing/detected-worktree-meta'
+import { findRepoForHost } from '../slices/repo-host-identity'
+import { getGitHubRepoLookupIndex } from '../slices/github-repo-lookup-index'
 import { getPRRefreshRuntimeRepoTarget } from './repository-routing'
 import type { VisibleHostedReviewRefreshTarget } from './visible-hosted-review-refresh-scheduler'
 import { shouldCoordinateVisibleGitHubReview } from './visible-hosted-review-refresh-ownership'
 
+export function* getVisibleHostedReviewWorkspaces(
+  state: AppState,
+  options?: { selectedOnly?: boolean }
+) {
+  const visibleHosts =
+    state.visibleWorkspaceHostIds ??
+    (state.workspaceHostScope && state.workspaceHostScope !== 'all'
+      ? [state.workspaceHostScope]
+      : null)
+  for (const id of state.visibleReviewWorktreeIds) {
+    const owners = new Set(getWorktreeLookupIndex(state).byId.get(id)?.owners)
+    for (const detected of findIndexedDetectedWorktrees(state.detectedWorktreesByRepo, id)) {
+      const workspace = findKnownWorktreeById(state, id, detected.hostId ?? 'local')
+      if (workspace) {
+        owners.add(workspace)
+      }
+    }
+    for (const worktree of owners) {
+      if (worktree.isArchived || worktree.isBare) {
+        continue
+      }
+      const repo = findRepoForHost(state.repos, worktree.repoId, {
+        hostId: worktree.hostId,
+        settings: state.settings
+      })
+      if (!repo) {
+        continue
+      }
+      const candidate = buildPRRefreshCandidate(state, worktree, undefined, repo)
+      if (
+        !candidate ||
+        candidate.repoKind !== 'git' ||
+        (candidate.connectionId && candidate.connectionState !== 'connected')
+      ) {
+        continue
+      }
+      const hostId = getRepoExecutionHostId(repo)
+      const activeHost = state.activeWorkspaceExecutionHostId
+      const selected =
+        id === state.activeWorktreeId &&
+        (activeHost
+          ? hostId === activeHost
+          : owners.size === 1 || hostId === getSettingsFocusedExecutionHostId(state.settings))
+      if (
+        (options?.selectedOnly && !selected) ||
+        (!selected && visibleHosts && !visibleHosts.includes(hostId))
+      ) {
+        continue
+      }
+      yield { worktree, repo, candidate, selected }
+    }
+  }
+}
+
 export function getVisibleHostedReviewRefreshTargets(
   state: AppState,
   getState: () => AppState,
@@ -17,24 +82,12 @@ export function getVisibleHostedReviewRefreshTargets(
 ): VisibleHostedReviewRefreshTarget[] {
   const targets = new Map<string, VisibleHostedReviewRefreshTarget>()
   const revisions = new Map<string, Map<string, string>>()
-  for (const id of state.visibleReviewWorktreeIds) {
-    if (options?.selectedOnly && id !== state.activeWorktreeId) {
-      continue
-    }
-    const worktree = findWorktreeById(state, id)
-    if (!worktree || worktree.isArchived || worktree.isBare || !worktree.branch) {
-      continue
-    }
-    const candidate = buildPRRefreshCandidate(state, worktree)
-    if (
-      !candidate ||
-      candidate.repoKind !== 'git' ||
-      !candidate.branch ||
-      candidate.branch === 'HEAD'
-    ) {
-      continue
-    }
-    if (candidate.connectionId && candidate.connectionState !== 'connected') {
+  for (const { worktree, repo, candidate, selected } of getVisibleHostedReviewWorkspaces(
+    state,
+    options
+  )) {
+    const id = worktree.id
+    if (!candidate.branch || candidate.branch === 'HEAD') {
       continue
     }
     const key = getHostedReviewCacheKey(
@@ -61,12 +114,18 @@ export function getVisibleHostedReviewRefreshTargets(
       hints.linkedAzureDevOpsPR != null ||
       hints.linkedGiteaPR != null ||
       (hostedEntry?.data != null && hostedEntry.data.provider !== 'github')
+    // The legacy GitHub action still resolves bare IDs; never pass it another owner's candidate.
+    if (
+      getGitHubRepoLookupIndex(state.repos).findById(repo.id) !== repo ||
+      findWorktreeById(state, worktree.id) !== worktree
+    ) {
+      continue
+    }
     const knownGitHub = shouldCoordinateVisibleGitHubReview(state, worktree, candidate)
     const runtime = knownGitHub ? getPRRefreshRuntimeRepoTarget(state, candidate) : null
     if (knownGitHub && !runtime) {
       continue
     }
-    const selected = id === state.activeWorktreeId
     const usePR =
       knownGitHub &&
       prEntry !== undefined &&
@@ -147,11 +206,21 @@ export function visibleHostedReviewRefreshInputsChanged(
   return (
     state.visibleReviewWorktreeIds !== previous.visibleReviewWorktreeIds ||
     state.activeWorktreeId !== previous.activeWorktreeId ||
+    state.activeWorkspaceExecutionHostId !== previous.activeWorkspaceExecutionHostId ||
+    state.visibleWorkspaceHostIds !== previous.visibleWorkspaceHostIds ||
+    state.workspaceHostScope !== previous.workspaceHostScope ||
     state.worktreesByRepo !== previous.worktreesByRepo ||
+    state.detectedWorktreesByRepo !== previous.detectedWorktreesByRepo ||
     state.repos !== previous.repos ||
     state.settings !== previous.settings ||
     state.sshConnectionStates !== previous.sshConnectionStates ||
     state.prCache !== previous.prCache ||
-    state.hostedReviewCache !== previous.hostedReviewCache
+    state.hostedReviewCache !== previous.hostedReviewCache ||
+    state.tabsByWorktree !== previous.tabsByWorktree ||
+    state.ptyIdsByTabId !== previous.ptyIdsByTabId ||
+    state.browserTabsByWorktree !== previous.browserTabsByWorktree ||
+    state.unifiedTabsByWorktree !== previous.unifiedTabsByWorktree ||
+    state.agentStatusByPaneKey !== previous.agentStatusByPaneKey ||
+    state.agentStatusEpoch !== previous.agentStatusEpoch
   )
 }
diff --git a/src/renderer/src/store/github/worktree-refresh.ts b/src/renderer/src/store/github/worktree-refresh.ts
index 4168bd50c4ac..8588803741e7 100644
--- a/src/renderer/src/store/github/worktree-refresh.ts
+++ b/src/renderer/src/store/github/worktree-refresh.ts
@@ -20,6 +20,7 @@ export function findWorktreeById(state: AppState, worktreeId: string): Worktree
 }
 
 type WorktreeLookupEntry = {
+  owners: Worktree[]
   first: Worktree
   unique: Worktree | null
 }
@@ -39,9 +40,10 @@ export function buildWorktreeLookupIndex(state: AppState): WorktreeLookupIndex {
       const worktreeId = worktree.id
       const existing = byId.get(worktreeId)
       if (existing) {
+        existing.owners.push(worktree)
         existing.unique = null
       } else {
-        byId.set(worktreeId, { first: worktree, unique: worktree })
+        byId.set(worktreeId, { owners: [worktree], first: worktree, unique: worktree })
       }
     }
   }
diff --git a/src/renderer/src/store/slices/hosted-review-cache-state.ts b/src/renderer/src/store/slices/hosted-review-cache-state.ts
index f7a52802a209..c4be9da838f1 100644
--- a/src/renderer/src/store/slices/hosted-review-cache-state.ts
+++ b/src/renderer/src/store/slices/hosted-review-cache-state.ts
@@ -12,12 +12,15 @@ import type { AppState } from '../types'
 export type HostedReviewCacheEntry<T> = {
   data: T | null
   fetchedAt: number
+  stale?: boolean
   linkedReviewHintKey?: string
   branchLookupGitHubPRNumber?: number
 }
 export type HostedReviewCache = Record<string, HostedReviewCacheEntry<HostedReviewInfo>>
 
 export type HostedReviewFetchOptions = {
+  /** Source-qualified exact lookup; does not replace the branch’s selected review. */
+  exactReviewKey?: string
   force?: boolean
   repoId?: string
   admissionTier?: 'interactive' | 'status' | 'background'
diff --git a/src/renderer/src/store/slices/hosted-review.ts b/src/renderer/src/store/slices/hosted-review.ts
index d5f142736ea3..255b29879ac7 100644
--- a/src/renderer/src/store/slices/hosted-review.ts
+++ b/src/renderer/src/store/slices/hosted-review.ts
@@ -161,15 +161,17 @@ export const createHostedReviewSlice: StateCreator<AppState, [], [], HostedRevie
     }
     const ownerSettings = settingsForHostedReviewRepoOwner(get().settings, repo)
     const target = getActiveRuntimeTarget(ownerSettings)
-    const cacheKey = getHostedReviewCacheKey(
-      repoPath,
-      branch,
-      ownerSettings,
-      options?.repoId ?? repo?.id,
-      repo?.connectionId,
-      repo?.executionHostId,
-      repo !== undefined
-    )
+    const cacheKey =
+      options?.exactReviewKey ??
+      getHostedReviewCacheKey(
+        repoPath,
+        branch,
+        ownerSettings,
+        options?.repoId ?? repo?.id,
+        repo?.connectionId,
+        repo?.executionHostId,
+        repo !== undefined
+      )
     const cached = get().hostedReviewCache[cacheKey]
     const hintKey = linkedReviewHintKey(options)
     const requestKey = hostedReviewRequestKey(cacheKey, hintKey)
@@ -190,8 +192,16 @@ export const createHostedReviewSlice: StateCreator<AppState, [], [], HostedRevie
     const startRequest = (): Promise<HostedReviewInfo | null> => {
       const generation = nextLookupGeneration()
       const requestStartedAt = Date.now()
-      const requestStartedEntry = get().hostedReviewCache[cacheKey]
       requestGenerations.set(cacheKey, generation)
+      if (options?.exactReviewKey && cached) {
+        set((state) => ({
+          hostedReviewCache: {
+            ...state.hostedReviewCache,
+            [cacheKey]: { ...cached, stale: true }
+          }
+        }))
+      }
+      const requestStartedEntry = get().hostedReviewCache[cacheKey]
       const request = (async () => {
         try {
           const args = hostedReviewBranchLookupArgs(branch, options)
@@ -225,15 +235,17 @@ export const createHostedReviewSlice: StateCreator<AppState, [], [], HostedRevie
                 return state
               }
               const currentPRCache = state.prCache ?? {}
-              const prCache = clearHostedReviewConflictingPrCache({
-                cache: currentPRCache,
-                review,
-                repoPath,
-                repoId: options?.repoId ?? repo?.id,
-                branch,
-                settings: ownerSettings,
-                repo
-              })
+              const prCache = options?.exactReviewKey
+                ? currentPRCache
+                : clearHostedReviewConflictingPrCache({
+                    cache: currentPRCache,
+                    review,
+                    repoPath,
+                    repoId: options?.repoId ?? repo?.id,
+                    branch,
+                    settings: ownerSettings,
+                    repo
+                  })
               return {
                 ...(prCache === currentPRCache ? {} : { prCache }),
                 hostedReviewCache: withHostedReviewCacheEntry(state.hostedReviewCache, cacheKey, {
diff --git a/src/renderer/src/store/slices/linear-source-context-cache-scope.test.ts b/src/renderer/src/store/slices/linear-source-context-cache-scope.test.ts
index 08ed1248b196..98123ca4cec5 100644
--- a/src/renderer/src/store/slices/linear-source-context-cache-scope.test.ts
+++ b/src/renderer/src/store/slices/linear-source-context-cache-scope.test.ts
@@ -138,6 +138,60 @@ describe('createLinearSlice caching', () => {
     ).toBeNull()
   })
 
+  it('uses source-selected workspaces for searches, lists, and matching cache reads', async () => {
+    const store = createTestStore()
+    store.setState({
+      linearStatus: { connected: true, viewer: null, selectedWorkspaceId: 'focused-workspace' }
+    })
+    const sourceContext = linearSourceContext('source-runtime', 'source-workspace')
+    const options = { sourceContext, workspaceId: 'source-workspace' }
+    linearSearchIssues.mockResolvedValue([issue('SOURCE-1')])
+    linearListIssues.mockResolvedValue({ items: [issue('SOURCE-2')] })
+    await store.getState().searchLinearIssues('query', 12, options)
+    await store.getState().listLinearIssues({ kind: 'list', limit: 12 }, options)
+    expect(linearSearchIssues).toHaveBeenCalledWith(sourceContext, 'query', 12, 'source-workspace')
+    expect(linearListIssues).toHaveBeenCalledWith(
+      sourceContext,
+      'assigned',
+      12,
+      'source-workspace',
+      undefined
+    )
+    expect(
+      store.getState().getCachedLinearIssues({ kind: 'search', query: 'query', limit: 12 }, options)
+    ).toMatchObject([{ id: 'SOURCE-1' }])
+    expect(
+      store.getState().getCachedLinearIssues({ kind: 'list', limit: 12 }, options)
+    ).toMatchObject({ items: [{ id: 'SOURCE-2' }] })
+    store.getState().prefetchLinearIssues({ kind: 'search', query: 'query', limit: 12 }, options)
+    expect(linearSearchIssues).toHaveBeenCalledTimes(1)
+    expect(
+      store
+        .getState()
+        .getCachedLinearIssues({ kind: 'search', query: 'query', limit: 12 }, { sourceContext })
+    ).toBeNull()
+  })
+
+  it('distinguishes explicit default, all, and inherited focused workspace selections', async () => {
+    const store = createTestStore()
+    store.setState({
+      linearStatus: { connected: true, viewer: null, selectedWorkspaceId: 'focused-workspace' }
+    })
+    const sourceContext = linearSourceContext('source-runtime')
+    linearSearchIssues.mockResolvedValue([])
+    await store.getState().searchLinearIssues('query', 12, { sourceContext, workspaceId: null })
+    await store.getState().searchLinearIssues('query', 12, { sourceContext, workspaceId: 'all' })
+    await store
+      .getState()
+      .searchLinearIssues('query', 12, { sourceContext, workspaceId: undefined })
+    expect(linearSearchIssues.mock.calls.map((args) => args[3])).toEqual([
+      null,
+      'all',
+      'focused-workspace'
+    ])
+    expect(Object.keys(store.getState().linearSearchCache)).toHaveLength(3)
+  })
+
   it('scopes cached Linear teams, projects, and views to the explicit source context', async () => {
     const store = createTestStore()
     store.setState({
@@ -308,4 +362,18 @@ describe('createLinearSlice caching', () => {
         ?.title
     ).toBe('Remote title')
   })
+  it('does not reuse an unscoped issue detail for an explicit source', async () => {
+    const store = createTestStore()
+    const sourceContext = linearSourceContext('source-runtime', 'source-workspace')
+    store.setState({
+      linearIssueCache: {
+        'same-id': { data: { ...issue('same-id'), title: 'Wrong source' }, fetchedAt: Date.now() }
+      }
+    })
+    linearGetIssue.mockResolvedValueOnce({ ...issue('same-id'), title: 'Correct source' })
+    await expect(
+      store.getState().fetchLinearIssue('same-id', 'source-workspace', { sourceContext })
+    ).resolves.toMatchObject({ title: 'Correct source' })
+    expect(linearGetIssue).toHaveBeenCalledWith(sourceContext, 'same-id', 'source-workspace')
+  })
 })
diff --git a/src/renderer/src/store/slices/linear/linear-cache.ts b/src/renderer/src/store/slices/linear/linear-cache.ts
index f77f96f70f23..b9b41036d36e 100644
--- a/src/renderer/src/store/slices/linear/linear-cache.ts
+++ b/src/renderer/src/store/slices/linear/linear-cache.ts
@@ -68,8 +68,12 @@ export function workspaceErrorMessage(error: unknown): string {
 }
 
 export function getSelectedWorkspaceId(
-  status: LinearConnectionStatus
+  status: LinearConnectionStatus,
+  options?: { workspaceId?: LinearWorkspaceSelection | null }
 ): LinearWorkspaceSelection | null {
+  if (options?.workspaceId !== undefined) {
+    return options.workspaceId
+  }
   return status.selectedWorkspaceId ?? status.activeWorkspaceId ?? null
 }
 
diff --git a/src/renderer/src/store/slices/linear/linear-issue-cache-actions.ts b/src/renderer/src/store/slices/linear/linear-issue-cache-actions.ts
index 32c3116aaac3..fa4bf0fa235d 100644
--- a/src/renderer/src/store/slices/linear/linear-issue-cache-actions.ts
+++ b/src/renderer/src/store/slices/linear/linear-issue-cache-actions.ts
@@ -31,7 +31,7 @@ export function createLinearIssueCacheActions(
   return {
     getCachedLinearIssues: (args: LinearIssueReadArgs, options) => {
       const scope = getLinearReadScope(get().settings, options?.sourceContext)
-      const workspaceId = getSelectedWorkspaceId(get().linearStatus)
+      const workspaceId = getSelectedWorkspaceId(get().linearStatus, options)
       if (args.kind === 'search') {
         const cacheKey = scopedLinearCacheKey(
           scope,
@@ -51,7 +51,7 @@ export function createLinearIssueCacheActions(
     prefetchLinearIssues: (args: LinearIssueReadArgs, options?: LinearFetchOptions) => {
       const scope = getLinearReadScope(get().settings, options?.sourceContext)
       const { contextKey } = scope
-      const workspaceId = getSelectedWorkspaceId(get().linearStatus)
+      const workspaceId = getSelectedWorkspaceId(get().linearStatus, options)
       if (args.kind === 'search') {
         const limit = args.limit ?? 20
         const cacheKey = scopedLinearCacheKey(
diff --git a/src/renderer/src/store/slices/linear/linear-issue-detail-actions.ts b/src/renderer/src/store/slices/linear/linear-issue-detail-actions.ts
index 94b4f3fde073..f2826509f459 100644
--- a/src/renderer/src/store/slices/linear/linear-issue-detail-actions.ts
+++ b/src/renderer/src/store/slices/linear/linear-issue-detail-actions.ts
@@ -39,7 +39,9 @@ export function createLinearIssueDetailActions(
       const scope = getLinearReadScope(get().settings, options?.sourceContext)
       const { contextKey } = scope
       const issueCacheKey = scopedLinearCacheKey(scope, `${workspaceId ?? 'selected'}::${id}`)
-      const cached = get().linearIssueCache[issueCacheKey] ?? get().linearIssueCache[id]
+      const cached =
+        get().linearIssueCache[issueCacheKey] ??
+        (scope.explicitSource ? undefined : get().linearIssueCache[id])
       if (isFresh(cached)) {
         return cached.data
       }
diff --git a/src/renderer/src/store/slices/linear/linear-issue-list-actions.ts b/src/renderer/src/store/slices/linear/linear-issue-list-actions.ts
index 20fdd8b70c4f..8c715265ae82 100644
--- a/src/renderer/src/store/slices/linear/linear-issue-list-actions.ts
+++ b/src/renderer/src/store/slices/linear/linear-issue-list-actions.ts
@@ -47,7 +47,7 @@ export function createLinearIssueListActions(
     searchLinearIssues: async (query: string, limit = 20, options?: LinearFetchOptions) => {
       const scope = getLinearReadScope(get().settings, options?.sourceContext)
       const { contextKey } = scope
-      const workspaceId = getSelectedWorkspaceId(get().linearStatus)
+      const workspaceId = getSelectedWorkspaceId(get().linearStatus, options)
       const cacheKey = scopedLinearCacheKey(scope, linearSearchCacheKey(workspaceId, query, limit))
       const cached = get().linearSearchCache[cacheKey]
       if (!options?.force && isFresh(cached)) {
@@ -92,6 +92,7 @@ export function createLinearIssueListActions(
         .catch((error) => {
           console.warn('[linear] searchLinearIssues failed:', error)
           if (
+            !(scope.explicitSource && options?.workspaceId !== undefined) &&
             (isIntegrationCredentialDecryptionError(error) || looksLikeAuthError(error)) &&
             canWriteLinearReadResult(
               contextKey,
@@ -113,6 +114,7 @@ export function createLinearIssueListActions(
             inflightSearchRequests.delete(cacheKey)
           }
           if (
+            !(scope.explicitSource && options?.workspaceId !== undefined) &&
             shouldRefreshStatusAfterRead(workspaceId, get().linearStatus) &&
             canWriteLinearReadResult(
               contextKey,
@@ -140,7 +142,7 @@ export function createLinearIssueListActions(
     listLinearIssues: async (args: LinearIssueListReadArgs, options?: LinearFetchOptions) => {
       const scope = getLinearReadScope(get().settings, options?.sourceContext)
       const { contextKey } = scope
-      const workspaceId = getSelectedWorkspaceId(get().linearStatus)
+      const workspaceId = getSelectedWorkspaceId(get().linearStatus, options)
       const filter = args.filter ?? 'assigned'
       const effectiveLimit = clampLinearIssueListLimit(args.limit)
       const attributeFilter = normalizeListAttributeFilter(args.attributeFilter)
@@ -202,6 +204,7 @@ export function createLinearIssueListActions(
             throw error
           }
           if (
+            !(scope.explicitSource && options?.workspaceId !== undefined) &&
             (isIntegrationCredentialDecryptionError(error) || looksLikeAuthError(error)) &&
             canWriteLinearReadResult(
               contextKey,
@@ -223,6 +226,7 @@ export function createLinearIssueListActions(
             inflightListRequests.delete(cacheKey)
           }
           if (
+            !(scope.explicitSource && options?.workspaceId !== undefined) &&
             shouldRefreshStatusAfterRead(workspaceId, get().linearStatus) &&
             canWriteLinearReadResult(
               contextKey,
diff --git a/src/renderer/src/store/slices/linear/linear-slice-contract.ts b/src/renderer/src/store/slices/linear/linear-slice-contract.ts
index 3c87fdf30902..aff0802c99f5 100644
--- a/src/renderer/src/store/slices/linear/linear-slice-contract.ts
+++ b/src/renderer/src/store/slices/linear/linear-slice-contract.ts
@@ -29,7 +29,11 @@ export type LinearIssueReadArgs =
   | { kind: 'search'; query: string; limit?: number }
   | LinearIssueListReadArgs
 
-export type LinearFetchOptions = { force?: boolean; sourceContext?: TaskSourceContext | null }
+export type LinearFetchOptions = {
+  force?: boolean
+  sourceContext?: TaskSourceContext | null
+  workspaceId?: LinearWorkspaceSelection | null
+}
 export type LinearPatchOptions = { sourceContext?: TaskSourceContext | null }
 
 export type LinearSlice = {
@@ -73,7 +77,7 @@ export type LinearSlice = {
   ) => Promise<LinearIssue | null>
   getCachedLinearIssues: (
     args: LinearIssueReadArgs,
-    options?: Pick<LinearFetchOptions, 'sourceContext'>
+    options?: Pick<LinearFetchOptions, 'sourceContext' | 'workspaceId'>
   ) => LinearIssue[] | LinearCollectionResult<LinearIssue> | null
   prefetchLinearIssues: (args: LinearIssueReadArgs, options?: LinearFetchOptions) => void
   searchLinearIssues: (

From a747c1c013fae3b04ff76e87587ae44bf9ee36ca Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Thu, 8 Oct 2026 01:46:31 -0700
Subject: [PATCH 14/17] Allow another phone send after delivery is unconfirmed
 (#26392)

* Allow another phone send after delivery is unconfirmed

* Update phone image recordings after journal removal
---
 config/reliability-gates.jsonc                | 122 ++---
 ...obile-mirrored-storage-write-path.test.mjs |   1 -
 .../mobile-web-app-session-render.test.mjs    |   5 +-
 ...native-chat-image-upload-second-fails.json |  19 +-
 .../native-chat-image-upload-single.json      |  47 +-
 .../goldens/native-chat-image-upload-two.json |  70 ++-
 .../src/mobile-web-shell/page-storage-keys.ts |   2 +-
 .../platform/native-chat-image-fingerprint.ts |   1 -
 .../native-chat-image-fingerprint.web.test.ts | 113 -----
 .../native-chat-image-fingerprint.web.ts      |  27 --
 .../mobile-native-chat-controller-contract.ts |   1 -
 ...obile-native-chat-image-attachment.test.ts |  89 +---
 .../mobile-native-chat-image-attachment.ts    |  19 +-
 .../mobile-structured-agent-session-rpc.ts    |  10 +-
 ...ructured-agent-session-send-bypass.test.ts | 215 ---------
 .../mobile-structured-agent-session-send.ts   | 218 +--------
 .../mobile-structured-send-delivery.test.ts   | 310 ++++--------
 .../mobile-structured-send-delivery.ts        | 133 +-----
 .../mobile-structured-send-new-action.test.ts |  97 ++++
 ...-structured-send-operation-journal.test.ts | 450 ------------------
 ...obile-structured-send-operation-journal.ts | 281 -----------
 ...ructured-send-page-storage-refusal.test.ts | 143 ------
 .../use-mobile-native-chat-controller.ts      |   1 -
 ...bile-native-chat-image-attachments.test.ts |   3 +-
 .../use-mobile-native-chat-image-upload.ts    |   2 -
 .../use-mobile-native-chat-session-lane.ts    |   3 -
 .../use-mobile-session-image-attachments.ts   |   1 -
 ...ed-agent-session-background-tasks.test.tsx |   3 +-
 ...agent-session-newer-approval-send.test.tsx |   3 +-
 ...tured-agent-session-prompt-cancel.test.tsx |   3 -
 ...e-structured-agent-session-queued.test.tsx | 322 ++-----------
 ...ctured-agent-session-read-failure.test.tsx |   3 +-
 ...ile-structured-agent-session-send.test.tsx | 431 +++++------------
 ...e-mobile-structured-agent-session.test.tsx |   4 +-
 .../use-mobile-structured-agent-session.ts    |   7 -
 ...bile-structured-native-chat-send-bridge.ts |   1 -
 ...tructured-send-operation-reconciliation.ts |  24 -
 ...use-mobile-structured-send-with-outcome.ts |   9 -
 mobile/src/storage/mirrored-storage-keys.ts   |   3 +-
 mobile/tests-typecheck-baseline.txt           |   1 -
 mobile/web-entry/web-overrides.json           |   4 -
 .../structured-agent-session-mutation.ts      |  12 +-
 42 files changed, 490 insertions(+), 2723 deletions(-)
 delete mode 100644 mobile/src/platform/native-chat-image-fingerprint.ts
 delete mode 100644 mobile/src/platform/native-chat-image-fingerprint.web.test.ts
 delete mode 100644 mobile/src/platform/native-chat-image-fingerprint.web.ts
 delete mode 100644 mobile/src/session/mobile-structured-agent-session-send-bypass.test.ts
 create mode 100644 mobile/src/session/mobile-structured-send-new-action.test.ts
 delete mode 100644 mobile/src/session/mobile-structured-send-operation-journal.test.ts
 delete mode 100644 mobile/src/session/mobile-structured-send-operation-journal.ts
 delete mode 100644 mobile/src/session/mobile-structured-send-page-storage-refusal.test.ts
 delete mode 100644 mobile/src/session/use-mobile-structured-send-operation-reconciliation.ts

diff --git a/config/reliability-gates.jsonc b/config/reliability-gates.jsonc
index 3b415f60d580..a01d07a35659 100644
--- a/config/reliability-gates.jsonc
+++ b/config/reliability-gates.jsonc
@@ -325,24 +325,10 @@
         "terminal automation completion",
         "local and relayed cancellation"
       ],
-      "platforms": [
-        "macos",
-        "linux",
-        "windows"
-      ],
-      "providers": [
-        "local",
-        "ssh",
-        "wsl",
-        "remote-runtime"
-      ],
-      "coveredPlatforms": [
-        "macos"
-      ],
-      "coveredProviders": [
-        "local",
-        "remote-runtime"
-      ],
+      "platforms": ["macos", "linux", "windows"],
+      "providers": ["local", "ssh", "wsl", "remote-runtime"],
+      "coveredPlatforms": ["macos"],
+      "coveredProviders": ["local", "remote-runtime"],
       "coverageNotes": "Real HTTP hook ingress and relay forwarding, production runtime automation observer, and captured Claude native ready bytes run locally on macOS. SSH/WSL transport ownership is simulated; physical remote hosts and native Windows/Linux are not verified.",
       "motivatingLinks": [
         "https://github.com/stablyai/orca/pull/24878",
@@ -1456,7 +1442,7 @@
     },
     {
       "id": "agent-session.structured-send-at-most-once",
-      "title": "Ambiguous structured sends never become a second provider delivery",
+      "title": "One structured-send attempt dispatches once; a later Send is a new message",
       "maturity": "experimental",
       "protection": "partial",
       "owner": "agent-session-runtime",
@@ -1466,13 +1452,13 @@
       "providers": ["local", "ssh", "remote-runtime", "mobile"],
       "coveredPlatforms": ["macos"],
       "coveredProviders": ["local", "mobile"],
-      "coverageNotes": "Deterministic host, direct/Relay transport, and mobile hook tests cover durable identity, caller changes, journal loss, acknowledgement loss, expiry, and mobile remount; renderer tests cover the desktop's single request per send, its 30 s bound and the hand-back. The host code is execution-location neutral, but live SSH/remote runtimes and physical iOS/Android lifecycle are not exercised.",
+      "coverageNotes": "Deterministic host and direct/Relay transport tests cover per-operation duplicate protection, caller changes, missing host journal rows, acknowledgement loss, and expiry. Mobile tests cover new-action identity, remount, storage refusal, current attachment paths, and capability changes; renderer tests cover one request per send and the bounded hand-back. Live SSH/remote runtimes and physical iOS/Android lifecycle are not exercised.",
       "motivatingLinks": ["https://github.com/stablyai/orca/pull/20133"],
-      "invariant": "One structured-send operation id causes at most one provider dispatch. On the phone a transport-ambiguous send reuses that id for every resend and caller reconnect, across remount and journal recovery. The desktop never resends: each send makes one request, and an ambiguous or unanswered one, or one still out after 30 s, hands the text back to check; a send unsettled at a reload or crash is not resent. Only a terminal rejection may rotate to a first delivery.",
-      "oracle": "Inject adapter acknowledgement loss, RPC response loss, caller replacement, logical-client close after response, auth recovery with a written request, missing journal submissions, legacy pending rows, stale fences, operation expiry, mobile remount, and durable-journal capacity. Assert one provider dispatch or one operation id for every ambiguous retry, fresh identity only after rejection, and no eviction of ambiguous mobile ids.",
+      "invariant": "One structured-send operation id causes at most one provider dispatch. Each user Send on phone or desktop is a new action with a fresh id and one request; neither automatically resends an ambiguous action. The host retains the original action's outcome, and a later phone Send remains possible with equal text, after remount, or when phone storage fails. Repeated transmission of the same operation remains protected by host deduplication.",
+      "oracle": "Inject adapter/RPC acknowledgement loss, caller replacement, logical-client close after response, auth recovery with a written request, missing host submissions, legacy pending rows, stale fences, expiry, mobile remount, and phone storage refusal. Assert at most one dispatch for repeated transmission of one operation. For a later phone Send, assert a fresh id and second delivery while the original host entry remains unknown; equal images use current uploaded paths and delivery fields follow current host capabilities.",
       "commands": [
         "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-evidence.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/structured-agent-session-message-sender.test.ts src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
-        "ORCA_BACKGROUND_LAUNCH=1 pnpm --dir mobile test ../mobile/src/session/mobile-native-chat-image-attachment.test.ts ../mobile/src/session/use-mobile-native-chat-image-attachments.test.ts ../mobile/src/session/mobile-structured-send-operation-journal.test.ts ../mobile/src/session/mobile-structured-send-delivery.test.ts ../mobile/src/session/use-mobile-structured-agent-session-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session.test.tsx ../mobile/src/transport/mobile-relay-rpc-session.test.ts ../mobile/src/transport/rpc-client-delivery-ambiguity.test.ts ../mobile/src/transport/stable-logical-rpc-client.test.ts"
+        "ORCA_BACKGROUND_LAUNCH=1 pnpm --dir mobile test ../mobile/src/session/mobile-structured-send-new-action.test.ts ../mobile/src/session/use-mobile-structured-agent-session-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx ../mobile/src/session/mobile-structured-send-delivery.test.ts ../mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx ../mobile/src/session/use-mobile-structured-agent-session.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx ../mobile/src/session/mobile-native-chat-image-attachment.test.ts ../mobile/src/session/use-mobile-native-chat-image-attachments.test.ts ../mobile/src/session/use-mobile-structured-native-chat-send-bridge.test.ts ../mobile/src/mobile-web-shell/page-storage-keys.test.ts ../mobile/src/mobile-web-shell/bridge/page-async-storage.test.ts ../mobile/src/mobile-web-shell/use-page-host-snapshot.test.tsx ../mobile/src/mobile-web-shell/bridge-host-init.test.ts ../mobile/src/transport/mobile-relay-rpc-session.test.ts ../mobile/src/transport/rpc-client-delivery-ambiguity.test.ts ../mobile/src/transport/stable-logical-rpc-client.test.ts --maxWorkers=2"
       ],
       "testFiles": [
         "src/shared/agent-session-operation-ledger.test.ts",
@@ -1488,13 +1474,23 @@
         "src/renderer/src/lib/launch-structured-agent-session.test.ts",
         "mobile/src/session/mobile-native-chat-image-attachment.test.ts",
         "mobile/src/session/use-mobile-native-chat-image-attachments.test.ts",
-        "mobile/src/session/mobile-structured-send-operation-journal.test.ts",
+        "mobile/src/session/mobile-structured-send-new-action.test.ts",
         "mobile/src/session/mobile-structured-send-delivery.test.ts",
         "mobile/src/session/use-mobile-structured-agent-session-send.test.tsx",
         "mobile/src/session/use-mobile-structured-agent-session.test.tsx",
         "mobile/src/transport/mobile-relay-rpc-session.test.ts",
         "mobile/src/transport/rpc-client-delivery-ambiguity.test.ts",
-        "mobile/src/transport/stable-logical-rpc-client.test.ts"
+        "mobile/src/transport/stable-logical-rpc-client.test.ts",
+        "mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx",
+        "mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx",
+        "mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx",
+        "mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx",
+        "mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx",
+        "mobile/src/session/use-mobile-structured-native-chat-send-bridge.test.ts",
+        "mobile/src/mobile-web-shell/page-storage-keys.test.ts",
+        "mobile/src/mobile-web-shell/bridge/page-async-storage.test.ts",
+        "mobile/src/mobile-web-shell/use-page-host-snapshot.test.tsx",
+        "mobile/src/mobile-web-shell/bridge-host-init.test.ts"
       ],
       "assertionRefs": [
         {
@@ -1514,12 +1510,11 @@
         {
           "file": "mobile/src/session/use-mobile-structured-agent-session-send.test.tsx",
           "assertions": [
-            "keeps one id across acknowledgement loss and host unknown replays",
-            "reuses an ambiguous id after the session hook remounts",
-            "keeps an ambiguous id after the host replay window expires",
-            "reuses the original uploaded attachment identity after acknowledgement loss",
-            "keeps the send id after a pending-admission refusal",
-            "rotates after a %s pre-handler RPC refusal that proves the send did not run"
+            "a later Send owns a new id even when the earlier host answer was %s",
+            "keeps the original unknown host row while allowing another Send",
+            "does not replay an old action after remount",
+            "uses newly uploaded attachment paths for a new action with the same image",
+            "never reads an old phone journal, even when storage is full or unreadable"
           ]
         },
         {
@@ -1557,22 +1552,22 @@
       ],
       "evidenceRuns": [
         {
-          "date": "2026-10-06",
+          "date": "2026-10-07",
           "runner": "local",
           "platform": "macos",
-          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-evidence.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/structured-agent-session-message-sender.test.ts src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
+          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm --dir mobile test ../mobile/src/session/mobile-structured-send-new-action.test.ts ../mobile/src/session/use-mobile-structured-agent-session-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx ../mobile/src/session/mobile-structured-send-delivery.test.ts ../mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx ../mobile/src/session/use-mobile-structured-agent-session.test.tsx ../mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx ../mobile/src/session/mobile-native-chat-image-attachment.test.ts ../mobile/src/session/use-mobile-native-chat-image-attachments.test.ts ../mobile/src/session/use-mobile-structured-native-chat-send-bridge.test.ts ../mobile/src/mobile-web-shell/page-storage-keys.test.ts ../mobile/src/mobile-web-shell/bridge/page-async-storage.test.ts ../mobile/src/mobile-web-shell/use-page-host-snapshot.test.tsx ../mobile/src/mobile-web-shell/bridge-host-init.test.ts ../mobile/src/transport/mobile-relay-rpc-session.test.ts ../mobile/src/transport/rpc-client-delivery-ambiguity.test.ts ../mobile/src/transport/stable-logical-rpc-client.test.ts --maxWorkers=2",
           "result": "passed",
-          "durationSeconds": 14,
-          "summary": "Eleven focused host, shared, renderer, and orchestration files passed 173 tests after the desktop outbox gave way to the in-memory sender, which makes one request per send and never resends."
+          "durationSeconds": 5.42,
+          "summary": "Nineteen focused mobile files passed 241 tests for fresh Send identity, remount, attachment paths, storage refusal, mixed host capabilities, queued cards, and written-request ambiguity."
         },
         {
-          "date": "2026-09-12",
+          "date": "2026-10-06",
           "runner": "local",
           "platform": "macos",
-          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm --dir mobile test ../mobile/src/session/mobile-native-chat-image-attachment.test.ts ../mobile/src/session/use-mobile-native-chat-image-attachments.test.ts ../mobile/src/session/mobile-structured-send-operation-journal.test.ts ../mobile/src/session/mobile-structured-send-delivery.test.ts ../mobile/src/session/use-mobile-structured-agent-session-send.test.tsx ../mobile/src/session/use-mobile-structured-agent-session.test.tsx ../mobile/src/transport/mobile-relay-rpc-session.test.ts ../mobile/src/transport/rpc-client-delivery-ambiguity.test.ts ../mobile/src/transport/stable-logical-rpc-client.test.ts",
+          "command": "ORCA_BACKGROUND_LAUNCH=1 pnpm test src/shared/agent-session-operation-ledger.test.ts src/shared/structured-agent-session-send-evidence.test.ts src/main/runtime/agent-session-operation-admission.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts src/main/native-chat/agent-session-wire/structured-agent-session-send.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-delivery.test.ts src/main/runtime/orchestration/structured-mailbox-pointer-host.test.ts src/main/runtime/orchestration/structured-pointer-operation-id.test.ts src/renderer/src/components/native-chat/structured-agent-session-message-sender.test.ts src/renderer/src/components/native-chat/use-structured-agent-session.test.tsx src/renderer/src/lib/launch-structured-agent-session.test.ts",
           "result": "passed",
-          "durationSeconds": 2.37,
-          "summary": "Ten focused mobile session, attachment, and transport files passed 113 tests."
+          "durationSeconds": 14,
+          "summary": "Eleven focused host, shared, renderer, and orchestration files passed 173 tests after the desktop outbox gave way to the in-memory sender, which makes one request per send and never resends."
         }
       ],
       "runtimeBudget": {
@@ -1585,27 +1580,24 @@
       },
       "redGreenEvidence": {
         "status": "partial",
-        "evidence": "Four targeted failures were observed: spending the mobile id after acknowledgement loss made three retries use two ids; settling cross-caller recovery under the new caller left the original ledger row pending; returning no synthetic result for a legacy or crash-left pending row dispatched it as a new accepted send; and a8d3de8d20's blanket settlement rotated a stale-fence option id and failed the renderer invariant. The focused tests pass with the production fixes restored; a byte-identical old-production run is not recorded."
+        "evidence": "The exact phone acknowledgement-loss/later-equal-Send test fails twice with the original sender and classifier restored byte-for-byte: the second Send returns unknown under the earlier id. It passes with per-action identity. Existing host tests also pin cross-caller recovery, missing submissions, and legacy pending rows against repeat dispatch; those host paths were not changed."
       },
       "performanceBudget": {
         "required": true,
-        "evidence": "No polling, timers, subprocesses, or provider fanout were added. Each mobile journal mutation parses the bounded journal and performs at most one full AsyncStorage rewrite; entries retain hashes, ids, and original attachment paths, cap at 4,096, and fail closed at capacity. A first host send performs three serialized whole-store durable transactions: admission, the pre-effect unknown tombstone, and final settlement. Lease and fence admission now share one transaction with the operation row, so a transient pre-effect refusal leaves no row and, absent pruning, performs no store write. No capacity-scale host fsync or mobile AsyncStorage latency benchmark is recorded."
+        "evidence": "No polling, timers, subprocesses, or provider fanout were added. The phone send path no longer reads or writes AsyncStorage or hashes image contents. The existing host admission, pre-effect unknown record, and settlement transactions are unchanged. No capacity-scale host fsync benchmark is recorded."
       },
       "promotionCriteria": [
         "Soak both commands in CI with zero unexplained flakes.",
         "Add live physical-mobile and remote-runtime interruption evidence before claiming full provider coverage."
       ],
       "knownGaps": [
-        "A payload-keyed mobile ambiguity cannot distinguish retrying the original send from an intentional later send with identical content. It fails closed until authoritative settlement, so the claim that retention costs no liveness is false without a durable composer-action identity.",
-        "Clearing or externally corrupting desktop localStorage or mobile AsyncStorage can erase a client-owned ambiguous identity.",
-        "An ambiguous id retained past host tombstone expiry remains safely blocked rather than becoming live again.",
-        "A host crash after premarking the operation unknown but before journal append or provider dispatch can conservatively suppress a message that never reached the provider.",
-        "A replay synthesized from an operation row whose journal submission is missing is not republished into the journal; desktop stops automatic polling but remains safely blocked on that FIFO head.",
-        "The changed send guarantee is not capability-negotiated. New mobile clients fail closed across caller-identity change, but old clients can rotate an ambiguous id against a new host, and an old mobile client can interpret an ok response carrying unknown as accepted.",
-        "An ambiguous attachment retry depends on the original host temp path remaining usable when the first request never reached the host; if it is gone, the retry rejects rather than rotating.",
+        "Phone composer drafts remain in memory: killing the app between Send and host recording loses that text, as before.",
+        "A later intentional Send can deliver another copy of text from an earlier unknown action; the original action stays unresolved until the host can establish its outcome.",
+        "A host crash after recording the operation unknown but before journal append or provider dispatch can conservatively suppress an attempt that never reached the provider.",
+        "Older phone bundles retain their payload journal behavior until upgraded; legacy embedded-page storage access remains permitted.",
         "No live SSH, remote-runtime, physical iOS/Android, Linux, or Windows interruption run is recorded."
       ],
-      "demotionRule": "Keep experimental or demote if any ambiguous retry changes operation id, provider dispatch count exceeds one, durable identity is evicted by age or capacity, or the focused commands flake without a diagnosed harness defect."
+      "demotionRule": "Keep experimental or demote if one operation dispatches twice, uncertainty is reported as definite rejection, a later phone Send reuses the earlier action or is blocked by phone storage, or the focused commands flake without a diagnosed harness defect."
     },
     {
       "id": "agent-session.completed-turn-duration",
@@ -3788,9 +3780,7 @@
         },
         {
           "file": "src/main/system-resume-broadcast.test.ts",
-          "assertions": [
-            "publishes suspend and resume to main-process lifecycle consumers"
-          ]
+          "assertions": ["publishes suspend and resume to main-process lifecycle consumers"]
         },
         {
           "file": "src/main/system-power-lifecycle.test.ts",
@@ -5067,9 +5057,7 @@
         },
         {
           "file": "src/cli/runtime/serve-signal-exit-diagnostic.test.ts",
-          "assertions": [
-            "late update handoff failure cannot rearm termination after child exit"
-          ]
+          "assertions": ["late update handoff failure cannot rearm termination after child exit"]
         },
         {
           "file": "src/main/serve-update-handoff.test.ts",
@@ -5485,9 +5473,7 @@
       "coveredPlatforms": ["macos"],
       "coveredProviders": ["remote-runtime"],
       "coverageNotes": "Deterministic main-IPC contract tests cover disconnect-driven close delivery, exactly-once close, per-subscription teardown isolation against a failing socket close and a throwing liveness probe, containment of a throwing renderer send on the unguarded host-close path, and continued suppression of stale payloads from a retired transport. A headed paired-server journey (real Orca host plus a separate paired Orca desktop client) covers hidden-but-mounted reveal, cold-parked reveal, and cold-parked reveal across a disconnect/reconnect. Live Linux and Windows paired-server evidence and real sleep/wake transport loss remain uncollected.",
-      "motivatingLinks": [
-        "tests/e2e/paired-remote-terminal-parked-reveal-interactivity.spec.ts"
-      ],
+      "motivatingLinks": ["tests/e2e/paired-remote-terminal-parked-reveal-interactivity.spec.ts"],
       "invariant": "Every renderer-held runtime subscription receives exactly one terminal close event when its transport is retired, including when the retirement advanced the transport generation first, and a single failing teardown never abandons that environment's remaining subscriptions nor escapes into the transport that reported the close. Payload frames from a retired transport stay suppressed. A revealed remote terminal therefore reattaches over a live multiplex connection: its buffer restores, typed input reaches the host PTY, the echo paints without a tab flip, and the PTY converges on the revealed pane grid.",
       "oracle": "The main IPC contract test subscribes terminal.multiplex through the real handler, disconnects the environment, and asserts the renderer received exactly one {type: close} subscription event. Two isolation tests subscribe a second stream to the same environment and make the first one fail -- in its socket close, and in the liveness probe inside notifyClosed -- then assert the disconnect does not throw, both transports closed, and every close the renderer could still receive was delivered. A third drives a host-initiated close through the transport callback, which is the one notifyClosed call site with no surrounding guard, with a renderer send that throws, and asserts it cannot escape into the WebSocket close handler. A fourth test asserts that after retirement a late response frame is not forwarded and a late transport close does not re-send. The paired-server journey runs three reveal scenarios against one real host and one real paired desktop client, and for each records buffer restore, host-side receipt of the typed marker through an out-of-band host sink file, live paint without a tab flip, and PTY-versus-pane grid convergence.",
       "commands": [
@@ -12625,9 +12611,7 @@
         },
         {
           "file": "src/main/ipc/pty-startup-barrier-and-listing.test.ts",
-          "assertions": [
-            "global inventory starts local and SSH provider listings concurrently"
-          ]
+          "assertions": ["global inventory starts local and SSH provider listings concurrently"]
         },
         {
           "file": "src/renderer/src/components/status-bar/resource-session-inventory.test.ts",
@@ -21094,9 +21078,7 @@
         },
         {
           "file": "src/main/browser/agent-browser-bridge-tab-routing.test.ts",
-          "assertions": [
-            "closing a tab retires the exact named agent-browser session"
-          ]
+          "assertions": ["closing a tab retires the exact named agent-browser session"]
         },
         {
           "file": "src/main/startup/serve-signal-handlers.test.ts",
@@ -21535,9 +21517,7 @@
         },
         {
           "file": "config/scripts/verify-packaged-browser-participation.test.mjs",
-          "assertions": [
-            "reject missing, substituted, skipped and retried scenarios"
-          ]
+          "assertions": ["reject missing, substituted, skipped and retried scenarios"]
         }
       ],
       "evidenceRuns": [
@@ -21599,15 +21579,11 @@
         "gh run view 34074017928 --log",
         "pnpm exec playwright test --config tests/playwright.config.ts tests/e2e/terminal-hangul-terminating-digit-native.spec.ts --project=electron-headful --workers=1 --repeat-each=3 --retries=0 --reporter=list,json"
       ],
-      "testFiles": [
-        "tests/e2e/terminal-hangul-terminating-digit-native.spec.ts"
-      ],
+      "testFiles": ["tests/e2e/terminal-hangul-terminating-digit-native.spec.ts"],
       "assertionRefs": [
         {
           "file": "tests/e2e/terminal-hangul-terminating-digit-native.spec.ts",
-          "assertions": [
-            "a digit typed right after a Hangul syllable reaches the pty"
-          ]
+          "assertions": ["a digit typed right after a Hangul syllable reaches the pty"]
         }
       ],
       "evidenceRuns": [
diff --git a/config/scripts/mobile-mirrored-storage-write-path.test.mjs b/config/scripts/mobile-mirrored-storage-write-path.test.mjs
index d626677cbec9..b67c82ceea77 100644
--- a/config/scripts/mobile-mirrored-storage-write-path.test.mjs
+++ b/config/scripts/mobile-mirrored-storage-write-path.test.mjs
@@ -31,7 +31,6 @@ const MIRRORED_WRITERS = [
     keys: ['TERMINAL_ACCESSORY_LAYOUT_STORAGE_KEY']
   },
   { file: 'src/components/CustomKeyModal.tsx', keys: ['CUSTOM_ACCESSORY_KEYS_STORAGE_KEY'] },
-  { file: 'src/session/mobile-structured-send-operation-journal.ts', keys: ['STORAGE_KEY'] },
   {
     file: 'src/worktree/last-visited-worktree-repo.ts',
     keys: ['LAST_VISITED_WORKTREE_STORAGE_KEY']
diff --git a/config/scripts/mobile-web-app-session-render.test.mjs b/config/scripts/mobile-web-app-session-render.test.mjs
index 9bf1560141f4..a18ccf93c031 100644
--- a/config/scripts/mobile-web-app-session-render.test.mjs
+++ b/config/scripts/mobile-web-app-session-render.test.mjs
@@ -374,7 +374,6 @@ describeRender(
  * `mobile-web-app-screencast-lane-grant.test.mjs` derives from this closure.
  *
  * **The storage refusals a control makes.** The case above covers the writes a mount makes on its
- * own; a refusal a user's own write earns still needs the control. That chain is
- * `mobile/src/session/mobile-structured-send-page-storage-refusal.test.ts` end to end over the
- * real `page-async-storage`.
+ * own; store-level write refusals are covered by
+ * `mobile/src/mobile-web-shell/bridge/page-async-storage.test.ts`.
  */
diff --git a/mobile/rpc-foundation/goldens/native-chat-image-upload-second-fails.json b/mobile/rpc-foundation/goldens/native-chat-image-upload-second-fails.json
index f09b32c7e780..d0260d6b1091 100644
--- a/mobile/rpc-foundation/goldens/native-chat-image-upload-second-fails.json
+++ b/mobile/rpc-foundation/goldens/native-chat-image-upload-second-fails.json
@@ -4,15 +4,6 @@
   "family": "nativeChat.image-upload",
   "namedDeltas": [],
   "values": {
-    "2ec71b490683": {
-      "name": "image-uploaded",
-      "ordinal": 8,
-      "value": {
-        "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-        "path": "/tmp/img-1.png",
-        "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
-      }
-    },
     "2fd17c25e4d0": {
       "name": "clipboard.startImageUpload#2",
       "ordinal": 9,
@@ -49,6 +40,14 @@
         }
       }
     },
+    "31f4965e4ed4": {
+      "name": "image-uploaded",
+      "ordinal": 8,
+      "value": {
+        "path": "/tmp/img-1.png",
+        "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+      }
+    },
     "6696a47819e1": {
       "name": "clipboard.startImageUpload#1",
       "ordinal": 3,
@@ -204,7 +203,7 @@
             "two": "765ab192e1a5"
           },
           "state": "b2b1a4389f58",
-          "effects": ["994fccf9b305", "2ec71b490683"]
+          "effects": ["994fccf9b305", "31f4965e4ed4"]
         }
       }
     ]
diff --git a/mobile/rpc-foundation/goldens/native-chat-image-upload-single.json b/mobile/rpc-foundation/goldens/native-chat-image-upload-single.json
index 32c13ce5d338..dd67c8a4a19f 100644
--- a/mobile/rpc-foundation/goldens/native-chat-image-upload-single.json
+++ b/mobile/rpc-foundation/goldens/native-chat-image-upload-single.json
@@ -4,13 +4,23 @@
   "family": "nativeChat.image-upload",
   "namedDeltas": [],
   "values": {
-    "5c7ed03288e6": {
+    "0d87f193fb59": {
+      "status": "fulfilled",
+      "startedAt": 0,
+      "settledAt": 0,
+      "value": [
+        {
+          "path": "/tmp/img-1.png",
+          "previewUri": "file:///a.png"
+        }
+      ]
+    },
+    "15d714ff61ff": {
       "failure": {
         "$rpc": "null"
       },
       "uploaded": [
         {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
           "path": "/tmp/img-1.png",
           "previewUri": "file:///a.png"
         }
@@ -71,17 +81,13 @@
       "ordinal": 1,
       "value": {}
     },
-    "9a61808dee44": {
-      "status": "fulfilled",
-      "startedAt": 0,
-      "settledAt": 0,
-      "value": [
-        {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-          "path": "/tmp/img-1.png",
-          "previewUri": "file:///a.png"
-        }
-      ]
+    "dd123d00d140": {
+      "name": "image-uploaded",
+      "ordinal": 8,
+      "value": {
+        "path": "/tmp/img-1.png",
+        "previewUri": "file:///a.png"
+      }
     },
     "ec8f73d25f26": {
       "name": "clipboard.commitImageUpload#1",
@@ -150,15 +156,6 @@
           }
         }
       }
-    },
-    "f4c66fc96af9": {
-      "name": "image-uploaded",
-      "ordinal": 8,
-      "value": {
-        "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-        "path": "/tmp/img-1.png",
-        "previewUri": "file:///a.png"
-      }
     }
   },
   "recording": {
@@ -170,10 +167,10 @@
           "sender": ["7c2e3ea286aa", "f05e4695ffa3", "ec8f73d25f26"],
           "payloads": ["6696a47819e1", "814ccd56a769", "8452698ac11a"],
           "settlements": {
-            "normal": "9a61808dee44"
+            "normal": "0d87f193fb59"
           },
-          "state": "5c7ed03288e6",
-          "effects": ["994fccf9b305", "f4c66fc96af9"]
+          "state": "15d714ff61ff",
+          "effects": ["994fccf9b305", "dd123d00d140"]
         }
       }
     ]
diff --git a/mobile/rpc-foundation/goldens/native-chat-image-upload-two.json b/mobile/rpc-foundation/goldens/native-chat-image-upload-two.json
index 8d7643ed0e11..3581f44ea229 100644
--- a/mobile/rpc-foundation/goldens/native-chat-image-upload-two.json
+++ b/mobile/rpc-foundation/goldens/native-chat-image-upload-two.json
@@ -4,41 +4,14 @@
   "family": "nativeChat.image-upload",
   "namedDeltas": [],
   "values": {
-    "147a6d6af2f1": {
-      "name": "image-uploaded",
-      "ordinal": 15,
-      "value": {
-        "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-        "path": "/tmp/img-2.png",
-        "previewUri": "file:///b.png"
-      }
-    },
-    "2ec71b490683": {
+    "31f4965e4ed4": {
       "name": "image-uploaded",
       "ordinal": 8,
       "value": {
-        "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
         "path": "/tmp/img-1.png",
         "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
       }
     },
-    "4a3413975ca6": {
-      "status": "fulfilled",
-      "startedAt": 0,
-      "settledAt": 0,
-      "value": [
-        {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-          "path": "/tmp/img-1.png",
-          "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
-        },
-        {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
-          "path": "/tmp/img-2.png",
-          "previewUri": "file:///b.png"
-        }
-      ]
-    },
     "5c19acb9611e": {
       "name": "clipboard.commitImageUpload#2",
       "ordinal": 13,
@@ -121,18 +94,16 @@
       "ordinal": 7,
       "json": "{\"id\":\"frame-3\",\"deviceToken\":\"recording-device\",\"method\":\"clipboard.commitImageUpload\",\"params\":{\"uploadId\":\"upload-1\"}}"
     },
-    "8d51e9899739": {
-      "failure": {
-        "$rpc": "null"
-      },
-      "uploaded": [
+    "87c17cf78a60": {
+      "status": "fulfilled",
+      "startedAt": 0,
+      "settledAt": 0,
+      "value": [
         {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
           "path": "/tmp/img-1.png",
           "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         },
         {
-          "contentFingerprint": "f75f583c67e2aaf12284c94d09b56e3caa9d7b93b71565d2fd3e09ef635cef8d",
           "path": "/tmp/img-2.png",
           "previewUri": "file:///b.png"
         }
@@ -224,6 +195,14 @@
         }
       }
     },
+    "d7dc1460b465": {
+      "name": "image-uploaded",
+      "ordinal": 15,
+      "value": {
+        "path": "/tmp/img-2.png",
+        "previewUri": "file:///b.png"
+      }
+    },
     "e74ddb684ed1": {
       "name": "clipboard.startImageUpload#2",
       "ordinal": 10,
@@ -296,6 +275,21 @@
           }
         }
       }
+    },
+    "f6cdfabc3790": {
+      "failure": {
+        "$rpc": "null"
+      },
+      "uploaded": [
+        {
+          "path": "/tmp/img-1.png",
+          "previewUri": "data:image/png;base64,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+        },
+        {
+          "path": "/tmp/img-2.png",
+          "previewUri": "file:///b.png"
+        }
+      ]
     }
   },
   "recording": {
@@ -321,10 +315,10 @@
             "a77c2409e01f"
           ],
           "settlements": {
-            "two": "4a3413975ca6"
+            "two": "87c17cf78a60"
           },
-          "state": "8d51e9899739",
-          "effects": ["994fccf9b305", "2ec71b490683", "147a6d6af2f1"]
+          "state": "f6cdfabc3790",
+          "effects": ["994fccf9b305", "31f4965e4ed4", "d7dc1460b465"]
         }
       }
     ]
diff --git a/mobile/src/mobile-web-shell/page-storage-keys.ts b/mobile/src/mobile-web-shell/page-storage-keys.ts
index fc77cfe27e4d..42c5dce890cb 100644
--- a/mobile/src/mobile-web-shell/page-storage-keys.ts
+++ b/mobile/src/mobile-web-shell/page-storage-keys.ts
@@ -29,7 +29,7 @@ export const PAGE_STORAGE_EXACT_KEYS = [
   'orca:custom-accessory-keys',
   /** Whether a supported agent session opens on the terminal or the native chat. */
   'orca:defaultSessionView',
-  /** The durable send journal: which `agentSession.send` operation ids are still unsettled. */
+  /** Legacy journal access for embedded pages served by older hosts. */
   'orca:mobileStructuredSendOperations:v1',
   /** The terminal's text scale, which pinch-to-zoom writes. */
   'orca:terminalTextScale',
diff --git a/mobile/src/platform/native-chat-image-fingerprint.ts b/mobile/src/platform/native-chat-image-fingerprint.ts
deleted file mode 100644
index 84ed6acc0491..000000000000
--- a/mobile/src/platform/native-chat-image-fingerprint.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { mobileNativeChatImageContentFingerprint as fingerprintNativeChatImage } from '../session/mobile-native-chat-image-attachment'
diff --git a/mobile/src/platform/native-chat-image-fingerprint.web.test.ts b/mobile/src/platform/native-chat-image-fingerprint.web.test.ts
deleted file mode 100644
index 9d120495173d..000000000000
--- a/mobile/src/platform/native-chat-image-fingerprint.web.test.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { createHash, webcrypto } from 'node:crypto'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import {
-  serializeStructuredAgentSessionFingerprintPayload,
-  structuredAgentSessionPayloadFingerprint
-} from '../../../src/shared/structured-agent-session-mutation'
-import * as portableHash from '../../../src/shared/sha256'
-import { mobileNativeChatImageContentFingerprint } from '../session/mobile-native-chat-image-attachment'
-import { fingerprintNativeChatImage as fingerprintNativeImage } from './native-chat-image-fingerprint'
-import { fingerprintNativeChatImage } from './native-chat-image-fingerprint.web'
-
-afterEach(() => {
-  vi.restoreAllMocks()
-  vi.unstubAllGlobals()
-})
-
-describe('native chat image fingerprints', () => {
-  it('preserves the existing fixed image fingerprint domain', async () => {
-    const expected = createHash('sha256')
-      .update('{"fields":{"base64":"AQID"},"method":"mobile.nativeChat.image","sessionId":""}')
-      .digest('hex')
-    vi.stubGlobal('crypto', webcrypto)
-
-    expect(mobileNativeChatImageContentFingerprint('AQID')).toBe(expected)
-    expect(await fingerprintNativeChatImage('AQID')).toBe(expected)
-  })
-
-  it('keeps the selected canonical envelope, nested ordering, undefined and Unicode', () => {
-    const input = {
-      method: 'm',
-      sessionId: 's',
-      fields: {
-        z: undefined,
-        nested: { z: null, a: '\ud800' },
-        array: [undefined, '😀'],
-        '2': 'two',
-        '10': 'ten'
-      },
-      ignoredExtra: 'outside the envelope'
-    }
-    const canonical =
-      '{"fields":{"10":"ten","2":"two","array":[null,"😀"],"nested":{"a":"\\ud800","z":null}},"method":"m","sessionId":"s"}'
-
-    expect(serializeStructuredAgentSessionFingerprintPayload(input)).toBe(canonical)
-    expect(
-      serializeStructuredAgentSessionFingerprintPayload({
-        ...input,
-        fields: {
-          '10': 'ten',
-          '2': 'two',
-          array: [undefined, '😀'],
-          nested: { a: '\ud800', z: null }
-        }
-      })
-    ).toBe(canonical)
-    expect(structuredAgentSessionPayloadFingerprint(input)).toBe(
-      createHash('sha256').update(canonical).digest('hex')
-    )
-  })
-
-  it.each(['', 'AAAA', 'data:image/png;base64,AAAA', '\ud800', '日本語😀', 'AQID'.repeat(4096)])(
-    'keeps the existing fingerprint for %j',
-    async (base64) => {
-      vi.stubGlobal('crypto', webcrypto)
-      expect(await fingerprintNativeChatImage(base64)).toBe(
-        mobileNativeChatImageContentFingerprint(base64)
-      )
-    }
-  )
-
-  it('uses browser crypto without running the portable hash or encoding twice', async () => {
-    const base64 = 'AQID'.repeat(256 * 1024)
-    const expected = mobileNativeChatImageContentFingerprint(base64)
-    vi.stubGlobal('crypto', webcrypto)
-    const nativeDigest = vi.spyOn(webcrypto.subtle, 'digest')
-    const fallbackHash = vi.spyOn(portableHash, 'sha256')
-    const encode = vi.spyOn(TextEncoder.prototype, 'encode')
-
-    expect(await fingerprintNativeChatImage(base64)).toBe(expected)
-    expect(nativeDigest).toHaveBeenCalledExactlyOnceWith('SHA-256', expect.any(Uint8Array))
-    expect(fallbackHash).not.toHaveBeenCalled()
-    expect(encode).toHaveBeenCalledTimes(1)
-  })
-
-  it.each(['missing', 'insecure', 'rejected', 'throwing'])(
-    'keeps a successful upload fingerprint when browser crypto is %s',
-    async (mode) => {
-      const base64 = 'data:image/png;base64,AQID'
-      const expected = mobileNativeChatImageContentFingerprint(base64)
-      const digest = vi.fn(() => {
-        if (mode === 'throwing') {
-          throw new Error('crypto unavailable')
-        }
-        return Promise.reject(new Error('crypto unavailable'))
-      })
-      vi.stubGlobal(
-        'crypto',
-        mode === 'missing' ? undefined : { subtle: mode === 'insecure' ? undefined : { digest } }
-      )
-      const fallbackHash = vi.spyOn(portableHash, 'sha256')
-      const encode = vi.spyOn(TextEncoder.prototype, 'encode')
-
-      expect(await fingerprintNativeChatImage(base64)).toBe(expected)
-      expect(fallbackHash).toHaveBeenCalledTimes(1)
-      expect(encode).toHaveBeenCalledTimes(1)
-    }
-  )
-
-  it('keeps the native platform function synchronous and identical', () => {
-    expect(fingerprintNativeImage).toBe(mobileNativeChatImageContentFingerprint)
-    expect(fingerprintNativeImage('AAAA')).toBe(mobileNativeChatImageContentFingerprint('AAAA'))
-  })
-})
diff --git a/mobile/src/platform/native-chat-image-fingerprint.web.ts b/mobile/src/platform/native-chat-image-fingerprint.web.ts
deleted file mode 100644
index 7c6b5d6f99d5..000000000000
--- a/mobile/src/platform/native-chat-image-fingerprint.web.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { serializeStructuredAgentSessionFingerprintPayload } from '../../../src/shared/structured-agent-session-mutation'
-import { sha256 } from '../../../src/shared/sha256'
-import { MOBILE_NATIVE_CHAT_IMAGE_FINGERPRINT_DOMAIN } from '../session/mobile-native-chat-image-attachment'
-
-function fingerprintHex(bytes: Uint8Array): string {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
-}
-
-export async function fingerprintNativeChatImage(base64: string): Promise<string> {
-  const bytes = new TextEncoder().encode(
-    serializeStructuredAgentSessionFingerprintPayload({
-      method: MOBILE_NATIVE_CHAT_IMAGE_FINGERPRINT_DOMAIN,
-      sessionId: '',
-      fields: { base64 }
-    })
-  )
-  const subtle = globalThis.crypto?.subtle
-  if (!subtle) {
-    return fingerprintHex(sha256(bytes))
-  }
-  try {
-    return fingerprintHex(new Uint8Array(await subtle.digest('SHA-256', bytes)))
-  } catch {
-    // A crypto backend failure must not discard an image the host already saved.
-    return fingerprintHex(sha256(bytes))
-  }
-}
diff --git a/mobile/src/session/mobile-native-chat-controller-contract.ts b/mobile/src/session/mobile-native-chat-controller-contract.ts
index 3a330fd28187..74980499eb9c 100644
--- a/mobile/src/session/mobile-native-chat-controller-contract.ts
+++ b/mobile/src/session/mobile-native-chat-controller-contract.ts
@@ -99,7 +99,6 @@ export type MobileNativeChatController = {
       id?: string
       path: string
       previewUri: string
-      contentFingerprint?: string
     }[]
   ) => Promise<MobileNativeChatSendOutcome>
   /** Launch-context text still parked on the agent's TUI input line, or null.
diff --git a/mobile/src/session/mobile-native-chat-image-attachment.test.ts b/mobile/src/session/mobile-native-chat-image-attachment.test.ts
index deb311525144..f6565c322894 100644
--- a/mobile/src/session/mobile-native-chat-image-attachment.test.ts
+++ b/mobile/src/session/mobile-native-chat-image-attachment.test.ts
@@ -38,77 +38,6 @@ function clientWithResponses(responses: RpcResponse[]): Pick<RpcClient, 'sendReq
 }
 
 describe('uploadMobileNativeChatImages', () => {
-  it('waits for each fingerprint before its callback and the next image', async () => {
-    const events: string[] = []
-    let completeFingerprint: (fingerprint: string) => void = () => {
-      throw new Error('fingerprint did not start')
-    }
-    let fingerprintStarted: () => void = () => {}
-    const started = new Promise<void>((resolve) => {
-      fingerprintStarted = resolve
-    })
-    const client = clientWithResponses([
-      methodNotFound('start-a'),
-      ok('save-a', '/tmp/a.png'),
-      methodNotFound('start-b'),
-      failed('save-b', 'second upload failed')
-    ])
-    const pending = uploadMobileNativeChatImages('library', {
-      client,
-      getConnectionId: async () => 'original-connection',
-      pickImages: async function* () {
-        events.push('read:first')
-        yield { base64: 'AAAA' }
-        events.push('read:second')
-        yield { base64: 'AQID' }
-      },
-      fingerprintImage: () => {
-        events.push('fingerprint')
-        fingerprintStarted()
-        return new Promise<string>((resolve) => {
-          completeFingerprint = resolve
-        })
-      },
-      onImageUploaded: (image) => events.push(`uploaded:${image.contentFingerprint}`)
-    })
-    const rejection = expect(pending).rejects.toThrow('second upload failed')
-    await started
-    expect(events).toEqual(['read:first', 'fingerprint'])
-    expect(client.calls).toHaveLength(2)
-
-    completeFingerprint('first-fingerprint')
-    await rejection
-    expect(events).toEqual([
-      'read:first',
-      'fingerprint',
-      'uploaded:first-fingerprint',
-      'read:second'
-    ])
-    expect(client.calls.map((call) => call.params)).toEqual([
-      { expectedBase64Length: 4, connectionId: 'original-connection' },
-      { contentBase64: 'AAAA', connectionId: 'original-connection' },
-      { expectedBase64Length: 4, connectionId: 'original-connection' },
-      { contentBase64: 'AQID', connectionId: 'original-connection' }
-    ])
-  })
-
-  it('does not add an await between a synchronous fingerprint and its callback', async () => {
-    const events: string[] = []
-    const client = clientWithResponses([methodNotFound('start'), ok('save', '/tmp/a.png')])
-    await uploadMobileNativeChatImages('library', {
-      client,
-      getConnectionId: async () => null,
-      pickImages: () => [{ base64: 'AAAA' }],
-      fingerprintImage: () => {
-        events.push('fingerprint')
-        queueMicrotask(() => events.push('microtask'))
-        return 'synchronous-fingerprint'
-      },
-      onImageUploaded: () => events.push('callback')
-    })
-    expect(events).toEqual(['fingerprint', 'callback', 'microtask'])
-  })
-
   it('uploads the picked image and returns its host path + local preview uri, without any terminal.send', async () => {
     const client = clientWithResponses([
       methodNotFound('start'),
@@ -124,8 +53,7 @@ describe('uploadMobileNativeChatImages', () => {
     expect(result).toEqual([
       {
         path: '/tmp/orca-attach.png',
-        previewUri: 'file:///photo.jpg',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'file:///photo.jpg'
       }
     ])
     // Native chat defers the paste to submit — nothing is sent to the terminal here.
@@ -165,18 +93,15 @@ describe('uploadMobileNativeChatImages', () => {
     expect(result).toEqual([
       {
         path: '/tmp/a.png',
-        previewUri: 'file:///a.jpg',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'file:///a.jpg'
       },
       {
         path: '/tmp/b.png',
-        previewUri: 'file:///b.jpg',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'file:///b.jpg'
       },
       {
         path: '/tmp/c.png',
-        previewUri: 'file:///c.jpg',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'file:///c.jpg'
       }
     ])
     expect(order).toEqual([
@@ -225,8 +150,7 @@ describe('uploadMobileNativeChatImages', () => {
     expect(onImageUploaded).toHaveBeenCalledOnce()
     expect(onImageUploaded).toHaveBeenCalledWith({
       path: '/tmp/a.png',
-      previewUri: 'file:///a.jpg',
-      contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+      previewUri: 'file:///a.jpg'
     })
   })
 
@@ -242,8 +166,7 @@ describe('uploadMobileNativeChatImages', () => {
     expect(result).toEqual([
       {
         path: '/tmp/x.png',
-        previewUri: 'data:image/png;base64,BBBB',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'data:image/png;base64,BBBB'
       }
     ])
   })
diff --git a/mobile/src/session/mobile-native-chat-image-attachment.ts b/mobile/src/session/mobile-native-chat-image-attachment.ts
index 1949ab7f50c0..3f0febbec349 100644
--- a/mobile/src/session/mobile-native-chat-image-attachment.ts
+++ b/mobile/src/session/mobile-native-chat-image-attachment.ts
@@ -1,6 +1,5 @@
 import { saveMobileClipboardImageAsTempFile } from './mobile-clipboard-image'
 import type { MobileClipboardImageRpcSender } from './mobile-clipboard-image-operations'
-import { structuredAgentSessionDomainFingerprint } from '../../../src/shared/structured-agent-session-mutation'
 // Type-only import so this module (and its unit test) stays free of the expo/
 // react-native picker chain; the concrete `pickImage` is injected by the hook.
 import type { MobileImageSource, PickedMobileImage } from './mobile-image-source-picker'
@@ -12,18 +11,6 @@ export type PendingNativeChatImage = {
   readonly id: string
   readonly path: string
   readonly previewUri: string
-  /** Stable across repeat uploads of the same bytes; never contains the image. */
-  readonly contentFingerprint?: string
-}
-
-export const MOBILE_NATIVE_CHAT_IMAGE_FINGERPRINT_DOMAIN = 'mobile.nativeChat.image'
-
-export function mobileNativeChatImageContentFingerprint(base64: string): string {
-  return structuredAgentSessionDomainFingerprint({
-    domain: MOBILE_NATIVE_CHAT_IMAGE_FINGERPRINT_DOMAIN,
-    sessionId: '',
-    fields: { base64 }
-  })
 }
 
 export function appendPendingNativeChatImages(
@@ -50,7 +37,6 @@ export type UploadNativeChatImagesDeps = {
     | Iterable<PickedMobileImage>
     | AsyncIterable<PickedMobileImage>
     | Promise<Iterable<PickedMobileImage> | AsyncIterable<PickedMobileImage>>
-  readonly fingerprintImage?: (base64: string) => string | Promise<string>
   // Fired once the user has picked an image and the host upload is about to start —
   // lets the UI show the attach spinner only for the transfer, not the picker.
   readonly onUploadStart?: () => void
@@ -69,7 +55,6 @@ export async function uploadMobileNativeChatImages(
     client,
     getConnectionId,
     pickImages,
-    fingerprintImage = mobileNativeChatImageContentFingerprint,
     onUploadStart,
     onImageUploaded
   }: UploadNativeChatImagesDeps
@@ -86,11 +71,9 @@ export async function uploadMobileNativeChatImages(
     // Prefer the picker's local URI for the thumbnail; fall back to an inline data
     // URI when the source omitted one (RN <Image> renders both).
     const previewUri = image.uri ?? `data:image/png;base64,${image.base64}`
-    const fingerprint = fingerprintImage(image.base64)
     const result = {
       path,
-      previewUri,
-      contentFingerprint: typeof fingerprint === 'string' ? fingerprint : await fingerprint
+      previewUri
     }
     uploaded.push(result)
     onImageUploaded?.(result)
diff --git a/mobile/src/session/mobile-structured-agent-session-rpc.ts b/mobile/src/session/mobile-structured-agent-session-rpc.ts
index b5d7959eb460..7b2da967d56c 100644
--- a/mobile/src/session/mobile-structured-agent-session-rpc.ts
+++ b/mobile/src/session/mobile-structured-agent-session-rpc.ts
@@ -27,10 +27,7 @@ export const STRUCTURED_SEND_TIMEOUT_MS = 15_000
 export type StructuredAgentSessionMutationCallResult<TValue> =
   | { status: 'accepted'; value: TValue }
   | { status: 'refused'; code: AgentSessionWireRefusalCode; message: string }
-  /** `hostRejectedByRequestSchema`: the host's schema turned this request away before running
-   *  it, so the same request can never be accepted there. An auth refusal does not set it:
-   *  it says nothing about an earlier delivery of the same id. */
-  | { status: 'failed'; message: string; hostRejectedByRequestSchema?: true }
+  | { status: 'failed'; message: string }
   | { status: 'unknown' }
 
 export type StructuredAgentSessionMutationResult<TValue> =
@@ -188,10 +185,7 @@ export async function requestStructuredAgentSessionMutation<TValue>(args: {
         status: 'failed',
         message: agentSessionWriteNoticeEnglish(
           agentSessionWriteNoticeParts(answered, phoneWriteKind(fingerprintMethod, fields))
-        ),
-        ...(error instanceof AgentSessionRpcResponseError && error.code === 'invalid_argument'
-          ? { hostRejectedByRequestSchema: true }
-          : {})
+        )
       }
     }
     if (
diff --git a/mobile/src/session/mobile-structured-agent-session-send-bypass.test.ts b/mobile/src/session/mobile-structured-agent-session-send-bypass.test.ts
deleted file mode 100644
index 2652c041b525..000000000000
--- a/mobile/src/session/mobile-structured-agent-session-send-bypass.test.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-// A resend past a saved record storage would not clear goes out under a fresh id. A retry of that
-// text in the same app run must replay that id, never mint another: if the first resend's answer
-// was lost, a second fresh id could deliver the message twice.
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { RpcClient } from '../transport/rpc-client'
-import { markRpcDeliveryUnknown } from '../transport/rpc-delivery-ambiguity'
-import type { RpcResponse } from '../transport/types'
-import { DISPATCH_REJECTED_CANCELLED } from '../../../src/shared/structured-agent-session-dispatch-rejection'
-import { sendMobileStructuredAgentSessionMessage } from './mobile-structured-agent-session-send'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
-
-const asyncStorage = vi.hoisted(() => ({
-  getItem: vi.fn(),
-  setItem: vi.fn(),
-  removeItem: vi.fn()
-}))
-
-vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
-
-function ok(result: unknown): RpcResponse {
-  return { id: 'request-1', ok: true, result, _meta: { runtimeId: 'runtime-1' } }
-}
-
-/** Its own submission, which a Stop took back before the agent started it. */
-function stoppedAnswer(clientMessageId: string): RpcResponse {
-  return ok({
-    ok: true,
-    replayed: false,
-    fence: 3,
-    cursor: { epoch: 'epoch-1', sequence: 1 },
-    value: {
-      clientMessageId,
-      submission: {
-        clientMessageId,
-        fence: 3,
-        payloadFingerprint: 'fingerprint',
-        dispatchState: 'rejected',
-        providerItemId: null,
-        reason: DISPATCH_REJECTED_CANCELLED,
-        submittedAt: 10,
-        resolvedAt: 10
-      }
-    }
-  })
-}
-
-function queuedAnswer(clientMessageId: string, state: 'waiting' | 'withdrawn'): RpcResponse {
-  return ok({
-    ok: true,
-    replayed: false,
-    fence: 3,
-    cursor: { epoch: 'epoch-1', sequence: 1 },
-    value: { clientMessageId, queued: { messageId: clientMessageId, position: 1, state } }
-  })
-}
-
-/** Each `agentSession.send` answered in turn: a lost answer, a queued draft in that state, or its
- *  submission stopped. */
-function hostAnswering(answers: readonly ('lost' | 'waiting' | 'withdrawn' | 'stopped')[]) {
-  const ids: string[] = []
-  const deliveries: unknown[] = []
-  const sendRequest = vi.fn<RpcClient['sendRequest']>(async (_method, params) => {
-    const envelope = Object(Object(params).envelope)
-    const id = String(envelope.clientOperationId)
-    const answer = answers[ids.length]
-    ids.push(id)
-    deliveries.push(Object(params).delivery)
-    if (answer === 'lost' || answer === undefined) {
-      throw markRpcDeliveryUnknown(new Error('Connection closed'))
-    }
-    return answer === 'stopped' ? stoppedAnswer(id) : queuedAnswer(id, answer)
-  })
-  const client: RpcClient = {
-    sendRequest,
-    subscribe: vi.fn(() => vi.fn()),
-    updateTerminalSubscriptionViewport: () => {},
-    getState: () => 'connected',
-    getReconnectAttempt: () => 0,
-    getLastConnectedAt: () => null,
-    onStateChange: () => () => {},
-    notifyForeground: () => {},
-    close: () => {}
-  }
-  return { client, ids, deliveries }
-}
-
-function sendAgain(client: RpcClient, onError: (message: string) => void, queue = true) {
-  return sendMobileStructuredAgentSessionMessage({
-    client,
-    sessionId: 'session-1',
-    sessionKey: 'host-a:session-1',
-    callerIdentity: 'device-a',
-    expectedRuntimeFence: 3,
-    text: 'again',
-    attachments: [],
-    ...(queue ? { delivery: 'queue-if-active' as const } : {}),
-    onError
-  })
-}
-
-describe('a resend past a saved record storage would not clear', () => {
-  let stored: Map<string, string>
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
-    stored = new Map()
-    asyncStorage.getItem.mockImplementation(async (key: string) => stored.get(key) ?? null)
-    asyncStorage.setItem.mockImplementation(async (key: string, value: string) => {
-      stored.set(key, value)
-    })
-    asyncStorage.removeItem.mockImplementation(async (key: string) => {
-      stored.delete(key)
-    })
-  })
-
-  it('replays its own id once storage recovers, even without the queue capability now', async () => {
-    const { client, ids, deliveries } = hostAnswering([
-      'lost',
-      'withdrawn',
-      'lost',
-      'withdrawn',
-      'waiting'
-    ])
-    const onError = vi.fn()
-    expect(await sendAgain(client, onError)).toBe('unknown')
-    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
-    asyncStorage.removeItem.mockRejectedValue(new Error('disk full'))
-    expect(await sendAgain(client, onError)).toBe('unknown')
-    // Storage recovers: the lost send's record now clears, and the queue capability is gone.
-    asyncStorage.setItem.mockImplementation(async (key: string, value: string) => {
-      stored.set(key, value)
-    })
-    asyncStorage.removeItem.mockImplementation(async (key: string) => {
-      stored.delete(key)
-    })
-    expect(await sendAgain(client, onError, false)).toBe('queued')
-    expect(ids).toHaveLength(5)
-    // The resend's id is replayed, as first sent, never replaced by a fresh one.
-    expect(ids[4]).toBe(ids[2])
-    expect(deliveries[4]).toBe('queue-if-active')
-  })
-
-  it('replays its own id on a retry after a lost answer, and reports the record only once sent', async () => {
-    // Lost first send; its withdrawn replay; the fresh resend's answer lost; the retry's
-    // withdrawn replay; then the resend answered.
-    const { client, ids } = hostAnswering(['lost', 'withdrawn', 'lost', 'withdrawn', 'waiting'])
-    const onError = vi.fn()
-    const send = () =>
-      sendMobileStructuredAgentSessionMessage({
-        client,
-        sessionId: 'session-1',
-        sessionKey: 'host-a:session-1',
-        callerIdentity: 'device-a',
-        expectedRuntimeFence: 3,
-        text: 'again',
-        attachments: [],
-        delivery: 'queue-if-active',
-        onError
-      })
-    expect(await send()).toBe('unknown')
-    // From here the lost send's record can never be cleared.
-    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
-    asyncStorage.removeItem.mockRejectedValue(new Error('disk full'))
-
-    expect(await send()).toBe('unknown')
-    // An unconfirmed resend may not have gone out, so nothing says it was sent.
-    expect(onError).not.toHaveBeenCalled()
-
-    expect(await send()).toBe('queued')
-    expect(ids).toHaveLength(5)
-    expect(ids[1]).toBe(ids[0])
-    expect(ids[3]).toBe(ids[0])
-    expect(ids[2]).not.toBe(ids[0])
-    // The retry replays the resend's id rather than minting one that could deliver twice.
-    expect(ids[4]).toBe(ids[2])
-    expect(onError).toHaveBeenCalledWith(
-      "Sent, but this phone couldn't update its record of sent messages."
-    )
-  })
-
-  // Lost first send; its withdrawn replay; the fresh resend's answer lost; the retry's withdrawn
-  // replay; then that resend's own replay withdrawn too. A resend is sent once, never again.
-  it('sends a withdrawn replay once more at most, then hands a queued draft back', async () => {
-    const { client, ids } = hostAnswering(['lost', 'withdrawn', 'lost', 'withdrawn', 'withdrawn'])
-    const onError = vi.fn()
-    expect(await sendAgain(client, onError)).toBe('unknown')
-    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
-    asyncStorage.removeItem.mockRejectedValue(new Error('disk full'))
-    expect(await sendAgain(client, onError)).toBe('unknown')
-
-    expect(await sendAgain(client, onError)).toBe('rejected')
-    expect(ids).toHaveLength(5)
-    expect(ids[4]).toBe(ids[2])
-    expect(onError).toHaveBeenCalledWith('Message not sent')
-  })
-
-  it('reads a resend a Stop took back again as sent, since the chat draws it, not as not sent', async () => {
-    const { client, ids } = hostAnswering(['lost', 'stopped', 'lost', 'stopped', 'stopped'])
-    const onError = vi.fn()
-    expect(await sendAgain(client, onError, false)).toBe('unknown')
-    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
-    asyncStorage.removeItem.mockRejectedValue(new Error('disk full'))
-    expect(await sendAgain(client, onError, false)).toBe('unknown')
-
-    expect(await sendAgain(client, onError, false)).toBe('accepted')
-    expect(ids).toHaveLength(5)
-    expect(ids[4]).toBe(ids[2])
-    // Only the storage failure is reported; nothing says the message was not sent.
-    expect(onError.mock.calls).toEqual([
-      ["Sent, but this phone couldn't update its record of sent messages."]
-    ])
-  })
-})
diff --git a/mobile/src/session/mobile-structured-agent-session-send.ts b/mobile/src/session/mobile-structured-agent-session-send.ts
index 9fe25f68f59a..41c6e109a30f 100644
--- a/mobile/src/session/mobile-structured-agent-session-send.ts
+++ b/mobile/src/session/mobile-structured-agent-session-send.ts
@@ -3,248 +3,46 @@ import {
   structuredAgentSessionSendBody,
   type StructuredAgentSessionAttachment
 } from '../../../src/shared/structured-agent-session-send-mutation'
-import {
-  structuredAgentSessionDomainFingerprint,
-  structuredAgentSessionPayloadFingerprint
-} from '../../../src/shared/structured-agent-session-mutation'
 import type { RpcClient } from '../transport/rpc-client'
 import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
 import {
   requestStructuredAgentSessionMutation,
   timeoutForDeadline
 } from './mobile-structured-agent-session-rpc'
-import { structuredSessionOperationId } from './structured-session-operation-id'
-import {
-  mobileStructuredSendDelivery,
-  mobileStructuredSendWithdrawnBeforeStart
-} from './mobile-structured-send-delivery'
-import {
-  bypassedMobileStructuredSendOperationId,
-  clearMobileStructuredSendOperation,
-  forgetBypassedMobileStructuredSendOperation,
-  getOrCreateMobileStructuredSendOperation,
-  mobileStructuredSendOperationKey,
-  rememberBypassedMobileStructuredSendOperation
-} from './mobile-structured-send-operation-journal'
+import { mobileStructuredSendDelivery } from './mobile-structured-send-delivery'
 
 export async function sendMobileStructuredAgentSessionMessage(input: {
   client: RpcClient
   sessionId: string
-  sessionKey: string
-  callerIdentity: string
   expectedRuntimeFence: number
   text: string
-  attachments: readonly (StructuredAgentSessionAttachment & { contentFingerprint?: string })[]
+  attachments: readonly StructuredAgentSessionAttachment[]
   /** Sent only when the host advertises `agent-session.queued-messages.v1`. */
   delivery?: 'queue-if-active'
   deadline?: number
   onError: (message: string) => void
-  /** Internal: the one fresh-id resend after a withdrawn replay. */
-  resendingAfterWithdrawal?: true
-  /** Internal: that resend when the withdrawn id's record could not be cleared. It bypasses the
-   *  record, so failing storage never blocks the send; its id is kept in memory for this app run,
-   *  so a retry after a lost answer replays it rather than sending again. */
-  bypassRetainedRecord?: true
-  /** Internal: on that resend, the key the withdrawn record matched. The remembered id is keyed
-   *  by it, so a capability change since the lost answer never mints another id. */
-  resendOperationKey?: string
 }): Promise<MobileNativeChatSendOutcome> {
   const timeoutMs = timeoutForDeadline(input.deadline)
   if (timeoutMs === null) {
     input.onError('Message not sent')
     return 'rejected'
   }
-  const requestedBody = structuredAgentSessionSendBody(input.text, input.attachments)
-  const requestedPayloadFingerprint = structuredAgentSessionPayloadFingerprint({
-    method: 'agentSession.send',
-    sessionId: input.sessionId,
-    fields: { body: requestedBody }
-  })
-  const intentFields = {
-    text: input.text.trimEnd(),
-    attachments: input.attachments.map(
-      (attachment) =>
-        attachment.contentFingerprint ??
-        structuredAgentSessionDomainFingerprint({
-          domain: 'mobile.nativeChat.image.preview',
-          sessionId: '',
-          fields: { previewUri: attachment.previewUri }
-        })
-    )
-  }
-  // `delivery` is part of the intent key, never a stored journal field: the
-  // immediate key is exactly today's, so an older build still reads the journal.
-  const operationKeyFor = (delivery: 'queue-if-active' | undefined): string =>
-    mobileStructuredSendOperationKey({
-      sessionKey: input.sessionKey,
-      intentFingerprint: structuredAgentSessionDomainFingerprint({
-        domain: 'mobile.agentSession.send.intent',
-        sessionId: input.sessionKey,
-        fields: delivery ? { ...intentFields, delivery } : intentFields
-      })
-    })
-  const queuedOperationKey = operationKeyFor('queue-if-active')
-  const immediateOperationKey = operationKeyFor(undefined)
-  const requestedOperationKey = input.delivery ? queuedOperationKey : immediateOperationKey
-  const attachmentPaths = input.attachments.map((attachment) => attachment.path)
-  const resendKey = input.resendOperationKey ?? requestedOperationKey
-  let operation: Awaited<ReturnType<typeof getOrCreateMobileStructuredSendOperation>>
-  try {
-    if (input.bypassRetainedRecord) {
-      operation = bypassOperation(resendKey, requestedPayloadFingerprint, attachmentPaths)
-    } else if (
-      input.resendOperationKey !== undefined &&
-      bypassedMobileStructuredSendOperationId(resendKey) !== undefined
-    ) {
-      // Storage recovered after a bypassed resend's answer was lost: that id is replayed, never
-      // replaced by a fresh one that could deliver the message twice.
-      operation = await adoptBypassedOperation({
-        operationKey: resendKey,
-        callerIdentity: input.callerIdentity,
-        payloadFingerprint: requestedPayloadFingerprint,
-        attachmentPaths
-      })
-    } else {
-      operation = await getOrCreateMobileStructuredSendOperation({
-        operationKey: requestedOperationKey,
-        // A retained id replays exactly as first sent, whatever the capability says now;
-        // a host that refuses that request shape retires it, so the next send goes out fresh.
-        alternateOperationKey: input.delivery ? immediateOperationKey : queuedOperationKey,
-        callerIdentity: input.callerIdentity,
-        payloadFingerprint: requestedPayloadFingerprint,
-        attachmentPaths,
-        createOperationId: structuredSessionOperationId
-      })
-    }
-  } catch {
-    input.onError('Message not sent')
-    return 'rejected'
-  }
-  const operationKey = operation.operationKey
-  const delivery = operationKey === queuedOperationKey ? 'queue-if-active' : undefined
-  const body = structuredAgentSessionSendBody(
-    input.text,
-    operation.attachmentPaths.map((path) => ({ path, previewUri: '' }))
-  )
-  const payloadFingerprint = structuredAgentSessionPayloadFingerprint({
-    method: 'agentSession.send',
-    sessionId: input.sessionId,
-    fields: { body }
-  })
-  if (payloadFingerprint !== operation.payloadFingerprint) {
-    input.onError('Message not sent')
-    return 'rejected'
-  }
+  // Each Send is a new action; the shared mutation sender mints its operation id once.
   const result = await requestStructuredAgentSessionMutation<AgentSessionSendResult>({
     client: input.client,
     method: 'agentSession.send',
     fingerprintMethod: 'agentSession.send',
     sessionId: input.sessionId,
     expectedRuntimeFence: input.expectedRuntimeFence,
-    // `delivery` joins the wire fields — and so the operation fingerprint — but
-    // never the journal's body-only fingerprint the submission echo recomputes.
-    fields: { body, ...(delivery ? { delivery } : {}) },
-    clientOperationId: operation.operationId,
+    fields: {
+      body: structuredAgentSessionSendBody(input.text, input.attachments),
+      ...(input.delivery ? { delivery: input.delivery } : {})
+    },
     timeoutMs
   })
-  const outcome = mobileStructuredSendDelivery(result, operation.retained)
-  if (input.bypassRetainedRecord && outcome.operationIdSpent) {
-    forgetBypassedMobileStructuredSendOperation(operationKey, operation.operationId)
-  }
-  let released = false
-  if (outcome.operationIdSpent) {
-    try {
-      await clearMobileStructuredSendOperation({
-        operationKey,
-        operationId: operation.operationId
-      })
-      released = true
-    } catch {
-      // A retained settled id can suppress a later identical send, never
-      // duplicate this one; the next replay gets another clear chance.
-    }
-  }
-  const withdrawnReplay =
-    (result.status === 'accepted' &&
-      'queued' in result.value &&
-      result.value.queued?.state === 'withdrawn') ||
-    (operation.retained && mobileStructuredSendWithdrawnBeforeStart(result))
-  if (withdrawnReplay && operation.retained && !input.resendingAfterWithdrawal) {
-    // The retained id's draft or submission was withdrawn, so it never reached the agent:
-    // this identical message is a new one, not a replay to swallow. A record
-    // storage would not clear is bookkeeping: it is reported, never allowed to
-    // block the send.
-    const resent = await sendMobileStructuredAgentSessionMessage({
-      ...input,
-      resendingAfterWithdrawal: true,
-      resendOperationKey: operationKey,
-      ...(released ? {} : { bypassRetainedRecord: true as const })
-    })
-    // Only when the resend is known to have gone out; an unconfirmed one may not have.
-    if (!released && (resent === 'accepted' || resent === 'queued')) {
-      input.onError("Sent, but this phone couldn't update its record of sent messages.")
-    }
-    return resent
-  }
-  if (withdrawnReplay && mobileStructuredSendWithdrawnBeforeStart(result)) {
-    // Not resent, but the chat draws it with its stop row: handing it back too would show it twice.
-    return 'accepted'
-  }
-  if (withdrawnReplay) {
-    // Not resent: no card and no bubble holds the text, so it goes back to the
-    // composer rather than vanishing.
-    input.onError('Message not sent')
-    return 'rejected'
-  }
+  const outcome = mobileStructuredSendDelivery(result)
   if (outcome.error !== null) {
     input.onError(outcome.error)
   }
   return outcome.outcome
 }
-
-/** The id a resend past an uncleared record goes out under: the one this app run already used
- *  for this text, replayed, or a fresh one remembered for the next retry. */
-function bypassOperation(
-  operationKey: string,
-  payloadFingerprint: string,
-  attachmentPaths: string[]
-): Awaited<ReturnType<typeof getOrCreateMobileStructuredSendOperation>> {
-  const bypassed = bypassedMobileStructuredSendOperationId(operationKey)
-  const operationId = bypassed ?? structuredSessionOperationId()
-  if (bypassed === undefined) {
-    rememberBypassedMobileStructuredSendOperation(operationKey, operationId)
-  }
-  return {
-    operationKey,
-    operationId,
-    retained: bypassed !== undefined,
-    payloadFingerprint,
-    attachmentPaths
-  }
-}
-
-/** A remembered bypassed id handed back to the saved record once storage works again: the record
- *  replays it, and memory lets it go. Should storage fail again, memory keeps replaying it. */
-async function adoptBypassedOperation(input: {
-  operationKey: string
-  callerIdentity: string
-  payloadFingerprint: string
-  attachmentPaths: string[]
-}): Promise<Awaited<ReturnType<typeof getOrCreateMobileStructuredSendOperation>>> {
-  const operationId = bypassedMobileStructuredSendOperationId(input.operationKey)
-  if (operationId === undefined) {
-    throw new Error('No bypassed send id to adopt')
-  }
-  try {
-    const recorded = await getOrCreateMobileStructuredSendOperation({
-      ...input,
-      createOperationId: () => operationId
-    })
-    if (recorded.operationId === operationId) {
-      forgetBypassedMobileStructuredSendOperation(input.operationKey, operationId)
-    }
-    return { ...recorded, retained: true }
-  } catch {
-    return bypassOperation(input.operationKey, input.payloadFingerprint, input.attachmentPaths)
-  }
-}
diff --git a/mobile/src/session/mobile-structured-send-delivery.test.ts b/mobile/src/session/mobile-structured-send-delivery.test.ts
index b7e457c7569d..ef0e7a520d9a 100644
--- a/mobile/src/session/mobile-structured-send-delivery.test.ts
+++ b/mobile/src/session/mobile-structured-send-delivery.test.ts
@@ -6,8 +6,6 @@ import { mobileStructuredSendDelivery } from './mobile-structured-send-delivery'
 import type { StructuredAgentSessionMutationCallResult } from './mobile-structured-agent-session-rpc'
 import { structuredSendResultFixture } from './structured-agent-send-result.test-fixture'
 
-const WITHDRAWN_SENTENCE = 'This message was withdrawn before the agent started it.'
-
 function accepted(
   dispatchState: AgentJournalDispatchState,
   reason: string | null = null
@@ -16,291 +14,147 @@ function accepted(
 }
 
 describe('mobileStructuredSendDelivery', () => {
-  it('keeps the operation id for every unknown, host-recorded or ack-lost', () => {
-    // The one answer that may be a delivery. Spending the id here turns the next
-    // identical send into a second copy in front of the model.
+  it('reports transport and host uncertainty on this send', () => {
     expect(mobileStructuredSendDelivery({ status: 'unknown' })).toEqual({
       outcome: 'unknown',
-      operationIdSpent: false,
       error: null
     })
     expect(mobileStructuredSendDelivery(accepted('unknown'))).toEqual({
       outcome: 'unknown',
-      operationIdSpent: false,
       error: null
     })
   })
 
-  it('reports a written send as sent and spends its id', () => {
-    // `pending` is written and awaiting the provider's acknowledgement — not doubt.
-    for (const dispatchState of ['accepted', 'pending'] as const) {
-      expect(mobileStructuredSendDelivery(accepted(dispatchState))).toEqual({
-        outcome: 'accepted',
-        operationIdSpent: true,
-        error: null
-      })
-    }
+  it.each(['accepted', 'pending'] as const)('reports a written %s send as accepted', (state) => {
+    expect(mobileStructuredSendDelivery(accepted(state))).toEqual({
+      outcome: 'accepted',
+      error: null
+    })
   })
 
-  it('classifies a queued draft answer as spent, card-rendered, never a bubble', () => {
-    // The host holds the message now; a later identical send is a new message.
-    // A dispatched draft answers as `queued` only when the host lost its
-    // submission, so no echo would retire a bubble: it too shows nothing.
-    for (const state of ['waiting', 'dispatched', 'returned', 'withdrawn'] as const) {
-      const queued: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
+  it.each(['waiting', 'dispatched', 'returned'] as const)(
+    'lets the host own its %s queued message without an optimistic bubble',
+    (state) => {
+      expect(
+        mobileStructuredSendDelivery({
+          status: 'accepted',
+          value: {
+            clientMessageId: 'client-1',
+            queued: { messageId: 'client-1', position: 1, state }
+          }
+        })
+      ).toEqual({ outcome: 'queued', error: null })
+    }
+  )
+
+  it('hands back a withdrawn card instead of silently sending again', () => {
+    expect(
+      mobileStructuredSendDelivery({
         status: 'accepted',
         value: {
           clientMessageId: 'client-1',
-          queued: { messageId: 'client-1', position: 1, state }
+          queued: { messageId: 'client-1', position: 1, state: 'withdrawn' }
         }
-      }
-      const outcome = 'queued'
-      expect(mobileStructuredSendDelivery(queued)).toEqual({
-        outcome,
-        operationIdSpent: true,
-        error: null
       })
-      expect(mobileStructuredSendDelivery(queued, true)).toEqual({
-        outcome,
-        operationIdSpent: true,
-        error: null
-      })
-    }
+    ).toEqual({ outcome: 'rejected', error: 'Message not sent' })
   })
 
-  it("reads a replay answered by its draft's hand-off as unconfirmed, and spends the id", () => {
-    // The hand-off names the replayed id as its draft: the host's answer states the link, so the
-    // id is spent without waiting for a stream that may never carry the hand-off.
-    const handedOff = structuredSendResultFixture('accepted')
-    if (!('submission' in handedOff)) {
+  it('keeps a handed-off queued message unconfirmed until the stream identifies it', () => {
+    const value = structuredSendResultFixture('accepted')
+    if (!('submission' in value)) {
       throw new Error('expected a submission answer')
     }
-    const replay: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
-      status: 'accepted',
-      value: {
-        clientMessageId: 'retained-draft-id',
-        submission: {
-          ...handedOff.submission,
-          clientMessageId: 'fresh-id',
-          queuedMessageId: 'retained-draft-id'
+    expect(
+      mobileStructuredSendDelivery({
+        status: 'accepted',
+        value: {
+          clientMessageId: 'draft-id',
+          submission: {
+            ...value.submission,
+            clientMessageId: 'fresh-id',
+            queuedMessageId: 'draft-id'
+          }
         }
-      }
-    }
-    expect(mobileStructuredSendDelivery(replay, true)).toEqual({
-      outcome: 'unknown',
-      operationIdSpent: true,
-      error: null
-    })
+      })
+    ).toEqual({ outcome: 'unknown', error: null })
   })
 
-  it('never spends a retained id on a malformed answer with no submission and no id', () => {
-    const malformed: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
-      status: 'accepted',
-      value: JSON.parse('{}')
-    }
-    expect(mobileStructuredSendDelivery(malformed, true)).toEqual({
+  it('fails closed when a malformed answer has no submission', () => {
+    expect(mobileStructuredSendDelivery({ status: 'accepted', value: JSON.parse('{}') })).toEqual({
       outcome: 'unknown',
-      operationIdSpent: false,
       error: null
     })
   })
 
-  it('does not report a retained payload replay as a new accepted send', () => {
-    for (const dispatchState of ['accepted', 'pending'] as const) {
-      expect(mobileStructuredSendDelivery(accepted(dispatchState), true)).toEqual({
-        outcome: 'unknown',
-        operationIdSpent: false,
-        error: null
-      })
-    }
-  })
-
-  it('spends the id of a rejection and withholds its internal reason', () => {
-    // Provably undelivered and terminal, so the id can only replay it: spending the
-    // id makes the retry a first delivery. The marker itself names nothing a person
-    // can act on, so it must not reach the screen.
+  it('withholds internal provider write reasons', () => {
     expect(
       mobileStructuredSendDelivery(accepted('rejected', 'provider_write_failed: broken pipe'))
     ).toEqual({
       outcome: 'rejected',
-      operationIdSpent: true,
       error: "Orca couldn't reach the agent. Your message was not sent. Send it again."
     })
   })
 
-  it('answers a send the host kept as a card like a queued one, first send or replay', () => {
-    // The card shows the text, so neither an error nor a composer hand-back may repeat it.
-    const kept: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
-      status: 'accepted',
-      value: {
-        clientMessageId: 'msg-1',
-        submission: {
-          clientMessageId: 'msg-1',
-          fence: 3,
-          payloadFingerprint: 'fingerprint',
-          dispatchState: 'rejected',
-          providerItemId: null,
-          reason: 'Orca restarted before this was sent.',
-          submittedAt: 10,
-          resolvedAt: 10,
-          keptAsQueuedMessageId: 'msg-1'
-        }
-      }
-    }
-    for (const retained of [false, true]) {
-      expect(mobileStructuredSendDelivery(kept, retained)).toEqual({
-        outcome: 'queued',
-        operationIdSpent: true,
-        error: null
-      })
+  it('lets a kept queued card hold the text after a provider rejection', () => {
+    const value = structuredSendResultFixture('rejected', 'Orca restarted before this was sent.')
+    if (!('submission' in value)) {
+      throw new Error('expected a submission answer')
     }
+    value.submission.keptAsQueuedMessageId = 'card-id'
+    expect(mobileStructuredSendDelivery({ status: 'accepted', value })).toEqual({
+      outcome: 'queued',
+      error: null
+    })
   })
 
-  // The chat draws a send a Stop took back with its stop row, so it never goes back to the draft. A
-  // retained replay is resent by the caller, which needs the id spent and no words of its own.
   it.each([
-    { retained: false, reason: DISPATCH_REJECTED_CANCELLED, fact: false, outcome: 'accepted' },
-    { retained: false, reason: WITHDRAWN_SENTENCE, fact: true, outcome: 'accepted' },
-    { retained: true, reason: DISPATCH_REJECTED_CANCELLED, fact: false, outcome: 'rejected' },
-    { retained: true, reason: WITHDRAWN_SENTENCE, fact: true, outcome: 'rejected' }
-  ] as const)(
-    'reads a send a Stop took back (retained $retained, typed fact $fact) as $outcome, spent, wordless',
-    ({ retained, reason, fact, outcome }) => {
-      const value = structuredSendResultFixture('rejected', reason)
-      if (fact && 'submission' in value) {
-        value.submission.rejection = { kind: 'cancelled' }
-      }
-      expect(mobileStructuredSendDelivery({ status: 'accepted', value }, retained)).toEqual({
-        outcome,
-        operationIdSpent: true,
-        error: null
-      })
+    { reason: DISPATCH_REJECTED_CANCELLED, typed: false },
+    { reason: 'This message was withdrawn before the agent started it.', typed: true }
+  ])('leaves a stopped submission in its existing chat row (typed $typed)', ({ reason, typed }) => {
+    const value = structuredSendResultFixture('rejected', reason)
+    if (typed && 'submission' in value) {
+      value.submission.rejection = { kind: 'cancelled' }
     }
-  )
+    expect(mobileStructuredSendDelivery({ status: 'accepted', value })).toEqual({
+      outcome: 'accepted',
+      error: null
+    })
+  })
 
-  it('shows a provider content rejection verbatim', () => {
+  it('shows an actionable content rejection', () => {
     expect(
       mobileStructuredSendDelivery(accepted('rejected', 'Claude does not support .bmp'))
-    ).toEqual({
+    ).toEqual({ outcome: 'rejected', error: 'Claude does not support .bmp' })
+  })
+
+  it.each([
+    ['agent_session_operation_invalid', 'Invalid operation'],
+    ['agent_session_checkpoint_stale', 'Fence moved'],
+    ['agent_session_operation_expired', 'Operation expired'],
+    ['agent_session_operation_conflict', 'Operation conflict']
+  ] as const)('reports the current %s refusal', (code, message) => {
+    expect(mobileStructuredSendDelivery({ status: 'refused', code, message })).toEqual({
       outcome: 'rejected',
-      operationIdSpent: true,
-      error: 'Claude does not support .bmp'
+      error: message
     })
   })
 
-  it('spends only refusals that prove the operation is settled', () => {
-    expect(
-      mobileStructuredSendDelivery({
-        status: 'refused',
-        code: 'agent_session_operation_invalid',
-        message: 'Invalid operation'
-      })
-    ).toEqual({ outcome: 'rejected', operationIdSpent: true, error: 'Invalid operation' })
-    expect(
-      mobileStructuredSendDelivery({
-        status: 'refused',
-        code: 'agent_session_checkpoint_stale',
-        message: 'Fence moved'
-      })
-    ).toEqual({ outcome: 'rejected', operationIdSpent: false, error: 'Fence moved' })
+  it('preserves an unknown operation refusal as uncertainty', () => {
     expect(
       mobileStructuredSendDelivery({
         status: 'refused',
         code: 'agent_session_operation_unknown',
         message: 'Outcome unknown'
       })
-    ).toEqual({ outcome: 'unknown', operationIdSpent: false, error: null })
+    ).toEqual({ outcome: 'unknown', error: null })
+  })
+
+  it('reports a request failure without consulting earlier sends', () => {
     expect(
       mobileStructuredSendDelivery({
         status: 'failed',
         message: 'Your message was not sent. Send it again.'
       })
-    ).toEqual({
-      outcome: 'rejected',
-      operationIdSpent: true,
-      error: 'Your message was not sent. Send it again.'
-    })
-  })
-
-  it('spends an ambiguous id the host has expired, and says to check the chat', () => {
-    // The host refuses an expired id on every replay; keeping it would refuse this text forever.
-    // The earlier attempt may still be in the chat, so the words never say it was not sent.
-    expect(
-      mobileStructuredSendDelivery(
-        {
-          status: 'refused',
-          code: 'agent_session_operation_expired',
-          message: 'Operation expired'
-        },
-        true
-      )
-    ).toEqual({
-      outcome: 'rejected',
-      operationIdSpent: true,
-      error:
-        "Orca couldn't confirm your message reached the agent. Check the chat, then send it again if needed."
-    })
-  })
-
-  it('never releases an ambiguous id on any other later RPC refusal or failure', () => {
-    expect(
-      mobileStructuredSendDelivery(
-        {
-          status: 'refused',
-          code: 'agent_session_operation_conflict',
-          message: 'Operation conflict'
-        },
-        true
-      )
-    ).toEqual({ outcome: 'rejected', operationIdSpent: false, error: 'Operation conflict' })
-    expect(
-      mobileStructuredSendDelivery(
-        { status: 'failed', message: 'Your message was not sent. Send it again.' },
-        true
-      )
-    ).toEqual({
-      outcome: 'rejected',
-      operationIdSpent: false,
-      error: 'Your message was not sent. Send it again.'
-    })
-  })
-
-  it('releases a replay only when the host refuses its request shape itself', () => {
-    // An older host's strict schema refuses `delivery` before it runs anything:
-    // that replay can never be accepted, so keeping the id refuses the text forever.
-    expect(
-      mobileStructuredSendDelivery(
-        {
-          status: 'failed',
-          message: 'Your message was not sent. Send it again.',
-          hostRejectedByRequestSchema: true
-        },
-        true
-      )
-    ).toEqual({
-      outcome: 'rejected',
-      operationIdSpent: true,
-      error: 'Your message was not sent. Send it again.'
-    })
-    // Any other refusal (an auth failure, a host without the method) proves nothing
-    // about an earlier delivery of this id.
-    expect(
-      mobileStructuredSendDelivery(
-        { status: 'failed', message: 'Your message was not sent.' },
-        true
-      )
-    ).toMatchObject({ operationIdSpent: false })
-  })
-
-  it('fails closed when an invalid host response omits the required submission', () => {
-    const result = {
-      status: 'accepted',
-      value: { clientMessageId: 'msg-1' }
-    } as unknown as StructuredAgentSessionMutationCallResult<AgentSessionSendResult>
-    expect(mobileStructuredSendDelivery(result)).toEqual({
-      outcome: 'unknown',
-      operationIdSpent: false,
-      error: null
-    })
+    ).toEqual({ outcome: 'rejected', error: 'Your message was not sent. Send it again.' })
   })
 })
diff --git a/mobile/src/session/mobile-structured-send-delivery.ts b/mobile/src/session/mobile-structured-send-delivery.ts
index 32dbc6f99e93..744a561cabb1 100644
--- a/mobile/src/session/mobile-structured-send-delivery.ts
+++ b/mobile/src/session/mobile-structured-send-delivery.ts
@@ -1,40 +1,5 @@
-// What one `agentSession.send` answer means to a client with no outbox.
-//
-// The desktop reads the same four dispatch states through
-// `disposeStructuredAgentSessionSendResult`; mobile has no queue to move, so it
-// needs only two facts: the outcome to report, and whether the operation id it
-// sent under is spent.
-//
-// The id is the whole safety mechanism here. Mobile keys its retained ids by
-// message body, so re-sending the same text reuses the id — and one id is one
-// delivery: `performSend` answers a second request under a recorded id from the
-// ledger and never puts it back on the wire. Releasing the id turns that replay
-// into a genuine second delivery, which is why only a settled answer releases it:
-//
-//   accepted/pending — the send happened. The id is spent; a later identical
-//     message is a new message and must carry a new id.
-//   withdrawn — a submission a Stop took back before the agent started it is
-//     drawn in the chat with its stop row, so it spends the id and goes back to no
-//     draft. Answering a first send, it is that message: sent, then stopped. As a
-//     retained replay it cannot be told from a new send of the same text, and it
-//     provably never ran, so the caller sends it again under a fresh id.
-//   rejected — a terminal refusal or rejected submission spends a fresh id. A
-//     pending-admission refusal, or any refusal after earlier transport doubt,
-//     keeps it because neither proves a retained delivery did not happen. Two
-//     exceptions spend it anyway, because the host can never accept the replay
-//     and keeping the id would only refuse every later send of the same text:
-//     a host that refuses the replay's request shape itself (an older host's
-//     strict schema turning `delivery` away), and an id the host has expired.
-//     A rejection the host kept as a card answers as `queued`: the card holds the text.
-//   unknown — the one answer that KEEPS its id, whether it came from the host or
-//     from an ack-loss on the way back. The message may be with the provider, so
-//     the retry has to stay a replay. Rotating here is what sent one message to a
-//     model five times.
-
-import type { AgentJournalSubmission } from '../../../src/shared/agent-session-journal-types'
 import type { AgentSessionSendResult } from '../../../src/shared/agent-session-wire'
 import { agentSessionRefusalOperationState } from '../../../src/shared/agent-session-refusal-retry'
-import { agentSessionWriteNoticeEnglish } from '../../../src/shared/agent-session-refusal-notice'
 import { structuredAgentSessionRejectionNotice } from '../../../src/shared/structured-agent-session-rejection-words'
 import { dispatchWasWithdrawn } from '../../../src/shared/structured-agent-session-dispatch-rejection'
 import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
@@ -42,103 +7,47 @@ import type { StructuredAgentSessionMutationCallResult } from './mobile-structur
 
 export type MobileStructuredSendDelivery = {
   outcome: MobileNativeChatSendOutcome
-  /** True when a retry is safe under a fresh operation id. */
-  operationIdSpent: boolean
-  /** Copy for the user, or null when the outcome needs none. */
   error: string | null
 }
 
-/** Whether a send answer is its own submission, which a Stop took back before the agent started it. */
-export function mobileStructuredSendWithdrawnBeforeStart(
-  result: StructuredAgentSessionMutationCallResult<AgentSessionSendResult>
-): boolean {
-  if (result.status !== 'accepted' || !('submission' in result.value)) {
-    return false
-  }
-  const { submission } = result.value
-  return (
-    submission.queuedMessageId === undefined &&
-    submission.dispatchState === 'rejected' &&
-    dispatchWasWithdrawn(submission)
-  )
-}
-
 export function mobileStructuredSendDelivery(
-  result: StructuredAgentSessionMutationCallResult<AgentSessionSendResult>,
-  retained = false
+  result: StructuredAgentSessionMutationCallResult<AgentSessionSendResult>
 ): MobileStructuredSendDelivery {
   if (result.status === 'unknown') {
-    return { outcome: 'unknown', operationIdSpent: false, error: null }
+    return { outcome: 'unknown', error: null }
   }
   if (result.status === 'refused') {
-    const refusalState = agentSessionRefusalOperationState(result.code)
-    if (refusalState === 'unknown') {
-      return { outcome: 'unknown', operationIdSpent: false, error: null }
-    }
-    if (retained && result.code === 'agent_session_operation_expired') {
-      // The host refuses this id for good once its day is up, so keeping it would refuse this text
-      // forever. The earlier attempt may already be in the chat, so the words say to check first.
-      return {
-        outcome: 'rejected',
-        operationIdSpent: true,
-        error: agentSessionWriteNoticeEnglish(['sendOutcomeLost'])
-      }
-    }
-    return {
-      outcome: 'rejected',
-      operationIdSpent: refusalState === 'settled-rejected' && !retained,
-      error: result.message
-    }
+    return agentSessionRefusalOperationState(result.code) === 'unknown'
+      ? { outcome: 'unknown', error: null }
+      : { outcome: 'rejected', error: result.message }
   }
   if (result.status !== 'accepted') {
-    return {
-      outcome: 'rejected',
-      operationIdSpent: !retained || result.hostRejectedByRequestSchema === true,
-      error: result.message
-    }
+    return { outcome: 'rejected', error: result.message }
   }
   if ('queued' in result.value && result.value.queued) {
-    // The host holds (or already settled) the draft: the send is spent — a
-    // later identical message is a new message. A withdrawn replay is spent
-    // too, never unknown: its card was deleted or carried by a /clear, and the
-    // caller resends it or hands the text back. A dispatched draft answers here
-    // only when the host could not find the submission it became (a live one
-    // answers with that submission), so no echo would retire an optimistic
-    // bubble: it shows nothing, and the transcript or the card owns the text.
-    return { outcome: 'queued', operationIdSpent: true, error: null }
-  }
-  const submission: AgentJournalSubmission | undefined =
-    'submission' in result.value ? result.value.submission : undefined
-  if (submission !== undefined && submission.queuedMessageId === result.value.clientMessageId) {
-    // The host says this id's queued draft was handed off as that submission: the send reached
-    // it, so the id is spent now, not when a stream that may never carry the hand-off shows it.
-    // Which send the phone meant stays unconfirmed, as for any retained replay of a live send.
-    return { outcome: 'unknown', operationIdSpent: true, error: null }
+    return result.value.queued.state === 'withdrawn'
+      ? { outcome: 'rejected', error: 'Message not sent' }
+      : { outcome: 'queued', error: null }
   }
+  const submission = 'submission' in result.value ? result.value.submission : undefined
   if (!submission || submission.dispatchState === 'unknown') {
-    return { outcome: 'unknown', operationIdSpent: false, error: null }
+    return { outcome: 'unknown', error: null }
   }
-  if (submission.dispatchState === 'rejected' && submission.keptAsQueuedMessageId !== undefined) {
-    // The host kept it as a card, which holds the text: no error, and nothing handed back to the
-    // composer, so the words never show twice.
-    return { outcome: 'queued', operationIdSpent: true, error: null }
-  }
-  if (mobileStructuredSendWithdrawnBeforeStart(result)) {
-    // The chat draws it with its stop row, so it is never handed back to the composer as well. A
-    // retained replay is resent by the caller.
-    return { outcome: retained ? 'rejected' : 'accepted', operationIdSpent: true, error: null }
+  if (submission.queuedMessageId === result.value.clientMessageId) {
+    return { outcome: 'unknown', error: null }
   }
   if (submission.dispatchState === 'rejected') {
+    if (submission.keptAsQueuedMessageId !== undefined) {
+      return { outcome: 'queued', error: null }
+    }
+    if (submission.queuedMessageId === undefined && dispatchWasWithdrawn(submission)) {
+      // The host transcript already owns this send's stopped row.
+      return { outcome: 'accepted', error: null }
+    }
     return {
       outcome: 'rejected',
-      operationIdSpent: true,
       error: structuredAgentSessionRejectionNotice(submission.reason, 'composer-send')
     }
   }
-  if (retained) {
-    // A payload match cannot distinguish retrying the ambiguous action from a
-    // later identical intent. Wait for the stream to settle and release it.
-    return { outcome: 'unknown', operationIdSpent: false, error: null }
-  }
-  return { outcome: 'accepted', operationIdSpent: true, error: null }
+  return { outcome: 'accepted', error: null }
 }
diff --git a/mobile/src/session/mobile-structured-send-new-action.test.ts b/mobile/src/session/mobile-structured-send-new-action.test.ts
new file mode 100644
index 000000000000..71827af8640c
--- /dev/null
+++ b/mobile/src/session/mobile-structured-send-new-action.test.ts
@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RpcClient } from '../transport/rpc-client'
+import { fieldsOf } from './use-mobile-structured-agent-session-queued.test-fixture'
+import { markRpcDeliveryUnknown } from '../transport/rpc-delivery-ambiguity'
+import { sendMobileStructuredAgentSessionMessage } from './mobile-structured-agent-session-send'
+
+const storage = vi.hoisted(() => ({ getItem: vi.fn(), setItem: vi.fn(), removeItem: vi.fn() }))
+vi.mock('@react-native-async-storage/async-storage', () => ({ default: storage }))
+
+describe('a new phone send after an acknowledgement was lost', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    const saved = new Map<string, string>()
+    storage.getItem.mockImplementation(async (key: string) => saved.get(key) ?? null)
+    storage.setItem.mockImplementation(async (key: string, value: string) => saved.set(key, value))
+    storage.removeItem.mockImplementation(async (key: string) => saved.delete(key))
+  })
+
+  it.each([false, true])(
+    'delivers identical text as a new action while the old host entry stays unknown (relaunch %s)',
+    async (relaunch) => {
+      const ids: string[] = []
+      const delivered: string[] = []
+      const ledger = new Set<string>()
+      const sendRequest = vi.fn<RpcClient['sendRequest']>(async (_method, params) => {
+        const id = String(fieldsOf(fieldsOf(params).envelope).clientOperationId)
+        const replayed = ledger.has(id)
+        ids.push(id)
+        if (!replayed) {
+          ledger.add(id)
+          delivered.push(id)
+          if (delivered.length === 1) {
+            throw markRpcDeliveryUnknown(new Error('Connection closed after dispatch'))
+          }
+        }
+        return {
+          id: 'response',
+          ok: true,
+          result: {
+            ok: true,
+            replayed,
+            fence: 3,
+            cursor: { epoch: 'epoch', sequence: 1 },
+            value: {
+              clientMessageId: id,
+              submission: {
+                clientMessageId: id,
+                fence: 3,
+                payloadFingerprint: String(fieldsOf(fieldsOf(params).envelope).payloadFingerprint),
+                dispatchState: id === delivered[0] ? 'unknown' : 'accepted',
+                providerItemId: null,
+                reason: null,
+                submittedAt: Date.now(),
+                resolvedAt: null
+              }
+            }
+          }
+        }
+      })
+      const clientFor = (): RpcClient => ({
+        sendRequest,
+        subscribe: vi.fn(() => vi.fn()),
+        updateTerminalSubscriptionViewport: () => {},
+        getState: () => 'connected',
+        getReconnectAttempt: () => 0,
+        getLastConnectedAt: () => null,
+        onStateChange: () => () => {},
+        notifyForeground: () => {},
+        close: () => {}
+      })
+      let client = clientFor()
+      const onError = vi.fn()
+      const message = {
+        sessionId: 'session',
+        sessionKey: 'remote-host:folder:session',
+        callerIdentity: 'phone',
+        expectedRuntimeFence: 3,
+        text: 'please continue',
+        attachments: [],
+        onError
+      }
+      const send = () => sendMobileStructuredAgentSessionMessage({ ...message, client })
+
+      expect(await send()).toBe('unknown')
+      if (relaunch) {
+        client = clientFor()
+      }
+      expect(await send()).toBe('accepted')
+      expect(delivered).toHaveLength(2)
+      expect(new Set(ids).size).toBe(2)
+      expect(onError).not.toHaveBeenCalled()
+      expect(storage.getItem).not.toHaveBeenCalled()
+      expect(storage.setItem).not.toHaveBeenCalled()
+    }
+  )
+})
diff --git a/mobile/src/session/mobile-structured-send-operation-journal.test.ts b/mobile/src/session/mobile-structured-send-operation-journal.test.ts
deleted file mode 100644
index 3c76e1d1c3fc..000000000000
--- a/mobile/src/session/mobile-structured-send-operation-journal.test.ts
+++ /dev/null
@@ -1,450 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { AGENT_SESSION_MAX_OPERATION_REPLAY_AGE_MS } from '../../../src/shared/agent-session-host-authority'
-import { AGENT_SESSION_DURABLE_OPERATION_GLOBAL_LIMIT } from '../../../src/shared/agent-session-operation-ledger'
-
-const asyncStorage = vi.hoisted(() => ({
-  getItem: vi.fn(),
-  setItem: vi.fn(),
-  removeItem: vi.fn()
-}))
-
-vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
-
-import {
-  clearMobileStructuredSendOperation,
-  clearMobileStructuredSettledSendOperations,
-  getOrCreateMobileStructuredSendOperation as getOrCreatePersistedOperation,
-  mobileStructuredSendCallerFingerprint,
-  mobileStructuredSendOperationKey,
-  resetMobileStructuredSendOperationJournalForTests
-} from './mobile-structured-send-operation-journal'
-import { readMirroredStorage } from '../storage/mirrored-storage-keys'
-
-const NOW = 1_900_000_000_000
-/** The key the journal persists under, which the hybrid shell mirrors into every `init`. */
-const JOURNAL_KEY = 'orca:mobileStructuredSendOperations:v1'
-const OPERATION_KEY = 'a'.repeat(64)
-const CALLER_IDENTITY = 'mobile-device-a'
-
-function getOrCreateMobileStructuredSendOperation(
-  input: Omit<
-    Parameters<typeof getOrCreatePersistedOperation>[0],
-    'callerIdentity' | 'payloadFingerprint' | 'attachmentPaths'
-  > & { payloadFingerprint?: string; attachmentPaths?: readonly string[] }
-) {
-  const { payloadFingerprint = 'b'.repeat(64), attachmentPaths = [], ...operation } = input
-  return getOrCreatePersistedOperation({
-    ...operation,
-    callerIdentity: CALLER_IDENTITY,
-    payloadFingerprint,
-    attachmentPaths
-  }).then(({ operationId, retained }) => ({ operationId, retained }))
-}
-
-function operationIdAt(timestamp: number, entropy: string): string {
-  return `${timestamp}-${entropy.repeat(32).slice(0, 32)}`
-}
-
-describe('mobile structured send operation journal', () => {
-  let values: Map<string, string>
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
-    values = new Map()
-    asyncStorage.getItem.mockImplementation(async (key: string) => values.get(key) ?? null)
-    asyncStorage.setItem.mockImplementation(async (key: string, value: string) => {
-      values.set(key, value)
-    })
-    asyncStorage.removeItem.mockImplementation(async (key: string) => {
-      values.delete(key)
-    })
-  })
-
-  it('persists an ambiguous id before dispatch and reuses it after remount', async () => {
-    const firstId = operationIdAt(NOW, '1')
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => firstId,
-        now: NOW
-      })
-    ).resolves.toEqual({ operationId: firstId, retained: false })
-
-    resetMobileStructuredSendOperationJournalForTests()
-    const createAfterRemount = vi.fn(() => operationIdAt(NOW, '2'))
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: createAfterRemount,
-        now: NOW
-      })
-    ).resolves.toEqual({ operationId: firstId, retained: true })
-    expect(createAfterRemount).not.toHaveBeenCalled()
-  })
-
-  /**
-   * A mirror the page reads is not allowed to run ahead of the store (round 4, CodeRabbit).
-   *
-   * The hybrid shell builds `init` from the mirror synchronously, so the page is handed whatever
-   * was noted here. Noting the write before it is persisted is what keeps an `init` in the same
-   * turn current; keeping the note after the persist was refused publishes a journal that does
-   * not exist, and the page resumes operations the device never wrote down.
-   */
-  it('rolls the mirror back when persisting an added entry fails', async () => {
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey: OPERATION_KEY,
-      createOperationId: () => operationIdAt(NOW, '8'),
-      now: NOW
-    })
-    const held = readMirroredStorage([JOURNAL_KEY])[JOURNAL_KEY]
-    asyncStorage.setItem.mockRejectedValueOnce(new Error('the store is full'))
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: 'c'.repeat(64),
-        createOperationId: () => operationIdAt(NOW, '9'),
-        now: NOW
-      })
-    ).rejects.toThrow('the store is full')
-    expect(readMirroredStorage([JOURNAL_KEY])[JOURNAL_KEY]).toBe(held)
-  })
-
-  it('rolls the mirror back when persisting the last clear fails', async () => {
-    const firstId = operationIdAt(NOW, 'a')
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey: OPERATION_KEY,
-      createOperationId: () => firstId,
-      now: NOW
-    })
-    const held = readMirroredStorage([JOURNAL_KEY])[JOURNAL_KEY]
-    asyncStorage.removeItem.mockRejectedValueOnce(new Error('the store is full'))
-    await expect(
-      clearMobileStructuredSendOperation({ operationKey: OPERATION_KEY, operationId: firstId })
-    ).rejects.toThrow('the store is full')
-    expect(readMirroredStorage([JOURNAL_KEY])[JOURNAL_KEY]).toBe(held)
-  })
-
-  it('clears only the exact settled operation', async () => {
-    const firstId = operationIdAt(NOW, '3')
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey: OPERATION_KEY,
-      createOperationId: () => firstId,
-      now: NOW
-    })
-
-    await expect(
-      clearMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        operationId: operationIdAt(NOW, '4')
-      })
-    ).rejects.toThrow('identity changed')
-    await clearMobileStructuredSendOperation({
-      operationKey: OPERATION_KEY,
-      operationId: firstId
-    })
-
-    const secondId = operationIdAt(NOW, '5')
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => secondId,
-        now: NOW
-      })
-    ).resolves.toEqual({ operationId: secondId, retained: false })
-  })
-
-  it('clears an ack-lost id only when its journal submission settles', async () => {
-    const sessionKey = 'host-a:session-a'
-    const payloadFingerprint = 'c'.repeat(64)
-    const operationKey = mobileStructuredSendOperationKey({
-      sessionKey,
-      intentFingerprint: payloadFingerprint
-    })
-    const operationId = operationIdAt(NOW, 'd')
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey,
-      payloadFingerprint,
-      createOperationId: () => operationId,
-      now: NOW
-    })
-    const submission = {
-      clientMessageId: operationId,
-      fence: 1,
-      payloadFingerprint,
-      dispatchState: 'unknown' as const,
-      providerItemId: null,
-      reason: 'ack lost',
-      submittedAt: NOW,
-      resolvedAt: NOW
-    }
-
-    await clearMobileStructuredSettledSendOperations({ submissions: [submission] })
-    expect(values.size).toBe(1)
-
-    await clearMobileStructuredSettledSendOperations({
-      submissions: [{ ...submission, dispatchState: 'accepted', reason: null }]
-    })
-    expect(values.size).toBe(0)
-  })
-
-  it("clears an id a draft hand-off names, whatever that hand-off's state", async () => {
-    const sessionKey = 'host-a:session-a'
-    const payloadFingerprint = '9'.repeat(64)
-    const operationKey = mobileStructuredSendOperationKey({
-      sessionKey,
-      intentFingerprint: payloadFingerprint
-    })
-    const operationId = operationIdAt(NOW, '7')
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey,
-      payloadFingerprint,
-      createOperationId: () => operationId,
-      now: NOW
-    })
-    // The drain handed the draft off under a fresh id; only the link names this send.
-    await clearMobileStructuredSettledSendOperations({
-      submissions: [
-        {
-          clientMessageId: operationIdAt(NOW + 1, '8'),
-          queuedMessageId: operationId,
-          fence: 1,
-          payloadFingerprint,
-          dispatchState: 'pending',
-          providerItemId: null,
-          reason: null,
-          submittedAt: NOW + 1,
-          resolvedAt: null
-        }
-      ]
-    })
-    expect(values.size).toBe(0)
-  })
-
-  it('does not clear a newer id for an older matching-payload submission', async () => {
-    const sessionKey = 'host-a:session-a'
-    const payloadFingerprint = 'e'.repeat(64)
-    const operationKey = mobileStructuredSendOperationKey({
-      sessionKey,
-      intentFingerprint: payloadFingerprint
-    })
-    const operationId = operationIdAt(NOW, 'f')
-    await getOrCreateMobileStructuredSendOperation({
-      operationKey,
-      payloadFingerprint,
-      createOperationId: () => operationId,
-      now: NOW
-    })
-
-    await clearMobileStructuredSettledSendOperations({
-      submissions: [
-        {
-          clientMessageId: operationIdAt(NOW - 1, '1'),
-          fence: 1,
-          payloadFingerprint,
-          dispatchState: 'accepted',
-          providerItemId: null,
-          reason: null,
-          submittedAt: NOW - 1,
-          resolvedAt: NOW - 1
-        }
-      ]
-    })
-
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey,
-        createOperationId: () => operationIdAt(NOW, '2'),
-        now: NOW
-      })
-    ).resolves.toEqual({ operationId, retained: true })
-  })
-
-  it('reuses the original attachment paths for an ambiguous repeat upload', async () => {
-    const operationId = operationIdAt(NOW, 'e')
-    const payloadFingerprint = 'd'.repeat(64)
-    await getOrCreatePersistedOperation({
-      operationKey: OPERATION_KEY,
-      callerIdentity: CALLER_IDENTITY,
-      payloadFingerprint,
-      attachmentPaths: ['/tmp/original.png'],
-      createOperationId: () => operationId,
-      now: NOW
-    })
-
-    await expect(
-      getOrCreatePersistedOperation({
-        operationKey: OPERATION_KEY,
-        callerIdentity: CALLER_IDENTITY,
-        payloadFingerprint: 'e'.repeat(64),
-        attachmentPaths: ['/tmp/reuploaded.png'],
-        createOperationId: () => operationIdAt(NOW, 'f'),
-        now: NOW
-      })
-    ).resolves.toEqual({
-      operationKey: OPERATION_KEY,
-      operationId,
-      retained: true,
-      payloadFingerprint,
-      attachmentPaths: ['/tmp/original.png']
-    })
-  })
-
-  it('replays an entry retained under the alternate key, and says which key matched', async () => {
-    const operationId = operationIdAt(NOW, 'e')
-    const alternateKey = 'b'.repeat(64)
-    await getOrCreatePersistedOperation({
-      operationKey: alternateKey,
-      callerIdentity: CALLER_IDENTITY,
-      payloadFingerprint: 'd'.repeat(64),
-      attachmentPaths: [],
-      createOperationId: () => operationId,
-      now: NOW
-    })
-    await expect(
-      getOrCreatePersistedOperation({
-        operationKey: OPERATION_KEY,
-        alternateOperationKey: alternateKey,
-        callerIdentity: CALLER_IDENTITY,
-        payloadFingerprint: 'd'.repeat(64),
-        attachmentPaths: [],
-        createOperationId: () => operationIdAt(NOW, 'f'),
-        now: NOW
-      })
-    ).resolves.toMatchObject({ operationKey: alternateKey, operationId, retained: true })
-  })
-
-  it('keeps an ambiguous id after the host replay window closes', async () => {
-    const expired = operationIdAt(NOW - AGENT_SESSION_MAX_OPERATION_REPLAY_AGE_MS - 1, '6')
-    asyncStorage.getItem.mockResolvedValueOnce(
-      JSON.stringify({
-        v: 1,
-        entries: [
-          {
-            operationKey: OPERATION_KEY,
-            operationId: expired,
-            callerFingerprint: mobileStructuredSendCallerFingerprint(CALLER_IDENTITY),
-            payloadFingerprint: 'b'.repeat(64),
-            attachmentPaths: []
-          }
-        ]
-      })
-    )
-
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => operationIdAt(NOW, '7'),
-        now: NOW
-      })
-    ).resolves.toEqual({ operationId: expired, retained: true })
-  })
-
-  it('fails closed when a retained operation id is malformed', async () => {
-    asyncStorage.getItem.mockResolvedValueOnce(
-      JSON.stringify({
-        v: 1,
-        entries: [
-          {
-            operationKey: OPERATION_KEY,
-            operationId: 'not-an-operation-id',
-            callerFingerprint: mobileStructuredSendCallerFingerprint(CALLER_IDENTITY),
-            payloadFingerprint: 'b'.repeat(64),
-            attachmentPaths: []
-          }
-        ]
-      })
-    )
-
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => operationIdAt(NOW, '8'),
-        now: NOW
-      })
-    ).rejects.toThrow('unreadable')
-  })
-
-  it('fails closed when durable identity cannot be read or written', async () => {
-    asyncStorage.getItem.mockRejectedValueOnce(new Error('storage unavailable'))
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => operationIdAt(NOW, '9'),
-        now: NOW
-      })
-    ).rejects.toThrow('storage unavailable')
-
-    asyncStorage.setItem.mockRejectedValueOnce(new Error('disk full'))
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => operationIdAt(NOW, 'a'),
-        now: NOW
-      })
-    ).rejects.toThrow('disk full')
-    expect(values.size).toBe(0)
-  })
-
-  it('refuses new sends rather than evicting an ambiguous id at capacity', async () => {
-    asyncStorage.getItem.mockResolvedValueOnce(
-      JSON.stringify({
-        v: 1,
-        entries: Array.from(
-          { length: AGENT_SESSION_DURABLE_OPERATION_GLOBAL_LIMIT },
-          (_, index) => ({
-            operationKey: index.toString(16).padStart(64, '0'),
-            operationId: operationIdAt(NOW, index.toString(16).padStart(32, '0')),
-            callerFingerprint: mobileStructuredSendCallerFingerprint(CALLER_IDENTITY),
-            payloadFingerprint: 'b'.repeat(64),
-            attachmentPaths: []
-          })
-        )
-      })
-    )
-
-    await expect(
-      getOrCreateMobileStructuredSendOperation({
-        operationKey: OPERATION_KEY,
-        createOperationId: () => operationIdAt(NOW, 'b'),
-        now: NOW
-      })
-    ).rejects.toThrow('journal is full')
-  })
-
-  it('hashes the session scope and payload instead of retaining message bodies', () => {
-    const first = mobileStructuredSendOperationKey({
-      sessionKey: 'host-a:session-a',
-      intentFingerprint: 'message-body-fingerprint'
-    })
-    const second = mobileStructuredSendOperationKey({
-      sessionKey: 'host-b:session-a',
-      intentFingerprint: 'message-body-fingerprint'
-    })
-
-    expect(first).toMatch(/^[0-9a-f]{64}$/)
-    expect(second).not.toBe(first)
-    expect(first).not.toContain('message-body')
-  })
-
-  it('fails closed when a retained id crosses authenticated caller identities', async () => {
-    await getOrCreatePersistedOperation({
-      operationKey: OPERATION_KEY,
-      callerIdentity: 'mobile-device-before-repair',
-      payloadFingerprint: 'b'.repeat(64),
-      attachmentPaths: [],
-      createOperationId: () => operationIdAt(NOW, '3'),
-      now: NOW
-    })
-
-    await expect(
-      getOrCreatePersistedOperation({
-        operationKey: OPERATION_KEY,
-        callerIdentity: 'mobile-device-after-repair',
-        payloadFingerprint: 'b'.repeat(64),
-        attachmentPaths: [],
-        createOperationId: () => operationIdAt(NOW, '4'),
-        now: NOW
-      })
-    ).rejects.toThrow('caller identity changed')
-  })
-})
diff --git a/mobile/src/session/mobile-structured-send-operation-journal.ts b/mobile/src/session/mobile-structured-send-operation-journal.ts
deleted file mode 100644
index 98937ad1bbbb..000000000000
--- a/mobile/src/session/mobile-structured-send-operation-journal.ts
+++ /dev/null
@@ -1,281 +0,0 @@
-import AsyncStorage from '@react-native-async-storage/async-storage'
-import { z } from 'zod'
-import { persistMirrored } from '../storage/mirrored-storage-keys'
-import type { AgentJournalSubmission } from '../../../src/shared/agent-session-journal-types'
-import {
-  AGENT_SESSION_MAX_NEW_OPERATION_AGE_MS,
-  AGENT_SESSION_OPERATION_FUTURE_SKEW_MS,
-  parseAgentSessionOperationTimestamp
-} from '../../../src/shared/agent-session-host-authority'
-import { AGENT_SESSION_DURABLE_OPERATION_GLOBAL_LIMIT } from '../../../src/shared/agent-session-operation-ledger'
-import { structuredAgentSessionDomainFingerprint } from '../../../src/shared/structured-agent-session-mutation'
-
-const STORAGE_KEY = 'orca:mobileStructuredSendOperations:v1'
-const OperationEntrySchema = z
-  .object({
-    operationKey: z.string().regex(/^[0-9a-f]{64}$/),
-    operationId: z.string().max(128),
-    callerFingerprint: z.string().regex(/^[0-9a-f]{64}$/),
-    payloadFingerprint: z.string().regex(/^[0-9a-f]{64}$/),
-    attachmentPaths: z.array(z.string().max(4096)).max(128)
-  })
-  .strict()
-const OperationJournalSchema = z
-  .object({
-    v: z.literal(1),
-    entries: z.array(OperationEntrySchema).max(AGENT_SESSION_DURABLE_OPERATION_GLOBAL_LIMIT)
-  })
-  .strict()
-
-type OperationEntry = z.infer<typeof OperationEntrySchema>
-type OperationJournal = z.infer<typeof OperationJournalSchema>
-
-const mutations: { tail: Promise<void> } = { tail: Promise.resolve() }
-
-export function mobileStructuredSendOperationKey(input: {
-  sessionKey: string
-  intentFingerprint: string
-}): string {
-  return structuredAgentSessionDomainFingerprint({
-    domain: 'mobile.agentSession.send.operation',
-    sessionId: input.sessionKey,
-    fields: { intentFingerprint: input.intentFingerprint }
-  })
-}
-
-export function mobileStructuredSendCallerFingerprint(callerIdentity: string): string {
-  return structuredAgentSessionDomainFingerprint({
-    domain: 'mobile.agentSession.send.caller',
-    sessionId: callerIdentity,
-    fields: {}
-  })
-}
-
-function newOperationIdIsAdmissible(operationId: string, now: number): boolean {
-  const timestamp = parseAgentSessionOperationTimestamp(operationId)
-  return (
-    timestamp !== null &&
-    timestamp <= now + AGENT_SESSION_OPERATION_FUTURE_SKEW_MS &&
-    now - timestamp <= AGENT_SESSION_MAX_NEW_OPERATION_AGE_MS
-  )
-}
-
-function parseJournal(raw: string | null): OperationJournal {
-  if (raw === null) {
-    return { v: 1, entries: [] }
-  }
-  let value: unknown
-  try {
-    value = JSON.parse(raw)
-  } catch {
-    throw new Error('Structured send operation journal is unreadable')
-  }
-  const parsed = OperationJournalSchema.safeParse(value)
-  if (!parsed.success) {
-    throw new Error('Structured send operation journal is unreadable')
-  }
-  if (
-    new Set(parsed.data.entries.map((entry) => entry.operationKey)).size !==
-      parsed.data.entries.length ||
-    parsed.data.entries.some(
-      (entry) => parseAgentSessionOperationTimestamp(entry.operationId) === null
-    )
-  ) {
-    throw new Error('Structured send operation journal is unreadable')
-  }
-  return parsed.data
-}
-
-async function writeEntries(entries: OperationEntry[]): Promise<void> {
-  // Through the one write path, which notes the mirror on an accepted write and on nothing else
-  // (ruling 35). The rejection this can raise is the point of the key: a journal the device never
-  // wrote must not reach the page, and the composer above catches it as "Message not sent".
-  await persistMirrored(
-    STORAGE_KEY,
-    entries.length === 0 ? null : JSON.stringify({ v: 1, entries })
-  )
-}
-
-async function serialize<T>(action: () => Promise<T>): Promise<T> {
-  const operation = mutations.tail.then(action, action)
-  mutations.tail = operation.then(
-    () => undefined,
-    () => undefined
-  )
-  return operation
-}
-
-export async function getOrCreateMobileStructuredSendOperation(input: {
-  operationKey: string
-  /** The same intent under its other delivery: a retained entry there is replayed
-   *  as-is, so the key that matched — never a stored field — says how it was sent. */
-  alternateOperationKey?: string
-  callerIdentity: string
-  payloadFingerprint: string
-  attachmentPaths: readonly string[]
-  createOperationId: () => string
-  now?: number
-}): Promise<{
-  operationKey: string
-  operationId: string
-  retained: boolean
-  payloadFingerprint: string
-  attachmentPaths: string[]
-}> {
-  return serialize(async () => {
-    const now = input.now ?? Date.now()
-    const callerFingerprint = mobileStructuredSendCallerFingerprint(input.callerIdentity)
-    const journal = parseJournal(await AsyncStorage.getItem(STORAGE_KEY))
-    const entries = journal.entries
-    const existing =
-      entries.find((entry) => entry.operationKey === input.operationKey) ??
-      entries.find(
-        (entry) =>
-          input.alternateOperationKey !== undefined &&
-          entry.operationKey === input.alternateOperationKey
-      )
-    if (existing) {
-      if (existing.callerFingerprint !== callerFingerprint) {
-        throw new Error('Structured send caller identity changed')
-      }
-      return {
-        operationKey: existing.operationKey,
-        operationId: existing.operationId,
-        retained: true,
-        payloadFingerprint: existing.payloadFingerprint,
-        attachmentPaths: [...existing.attachmentPaths]
-      }
-    }
-    // Ambiguity has no TTL. At the fixed capacity, refusing a new send is safer
-    // than evicting an id whose message may already be in provider context.
-    if (entries.length >= AGENT_SESSION_DURABLE_OPERATION_GLOBAL_LIMIT) {
-      throw new Error('Structured send operation journal is full')
-    }
-    const operationId = input.createOperationId()
-    if (!newOperationIdIsAdmissible(operationId, now)) {
-      throw new Error('Structured send operation id is invalid')
-    }
-    const entry = OperationEntrySchema.parse({
-      operationKey: input.operationKey,
-      operationId,
-      callerFingerprint,
-      payloadFingerprint: input.payloadFingerprint,
-      attachmentPaths: [...input.attachmentPaths]
-    })
-    await writeEntries([...entries, entry])
-    return {
-      operationKey: input.operationKey,
-      operationId,
-      retained: false,
-      payloadFingerprint: input.payloadFingerprint,
-      attachmentPaths: [...input.attachmentPaths]
-    }
-  })
-}
-
-export async function clearMobileStructuredSendOperation(input: {
-  operationKey: string
-  operationId: string
-}): Promise<void> {
-  return serialize(async () => {
-    const journal = parseJournal(await AsyncStorage.getItem(STORAGE_KEY))
-    const entries = journal.entries
-    const existing = entries.find((entry) => entry.operationKey === input.operationKey)
-    if (!existing) {
-      return
-    }
-    if (existing.operationId !== input.operationId) {
-      throw new Error('Structured send operation identity changed')
-    }
-    await writeEntries(entries.filter((entry) => entry !== existing))
-  })
-}
-
-/** Reconcile an ack-lost operation once the authoritative journal settles it, or hands it off:
- *  a submission naming the operation's id as its `queuedMessageId` is that send's queued draft
- *  going out, in whatever state, so the send reached the host and its id is spent. */
-export async function clearMobileStructuredSettledSendOperations(input: {
-  submissions: readonly AgentJournalSubmission[]
-}): Promise<void> {
-  const settled = new Set(
-    input.submissions.flatMap((submission) =>
-      submission.dispatchState === 'accepted' || submission.dispatchState === 'rejected'
-        ? [`${submission.payloadFingerprint}\u0000${submission.clientMessageId}`]
-        : []
-    )
-  )
-  const handedOff = new Set(
-    input.submissions.flatMap((submission) =>
-      submission.queuedMessageId !== undefined ? [submission.queuedMessageId] : []
-    )
-  )
-  if (settled.size === 0 && handedOff.size === 0) {
-    return
-  }
-  return serialize(async () => {
-    const journal = parseJournal(await AsyncStorage.getItem(STORAGE_KEY))
-    const entries = journal.entries.filter(
-      (entry) =>
-        !settled.has(`${entry.payloadFingerprint}\u0000${entry.operationId}`) &&
-        !handedOff.has(entry.operationId)
-    )
-    if (entries.length !== journal.entries.length) {
-      await writeEntries(entries)
-    }
-  })
-}
-
-/**
- * Spend the ids the host publishes as queued drafts. A draft is named by the
- * operation id of the send that created it, so seeing one is the host's own
- * receipt of that send — the `queued` answer a lost acknowledgement never
- * brought. Without this, a draft another device later withdraws leaves an entry
- * that no submission will ever settle.
- */
-export async function clearMobileStructuredQueuedSendOperations(input: {
-  queuedMessageIds: readonly string[]
-}): Promise<void> {
-  if (input.queuedMessageIds.length === 0) {
-    return
-  }
-  const held = new Set(input.queuedMessageIds)
-  return serialize(async () => {
-    const journal = parseJournal(await AsyncStorage.getItem(STORAGE_KEY))
-    const entries = journal.entries.filter((entry) => !held.has(entry.operationId))
-    if (entries.length !== journal.entries.length) {
-      await writeEntries(entries)
-    }
-  })
-}
-
-/** Ids sent past a saved record storage would not clear, keyed by the operation key that record
- *  matched, for this app run only: a retry of that text replays the same id instead of minting
- *  another, which could deliver it twice. An entry dies at app restart, when the host answers the
- *  id as spent, or when a saved record takes the id over; a replay the host keeps keeps it. */
-const bypassedOperationIds = new Map<string, string>()
-
-export function bypassedMobileStructuredSendOperationId(operationKey: string): string | undefined {
-  return bypassedOperationIds.get(operationKey)
-}
-
-export function rememberBypassedMobileStructuredSendOperation(
-  operationKey: string,
-  operationId: string
-): void {
-  bypassedOperationIds.set(operationKey, operationId)
-}
-
-export function forgetBypassedMobileStructuredSendOperation(
-  operationKey: string,
-  operationId: string
-): void {
-  if (bypassedOperationIds.get(operationKey) === operationId) {
-    bypassedOperationIds.delete(operationKey)
-  }
-}
-
-/** Test-only: drain in-memory serialization and bypassed ids while preserving durable storage. */
-export function resetMobileStructuredSendOperationJournalForTests(): void {
-  mutations.tail = Promise.resolve()
-  bypassedOperationIds.clear()
-}
diff --git a/mobile/src/session/mobile-structured-send-page-storage-refusal.test.ts b/mobile/src/session/mobile-structured-send-page-storage-refusal.test.ts
deleted file mode 100644
index b33d992ddb23..000000000000
--- a/mobile/src/session/mobile-structured-send-page-storage-refusal.test.ts
+++ /dev/null
@@ -1,143 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-/**
- * The page's own AsyncStorage under the durable send journal, which is the one allowlisted value
- * that outgrows what the bridge will carry.
- *
- * Measured on this tree: a journal entry with no attachment costs 343 characters in the array —
- * 342 of its own plus the comma that joins it — and the schema admits 4,096 of them, so 47
- * unsettled sends measure 16,140 and 48 measure 16,483, past `PAGE_STORAGE_MAX_VALUE_CHARS`. Every
- * page write goes through `page-async-storage`, which the
- * bundler aliases over the real module, so this is the module the journal actually writes to
- * inside the page — and the reason the refusal must be a rejection rather than a dropped write.
- *
- * What a resolved refusal would cost, which is more than a lost preference: the journal would
- * answer with an operation id no store holds, the mutation would go out carrying it, and a retry
- * after a crash would send the same message again. Ruling 7's "nothing silently no-ops", at the
- * one key where silence is a duplicate message rather than a default.
- *
- * The other half of the chain — that the rejection reaches the composer as "Message not sent" — is
- * in `use-mobile-structured-agent-session-send.test.tsx`, which already drives the real send with
- * a client double; asserting it here would mean building a second one.
- */
-vi.mock('@react-native-async-storage/async-storage', async () => ({
-  default: (await import('../mobile-web-shell/bridge/page-async-storage')).default
-}))
-
-const { publishPageStorage } = await import('../mobile-web-shell/bridge/page-async-storage')
-const { PAGE_STORAGE_MAX_VALUE_CHARS, pageStorageEntriesForInit } =
-  await import('../mobile-web-shell/page-storage-keys')
-const {
-  getOrCreateMobileStructuredSendOperation,
-  resetMobileStructuredSendOperationJournalForTests
-} = await import('./mobile-structured-send-operation-journal')
-
-const HOST_ID = 'host-1'
-const SESSION_ROUTE = '/h/host-1/session/wt-1'
-const JOURNAL = 'orca:mobileStructuredSendOperations:v1'
-
-const hex = (fill: string) => fill.repeat(64)
-
-/**
- * A journal the module itself reads back, built past the cap out of real entries rather than
- * filler: a value the parser refuses reads as "unreadable" and never reaches the write at all.
- * `ENTRIES_OVER_THE_CAP` is the measured number — one entry costs 343 characters in the array.
- */
-const ENTRIES_OVER_THE_CAP = 48
-
-function storedJournal(count: number): string {
-  return JSON.stringify({
-    v: 1,
-    entries: Array.from({ length: count }, (_, index) => ({
-      operationKey: index.toString(16).padStart(64, '0'),
-      operationId: `17584320${String(index).padStart(5, '0')}-${'b'.repeat(32)}`,
-      callerFingerprint: hex('c'),
-      payloadFingerprint: hex('d'),
-      attachmentPaths: []
-    }))
-  })
-}
-
-const posted: { key: string; value: string | null }[] = []
-
-/**
- * The page seated the way the shell seats it, rather than from a hand-written record.
- *
- * `pageStorageEntriesForInit` is the split the shell runs before `init` is built, so driving the
- * page through it is what makes these states ones production can reach: a journal over the cap
- * never arrives as a value, it arrives as a name on the oversize list.
- */
-function publishAsTheShellWould(held: Record<string, string>): void {
-  posted.length = 0
-  const { entries, oversize } = pageStorageEntriesForInit(held)
-  publishPageStorage(
-    entries,
-    (key, value) => {
-      posted.push({ key, value })
-      return true
-    },
-    HOST_ID,
-    SESSION_ROUTE,
-    oversize
-  )
-}
-
-function publish(entries: Record<string, string>): void {
-  publishAsTheShellWould(entries)
-}
-
-function claim() {
-  return getOrCreateMobileStructuredSendOperation({
-    operationKey: hex('a'),
-    callerIdentity: 'caller-1',
-    payloadFingerprint: hex('d'),
-    attachmentPaths: [],
-    createOperationId: () => `${String(Date.now())}-${hex('b').slice(0, 32)}`
-  })
-}
-
-beforeEach(() => {
-  resetMobileStructuredSendOperationJournalForTests()
-  publish({})
-})
-
-describe('the durable send journal against the page store', () => {
-  it('rejects the send that would take the journal past what the page may write', async () => {
-    // The real precondition, seated through the shell's own split: 47 entries fit, so `init`
-    // carries them and the page holds a journal it can read. The 48th is the one that does not.
-    const held = storedJournal(ENTRIES_OVER_THE_CAP - 1)
-    expect(held.length).toBeLessThanOrEqual(PAGE_STORAGE_MAX_VALUE_CHARS)
-    expect(storedJournal(ENTRIES_OVER_THE_CAP).length).toBeGreaterThan(PAGE_STORAGE_MAX_VALUE_CHARS)
-    publishAsTheShellWould({ [JOURNAL]: held })
-    await expect(claim()).rejects.toThrow(/could not save/)
-    // Nothing posted either: the value the wire would have dropped never left the page.
-    expect(posted).toEqual([])
-  })
-
-  /**
-   * The destructive one (ruling 33.6).
-   *
-   * A native journal past the cap is dropped from `init` for size, and the key stays in
-   * `pageStorageKeysForRoute`. Without the oversize list the page reads `null`, `parseJournal`
-   * answers an empty journal, and the first send writes a one-entry value over the device's — the
-   * native entries gone and a fresh `operationId` for an operation native already holds, which is
-   * the duplicate send ruling 7 exists to prevent.
-   */
-  it('refuses a send when init could not carry the journal, instead of replacing it', async () => {
-    const held = storedJournal(ENTRIES_OVER_THE_CAP)
-    const { entries, oversize } = pageStorageEntriesForInit({ [JOURNAL]: held })
-    // The precondition itself: the shell hands no value for this key and names it instead.
-    expect(entries).toEqual({})
-    expect(oversize).toEqual([JOURNAL])
-    publishAsTheShellWould({ [JOURNAL]: held })
-    await expect(claim()).rejects.toThrow(/could not save/)
-    // The half that makes it destructive: nothing was posted, so the native journal is untouched.
-    expect(posted).toEqual([])
-  })
-
-  it('claims an id when the journal fits, so the refusal above is the size and not the path', async () => {
-    publish({})
-    await expect(claim()).resolves.toEqual(expect.objectContaining({ retained: false }))
-    expect(posted.map((write) => write.key)).toEqual([JOURNAL])
-  })
-})
diff --git a/mobile/src/session/use-mobile-native-chat-controller.ts b/mobile/src/session/use-mobile-native-chat-controller.ts
index c294c28c4202..7e0c29ecb1ea 100644
--- a/mobile/src/session/use-mobile-native-chat-controller.ts
+++ b/mobile/src/session/use-mobile-native-chat-controller.ts
@@ -97,7 +97,6 @@ export function useMobileNativeChatController(args: {
       transcriptPath: activeChatResolution?.transcriptPath ?? null,
       sessionId: activeChatSessionId,
       sourceIdentity,
-      callerIdentity: deviceTokenRef.current ?? '',
       enabled: showNativeChat,
       connState,
       hostSupport: agentSessionHostSupport,
diff --git a/mobile/src/session/use-mobile-native-chat-image-attachments.test.ts b/mobile/src/session/use-mobile-native-chat-image-attachments.test.ts
index d1ed7b9b77f1..8f1e59bd0cfc 100644
--- a/mobile/src/session/use-mobile-native-chat-image-attachments.test.ts
+++ b/mobile/src/session/use-mobile-native-chat-image-attachments.test.ts
@@ -126,8 +126,7 @@ describe('useMobileNativeChatImageAttachments', () => {
       {
         id: 'img-1',
         path: '/tmp/a.png',
-        previewUri: 'file:///a.jpg',
-        contentFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/)
+        previewUri: 'file:///a.jpg'
       }
     ])
     expect(client.calls.some((c) => c.method === 'terminal.send')).toBe(false)
diff --git a/mobile/src/session/use-mobile-native-chat-image-upload.ts b/mobile/src/session/use-mobile-native-chat-image-upload.ts
index dda58854792b..7cd1a865567b 100644
--- a/mobile/src/session/use-mobile-native-chat-image-upload.ts
+++ b/mobile/src/session/use-mobile-native-chat-image-upload.ts
@@ -3,7 +3,6 @@ import { CLIPBOARD_IMAGE_TOO_LARGE_ERROR } from '../../../src/shared/clipboard-i
 import type { RpcClient } from '../transport/rpc-client'
 import type { ConnectionState } from '../transport/types'
 import { useMediaPicker } from '../platform/media-picker'
-import { fingerprintNativeChatImage } from '../platform/native-chat-image-fingerprint'
 import {
   ImageLibraryPermissionError,
   type MobileImageSource
@@ -71,7 +70,6 @@ export function useMobileNativeChatImageUpload(args: {
           client,
           getConnectionId: getActiveWorktreeConnectionId,
           pickImages: picker.pickImages,
-          fingerprintImage: fingerprintNativeChatImage,
           onImageUploaded: (image) => uploadedImages.push(image),
           onUploadStart: () => {
             started = true
diff --git a/mobile/src/session/use-mobile-native-chat-session-lane.ts b/mobile/src/session/use-mobile-native-chat-session-lane.ts
index c34f1995190c..15f68f0758b3 100644
--- a/mobile/src/session/use-mobile-native-chat-session-lane.ts
+++ b/mobile/src/session/use-mobile-native-chat-session-lane.ts
@@ -16,7 +16,6 @@ export function useMobileNativeChatSessionLane({
   transcriptPath,
   sessionId,
   sourceIdentity,
-  callerIdentity,
   hostSupport,
   appendComposerTextRef,
   enabled,
@@ -33,7 +32,6 @@ export function useMobileNativeChatSessionLane({
   transcriptPath: string | null
   sessionId: string | null
   sourceIdentity: Parameters<typeof useMobileNativeChatSession>[0]['sourceIdentity']
-  callerIdentity: string
   hostSupport: StructuredAgentSessionHostSupport | null
   /** The active pane's live composer; a queued card's Edit copies through it.
    *  A ref because the drafts (and their append) mount after this lane. */
@@ -62,7 +60,6 @@ export function useMobileNativeChatSessionLane({
     client,
     sessionId: structured ? sessionId : null,
     sourceIdentity,
-    callerIdentity,
     hostSupport,
     appendComposerText,
     enabled,
diff --git a/mobile/src/session/use-mobile-session-image-attachments.ts b/mobile/src/session/use-mobile-session-image-attachments.ts
index 92a2b52c844d..ec53d196a4c5 100644
--- a/mobile/src/session/use-mobile-session-image-attachments.ts
+++ b/mobile/src/session/use-mobile-session-image-attachments.ts
@@ -35,7 +35,6 @@ type Args = {
       id: string
       path: string
       previewUri: string
-      contentFingerprint?: string
     }[]
   ) => Promise<MobileNativeChatSendOutcome>
   /** Structured agent sessions do not have a terminal paste path. */
diff --git a/mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx
index 9bfd272cc50a..aef38e82e6e9 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-background-tasks.test.tsx
@@ -8,7 +8,6 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { AgentChildWorkView } from '../../../src/shared/agent-status-child-work-view'
 import type { AgentSessionSubscribeEvent } from '../../../src/shared/agent-session-wire'
 import type { RpcClient } from '../transport/rpc-client'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
 import {
   backgroundTaskRowMeta,
   buildBackgroundTaskGroupsFromViews
@@ -102,7 +101,7 @@ describe('mobile structured session background tasks', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
+
     sendRequest.mockImplementation(async (method) =>
       method === 'agentSession.cancel'
         ? mutationOk({})
diff --git a/mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx
index 9ed32c49579d..2d7e8f07462c 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-newer-approval-send.test.tsx
@@ -7,7 +7,6 @@ import { act, create, type ReactTestRenderer } from 'react-test-renderer'
 import { afterEach, beforeEach, expect, it, vi } from 'vitest'
 import type { AgentJournalRenderItem } from '../../../src/shared/agent-session-journal-types'
 import type { RpcClient } from '../transport/rpc-client'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
 import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
 import {
   CAPABLE,
@@ -98,7 +97,7 @@ async function sentDelivery(items: AgentJournalRenderItem[]): Promise<unknown> {
 
 beforeEach(() => {
   vi.clearAllMocks()
-  resetMobileStructuredSendOperationJournalForTests()
+
   sendRequest.mockImplementation(async (method) =>
     method === 'agentSession.send'
       ? mutationOk({ clientMessageId: 'client-1' })
diff --git a/mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx
index 4c419108c7c1..328a1effdd30 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-prompt-cancel.test.tsx
@@ -34,9 +34,6 @@ vi.mock('./use-mobile-structured-agent-options', () => ({
 vi.mock('./use-mobile-structured-prompt-responses', () => ({
   useMobileStructuredPromptResponses: mocks.promptResponses
 }))
-vi.mock('./use-mobile-structured-send-operation-reconciliation', () => ({
-  useMobileStructuredSendOperationReconciliation: vi.fn()
-}))
 
 import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
 
diff --git a/mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx
index ceaee501b650..0268fece2c65 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx
@@ -15,7 +15,6 @@ import type { AgentSessionSubscribeEvent } from '../../../src/shared/agent-sessi
 import type { RpcClient } from '../transport/rpc-client'
 import type { RpcResponse } from '../transport/types'
 import { markRpcDeliveryUnknown } from '../transport/rpc-delivery-ambiguity'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
 import type { StructuredAgentSessionHostSupport } from './mobile-structured-agent-session-host-support'
 import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
 import {
@@ -124,7 +123,7 @@ describe('mobile structured queued messages', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
+
     stored = new Map()
     asyncStorage.getItem.mockImplementation(async (key: string) => stored.get(key) ?? null)
     asyncStorage.setItem.mockImplementation(async (key: string, value: string) => {
@@ -167,10 +166,7 @@ describe('mobile structured queued messages', () => {
           fields: { body: params.body, delivery: 'queue-if-active' }
         })
       )
-      // Spent at `queued`: the durable send-operation entry is released.
-      await vi.waitFor(() =>
-        expect(stored.has('orca:mobileStructuredSendOperations:v1')).toBe(false)
-      )
+      expect(asyncStorage.setItem).not.toHaveBeenCalled()
     })
 
     it('keeps today’s request exactly against an incapable host', async () => {
@@ -207,317 +203,61 @@ describe('mobile structured queued messages', () => {
       )
     })
 
-    it('replays an ack-lost delivery send under one id and the delivery it was sent with', async () => {
+    it('a new send follows the current host capability after acknowledgement loss', async () => {
       let attempts = 0
-      sendRequest.mockImplementation(async (method) => {
-        if (method === 'agentSession.send') {
-          attempts += 1
+      sendRequest.mockImplementation(async (method, params) => {
+        if (method !== 'agentSession.send') {
+          return ok({ models: [], current: {} })
+        }
+        if (++attempts === 1) {
           throw markRpcDeliveryUnknown(new Error('Connection closed'))
         }
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+        const id = String(fieldsOf(fieldsOf(params).envelope).clientOperationId)
+        return mutationOk({ clientMessageId: id, submission: acceptedSubmission(id) })
       })
       await mountSession(CAPABLE)
       await act(async () => {
-        expect(await hook!.sendWithOutcome('retry me')).toBe('unknown')
+        expect(await hook!.sendWithOutcome('again')).toBe('unknown')
       })
       unmountSession()
-      // The capability probe has not answered after the reload, but the recorded
-      // operation must replay bit-for-bit — content-derived key, same id, same
-      // delivery field — or the host would refuse it as a fingerprint conflict.
       await mountSession(LEGACY)
       await act(async () => {
-        expect(await hook!.sendWithOutcome('retry me')).toBe('unknown')
+        expect(await hook!.sendWithOutcome('again')).toBe('accepted')
       })
-      expect(attempts).toBe(2)
       const first = requestOf('agentSession.send', 0)
       const second = requestOf('agentSession.send', 1)
-      expect(second.params.delivery).toBe('queue-if-active')
-      expect(second.envelope.clientOperationId).toBe(first.envelope.clientOperationId)
-      // Nothing new is persisted: an older build still reads the send journal.
-      const journal = stored.get('orca:mobileStructuredSendOperations:v1') ?? ''
-      expect(journal).not.toContain('delivery')
-    })
-
-    it('retires an ack-lost delivery send an older host refuses, so the next send goes out plain', async () => {
-      const journalKey = 'orca:mobileStructuredSendOperations:v1'
-      let attempts = 0
-      sendRequest.mockImplementation(async (method, params) => {
-        if (method === 'agentSession.send') {
-          attempts += 1
-          if (attempts <= 2) {
-            throw markRpcDeliveryUnknown(new Error('Connection closed'))
-          }
-          // The downgraded host's strict schema turns `delivery` away before running anything.
-          if ('delivery' in fieldsOf(params)) {
-            return {
-              id: 'request-1',
-              ok: false,
-              error: { code: 'invalid_argument', message: 'Unrecognized key: "delivery"' }
-            }
-          }
-          return mutationOk({
-            clientMessageId: 'client-plain',
-            submission: {
-              clientMessageId: 'client-plain',
-              fence: 3,
-              payloadFingerprint: 'fp',
-              dispatchState: 'accepted',
-              providerItemId: null,
-              reason: null,
-              submittedAt: 10,
-              resolvedAt: 10
-            }
-          })
-        }
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      })
-      await mountSession(CAPABLE)
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('downgraded')).toBe('unknown')
-      })
-      unmountSession()
-      await mountSession(LEGACY)
-      // A lost answer is still doubt: the replay keeps the id and its delivery.
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('downgraded')).toBe('unknown')
-      })
-      const first = requestOf('agentSession.send', 0)
-      expect(requestOf('agentSession.send', 1).envelope.clientOperationId).toBe(
-        first.envelope.clientOperationId
-      )
-      expect(stored.get(journalKey)).toContain(String(first.envelope.clientOperationId))
-      // The host answering that it cannot take the request retires the entry, once.
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('downgraded')).toBe('rejected')
-      })
-      const refused = requestOf('agentSession.send', 2)
-      expect(refused.params.delivery).toBe('queue-if-active')
-      expect(refused.envelope.clientOperationId).toBe(first.envelope.clientOperationId)
-      expect(onSendError).toHaveBeenCalledTimes(1)
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('downgraded')).toBe('accepted')
-      })
-      const plain = requestOf('agentSession.send', 3)
-      expect('delivery' in plain.params).toBe(false)
-      expect(plain.envelope.clientOperationId).not.toBe(first.envelope.clientOperationId)
-      expect(attempts).toBe(4)
-    })
-
-    it('keeps an ack-lost send when the host refuses its replay as unauthorized', async () => {
-      let attempts = 0
-      sendRequest.mockImplementation(async (method) => {
-        if (method === 'agentSession.send') {
-          attempts += 1
-          if (attempts === 1) {
-            throw markRpcDeliveryUnknown(new Error('Connection closed'))
-          }
-          // An auth refusal says nothing about whether the first attempt was delivered.
-          return {
-            id: 'request-1',
-            ok: false,
-            error: { code: 'unauthorized', message: 'Pairing revoked' }
-          }
-        }
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      })
-      await mountSession(CAPABLE)
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('in doubt')).toBe('unknown')
-      })
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('in doubt')).toBe('rejected')
-      })
-      await act(async () => {
-        await hook!.sendWithOutcome('in doubt')
-      })
-      const first = requestOf('agentSession.send', 0)
-      expect(requestOf('agentSession.send', 2).envelope.clientOperationId).toBe(
-        first.envelope.clientOperationId
-      )
+      expect(first.params.delivery).toBe('queue-if-active')
+      expect('delivery' in second.params).toBe(false)
+      expect(second.envelope.clientOperationId).not.toBe(first.envelope.clientOperationId)
     })
   })
 
-  it('an ack-lost send is spent once the host publishes it as a draft, even one later withdrawn', async () => {
-    const journalKey = 'orca:mobileStructuredSendOperations:v1'
+  it('an ack-lost queued send never absorbs the next identical message', async () => {
     let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method === 'agentSession.send') {
-        attempts += 1
-        if (attempts === 1) {
-          throw markRpcDeliveryUnknown(new Error('Connection closed'))
-        }
-        return mutationOk({
-          clientMessageId: `client-${attempts}`,
-          queued: { messageId: `client-${attempts}`, position: 1, state: 'waiting' }
-        })
+    sendRequest.mockImplementation(async (method, params) => {
+      if (method !== 'agentSession.send') {
+        return ok({ models: [], current: {} })
+      }
+      if (++attempts === 1) {
+        throw markRpcDeliveryUnknown(new Error('Connection closed'))
       }
-      return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+      const id = String(fieldsOf(fieldsOf(params).envelope).clientOperationId)
+      return mutationOk({
+        clientMessageId: id,
+        queued: { messageId: id, position: 1, state: 'waiting' }
+      })
     })
     await mountSession(CAPABLE, snapshotEvent({ runningTurn: true }))
     await act(async () => {
       expect(await hook!.sendWithOutcome('held')).toBe('unknown')
     })
-    const operationId = String(requestOf('agentSession.send').envelope.clientOperationId)
-    expect(stored.get(journalKey)).toContain(operationId)
-    // Someone else's draft proves nothing about this send.
-    act(() => listener?.(batchEvent([queuedDraft({ messageId: 'other-device' })])))
-    await act(async () => {})
-    expect(stored.get(journalKey)).toContain(operationId)
-    // The host names the draft by this send's operation id: that is its receipt.
-    act(() => listener?.(batchEvent([queuedDraft({ messageId: operationId })])))
-    await vi.waitFor(() => expect(stored.has(journalKey)).toBe(false))
-    // Deleted elsewhere: no submission will ever settle it, and nothing has to.
-    act(() => listener?.(batchEvent(null)))
+    const firstId = String(requestOf('agentSession.send').envelope.clientOperationId)
+    act(() => listener?.(batchEvent([queuedDraft({ messageId: firstId })])))
     await act(async () => {
       expect(await hook!.sendWithOutcome('held')).toBe('queued')
     })
-    expect(requestOf('agentSession.send', 1).envelope.clientOperationId).not.toBe(operationId)
-  })
-
-  it('an identical send whose retained id replays as withdrawn goes out fresh', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method === 'agentSession.send') {
-        attempts += 1
-        if (attempts === 1) {
-          throw markRpcDeliveryUnknown(new Error('Connection closed'))
-        }
-        const state = attempts === 2 ? 'withdrawn' : 'waiting'
-        // A pruned deleted card's receipt names no place in the queue: position 0.
-        return mutationOk({
-          clientMessageId: `client-${attempts}`,
-          queued: {
-            messageId: `client-${attempts}`,
-            position: state === 'withdrawn' ? 0 : 1,
-            state
-          }
-        })
-      }
-      return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-    })
-    await mountSession(CAPABLE)
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('again')).toBe('unknown')
-    })
-    // A Delete spent the ack-lost draft before it reached the agent; typing the
-    // same words again is a new message, not a replay to swallow.
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('again')).toBe('queued')
-    })
-    expect(attempts).toBe(3)
-    const ids = [0, 1, 2].map(
-      (index) => requestOf('agentSession.send', index).envelope.clientOperationId
-    )
-    expect(ids[1]).toBe(ids[0])
-    expect(ids[2]).not.toBe(ids[0])
-  })
-
-  it('a withdrawn replay whose record storage will not clear still goes out fresh, and says so', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method === 'agentSession.send') {
-        attempts += 1
-        if (attempts === 1) {
-          throw markRpcDeliveryUnknown(new Error('Connection closed'))
-        }
-        const state = attempts === 2 ? 'withdrawn' : 'waiting'
-        return mutationOk({
-          clientMessageId: `client-${attempts}`,
-          queued: { messageId: `client-${attempts}`, position: 1, state }
-        })
-      }
-      return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-    })
-    await mountSession(CAPABLE)
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('again')).toBe('unknown')
-    })
-    // The retained record cannot be cleared; that must not keep this text from being sent.
-    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
-    asyncStorage.removeItem.mockRejectedValue(new Error('disk full'))
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('again')).toBe('queued')
-    })
-    expect(attempts).toBe(3)
-    const ids = [0, 1, 2].map(
-      (index) => requestOf('agentSession.send', index).envelope.clientOperationId
-    )
-    expect(ids[1]).toBe(ids[0])
-    expect(ids[2]).not.toBe(ids[0])
-    expect(onSendError).toHaveBeenCalledWith(
-      "Sent, but this phone couldn't update its record of sent messages."
-    )
-  })
-
-  describe('a lost answer, then Stop, then the drain under a fresh id', () => {
-    const journalKey = 'orca:mobileStructuredSendOperations:v1'
-    let attempts = 0
-    let lostId = ''
-
-    beforeEach(() => {
-      attempts = 0
-      lostId = ''
-      sendRequest.mockImplementation(async (method, params) => {
-        if (method === 'agentSession.send') {
-          attempts += 1
-          const id = String(fieldsOf(fieldsOf(params).envelope).clientOperationId)
-          if (attempts === 1) {
-            lostId = id
-            throw markRpcDeliveryUnknown(new Error('Connection closed'))
-          }
-          if (id === lostId) {
-            // The replay answers with the hand-off, which names the replayed id as its draft.
-            return mutationOk({
-              clientMessageId: id,
-              submission: acceptedSubmission('fresh-hand-off', id)
-            })
-          }
-          return mutationOk({
-            clientMessageId: id,
-            queued: { messageId: id, position: 1, state: 'waiting' }
-          })
-        }
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      })
-    })
-
-    it('spends the record once the stream carries the hand-off naming it; a direct send does not', async () => {
-      await mountSession(CAPABLE)
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('again')).toBe('unknown')
-      })
-      expect(stored.get(journalKey)).toContain(lostId)
-      // A direct send's submission names no draft, so it settles nothing here.
-      act(() => listener?.(batchEvent(undefined, [acceptedSubmission('someone-else')])))
-      await act(async () => {})
-      expect(stored.get(journalKey)).toContain(lostId)
-      // The drain's hand-off went out under a fresh id and names the lost send's draft.
-      act(() => listener?.(batchEvent(undefined, [acceptedSubmission('fresh-hand-off', lostId)])))
-      await vi.waitFor(() => expect(stored.has(journalKey)).toBe(false))
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('again')).toBe('queued')
-      })
-      expect(attempts).toBe(2)
-      expect(requestOf('agentSession.send', 1).envelope.clientOperationId).not.toBe(lostId)
-    })
-
-    it('spends the record from a replay answered by the hand-off, which no page carries', async () => {
-      await mountSession(CAPABLE)
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('again')).toBe('unknown')
-      })
-      // The host holds that message now; the phone paints no bubble for it. The stream never
-      // carries the hand-off, so the answer's link is what spends the record.
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('again')).toBe('unknown')
-      })
-      expect(requestOf('agentSession.send', 1).envelope.clientOperationId).toBe(lostId)
-      await vi.waitFor(() => expect(stored.has(journalKey)).toBe(false))
-      await act(async () => {
-        expect(await hook!.sendWithOutcome('again')).toBe('queued')
-      })
-      expect(requestOf('agentSession.send', 2).envelope.clientOperationId).not.toBe(lostId)
-    })
+    expect(attempts).toBe(2)
+    expect(requestOf('agentSession.send', 1).envelope.clientOperationId).not.toBe(firstId)
   })
 
   describe('cards from the published list', () => {
diff --git a/mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx
index 0c1c1a7f7115..a59a5f699276 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-read-failure.test.tsx
@@ -5,7 +5,6 @@ import { createElement } from 'react'
 import { act, create, type ReactTestRenderer } from 'react-test-renderer'
 import { afterEach, beforeEach, expect, it, vi } from 'vitest'
 import type { RpcClient } from '../transport/rpc-client'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
 import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
 import { CAPABLE, SESSION_ID, ok } from './use-mobile-structured-agent-session-queued.test-fixture'
 
@@ -72,7 +71,7 @@ async function readFailedWith(reason: string) {
 
 beforeEach(() => {
   vi.clearAllMocks()
-  resetMobileStructuredSendOperationJournalForTests()
+
   sendRequest.mockImplementation(async (method) =>
     method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
   )
diff --git a/mobile/src/session/use-mobile-structured-agent-session-send.test.tsx b/mobile/src/session/use-mobile-structured-agent-session-send.test.tsx
index 4fa1d5bd13c0..3a6c351c6302 100644
--- a/mobile/src/session/use-mobile-structured-agent-session-send.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session-send.test.tsx
@@ -5,8 +5,8 @@ import type { AgentJournalDispatchState } from '../../../src/shared/agent-sessio
 import { DISPATCH_REJECTED_CANCELLED } from '../../../src/shared/structured-agent-session-dispatch-rejection'
 import type { AgentSessionSubscribeEvent } from '../../../src/shared/agent-session-wire'
 import type { RpcClient } from '../transport/rpc-client'
+import { fieldsOf, ok } from './use-mobile-structured-agent-session-queued.test-fixture'
 import { markRpcDeliveryUnknown } from '../transport/rpc-delivery-ambiguity'
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
 import { structuredSendResultFixture } from './structured-agent-send-result.test-fixture'
 import { useMobileStructuredAgentSession } from './use-mobile-structured-agent-session'
 
@@ -18,10 +18,6 @@ const asyncStorage = vi.hoisted(() => ({
 
 vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
 
-function ok(result: unknown) {
-  return { ok: true, result, _meta: { runtimeId: 'runtime-1' } }
-}
-
 function sendResult(dispatchState: AgentJournalDispatchState, reason: string | null = null) {
   return ok({
     ok: true,
@@ -32,7 +28,7 @@ function sendResult(dispatchState: AgentJournalDispatchState, reason: string | n
   })
 }
 
-function snapshotEvent(): AgentSessionSubscribeEvent {
+function snapshotEvent(): Extract<AgentSessionSubscribeEvent, { type: 'snapshot' }> {
   return {
     type: 'snapshot',
     sessionId: 'session-1',
@@ -57,18 +53,28 @@ function snapshotEvent(): AgentSessionSubscribeEvent {
   }
 }
 
-describe('mobile structured send retries', () => {
+describe('mobile structured send actions', () => {
   let renderer: ReactTestRenderer | null = null
   let hook: ReturnType<typeof useMobileStructuredAgentSession> | null = null
   let listener: ((value: unknown) => void) | null = null
   let storedOperations: Map<string, string>
   const onSendError = vi.fn()
-  const sendRequest = vi.fn()
-  const subscribe = vi.fn((_method: string, _params: unknown, onData: (value: unknown) => void) => {
+  const sendRequest = vi.fn<RpcClient['sendRequest']>()
+  const subscribe = vi.fn<RpcClient['subscribe']>((_method, _params, onData) => {
     listener = onData
     return vi.fn()
   })
-  const client = { sendRequest, subscribe } as unknown as RpcClient
+  const client: RpcClient = {
+    sendRequest,
+    subscribe,
+    updateTerminalSubscriptionViewport: () => {},
+    getState: () => 'connected',
+    getReconnectAttempt: () => 0,
+    getLastConnectedAt: () => null,
+    onStateChange: () => () => {},
+    notifyForeground: () => {},
+    close: () => {}
+  }
 
   function Harness(): null {
     hook = useMobileStructuredAgentSession({
@@ -78,8 +84,9 @@ describe('mobile structured send retries', () => {
       enabled: true,
       connected: true,
       agent: 'codex',
+      hostSupport: null,
       onSendError
-    } as never)
+    })
     return null
   }
 
@@ -96,15 +103,14 @@ describe('mobile structured send retries', () => {
   }
 
   function sentIds(): string[] {
-    return calls().map(
-      ([, params]) =>
-        (params as { envelope: { clientOperationId: string } }).envelope.clientOperationId
+    return calls().map(([, params]) =>
+      String(fieldsOf(fieldsOf(params).envelope).clientOperationId)
     )
   }
 
   beforeEach(() => {
     vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
+
     storedOperations = new Map()
     asyncStorage.getItem.mockImplementation(
       async (key: string) => storedOperations.get(key) ?? null
@@ -127,137 +133,59 @@ describe('mobile structured send retries', () => {
     listener = null
   })
 
-  it('keeps one id across acknowledgement loss and host unknown replays', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      if (attempts === 1) {
-        throw markRpcDeliveryUnknown(new Error('Connection closed'))
-      }
-      return sendResult('unknown')
-    })
-    await mountSession()
-
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('retry me')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('retry me')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('retry me')).toBe('unknown')
-    })
-
-    expect(calls()).toHaveLength(3)
-    expect(new Set(sentIds()).size).toBe(1)
-    expect(calls().every(([, params]) => !('retryUnknown' in (params as object)))).toBe(true)
-  })
+  it.each(['unknown', 'pending', 'accepted'] as const)(
+    'a later Send owns a new id even when the earlier host answer was %s',
+    async (state) => {
+      sendRequest.mockImplementation(async (method) =>
+        method === 'agentSession.send' ? sendResult(state) : ok({ models: [], current: {} })
+      )
+      await mountSession()
+      await act(async () => {
+        const outcome = state === 'unknown' ? 'unknown' : 'accepted'
+        expect(await hook!.sendWithOutcome('same text')).toBe(outcome)
+        expect(await hook!.sendWithOutcome('same text')).toBe(outcome)
+      })
+      expect(new Set(sentIds()).size).toBe(2)
+    }
+  )
 
-  // A replay of a retained id cannot be told from a new send of the same text, and a Stop took the
-  // first one back before the agent started it, so this press goes out as a new message.
-  it('sends a replay a Stop took back once more, under a fresh id, saying nothing', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      if (attempts === 1) {
-        throw markRpcDeliveryUnknown(new Error('Connection closed'))
+  it('keeps the original unknown host row while allowing another Send', async () => {
+    const original = structuredSendResultFixture('unknown')
+    if (!('submission' in original)) {
+      throw new Error('expected a submission answer')
+    }
+    const event = snapshotEvent()
+    event.page.submissions = [original.submission]
+    event.page.items = [
+      {
+        itemId: 'original-message',
+        revision: 1,
+        sequence: 1,
+        observedAt: 10,
+        body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'same text' }] }
       }
-      return attempts === 2
-        ? sendResult('rejected', DISPATCH_REJECTED_CANCELLED)
-        : sendResult('pending')
-    })
-    await mountSession()
-
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('stopped one')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('stopped one')).toBe('accepted')
-    })
-
-    expect(onSendError).not.toHaveBeenCalled()
-    // The lost first send, its replay, and exactly one resend under a new id.
-    const ids = sentIds()
-    expect(ids).toHaveLength(3)
-    expect(ids[1]).toBe(ids[0])
-    expect(ids[2]).not.toBe(ids[0])
-  })
-
-  it('reads a first answer a Stop took back as sent, saying nothing, and spends its id', async () => {
+    ]
     sendRequest.mockImplementation(async (method) =>
-      method === 'agentSession.send'
-        ? sendResult('rejected', DISPATCH_REJECTED_CANCELLED)
-        : method === 'agentSession.options'
-          ? ok({ models: [], current: {} })
-          : ok({})
+      method === 'agentSession.send' ? sendResult('accepted') : ok({ models: [], current: {} })
     )
     await mountSession()
-
+    act(() => listener?.(event))
+    const messages = hook!.session.messages
+    expect(messages).toHaveLength(1)
     await act(async () => {
-      expect(await hook!.sendWithOutcome('stopped first')).toBe('accepted')
-      expect(await hook!.sendWithOutcome('stopped first')).toBe('accepted')
+      expect(await hook!.sendWithOutcome('same text')).toBe('accepted')
     })
-
-    expect(onSendError).not.toHaveBeenCalled()
-    const ids = sentIds()
-    expect(ids).toHaveLength(2)
-    expect(ids[1]).not.toBe(ids[0])
+    expect(hook!.session.messages).toEqual(messages)
+    expect(event.page.submissions[0]?.dispatchState).toBe('unknown')
+    expect(calls()).toHaveLength(1)
   })
 
-  it('releases an ack-lost id after the journal accepts it for a later identical intent', async () => {
-    let attempts = 0
+  it('does not replay an old action after remount', async () => {
     sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      return attempts === 1
-        ? Promise.reject(markRpcDeliveryUnknown(new Error('Connection closed')))
-        : sendResult('accepted')
-    })
-    await mountSession()
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('same text, later intent')).toBe('unknown')
-    })
-    const firstRequest = calls()[0]![1] as {
-      envelope: { clientOperationId: string; payloadFingerprint: string }
-    }
-    const event = snapshotEvent()
-    act(() =>
-      listener?.({
-        ...event,
-        page: {
-          ...event.page,
-          submissions: [
-            {
-              ...structuredSendResultFixture('accepted').submission,
-              clientMessageId: firstRequest.envelope.clientOperationId,
-              payloadFingerprint: firstRequest.envelope.payloadFingerprint
-            }
-          ]
-        }
-      })
-    )
-    await vi.waitFor(() => expect(storedOperations.size).toBe(0))
-
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('same text, later intent')).toBe('accepted')
-    })
-
-    expect(sentIds()).toHaveLength(2)
-    expect(new Set(sentIds()).size).toBe(2)
-  })
-
-  it('reuses an ambiguous id after the session hook remounts', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+      if (method === 'agentSession.send') {
+        throw markRpcDeliveryUnknown(new Error('Connection closed'))
       }
-      attempts += 1
-      return attempts === 1
-        ? Promise.reject(markRpcDeliveryUnknown(new Error('Connection closed')))
-        : sendResult('unknown')
+      return ok({ models: [], current: {} })
     })
     await mountSession()
     await act(async () => {
@@ -265,131 +193,87 @@ describe('mobile structured send retries', () => {
     })
     act(() => renderer?.unmount())
     renderer = null
-    hook = null
     listener = null
-
     await mountSession()
     await act(async () => {
       expect(await hook!.sendWithOutcome('survive remount')).toBe('unknown')
     })
-
-    expect(new Set(sentIds()).size).toBe(1)
-    expect(calls().every(([, params]) => !('retryUnknown' in (params as object)))).toBe(true)
-    expect(asyncStorage.setItem.mock.invocationCallOrder[0]).toBeLessThan(
-      sendRequest.mock.invocationCallOrder.find(
-        (_, index) => sendRequest.mock.calls[index]?.[0] === 'agentSession.send'
-      )!
-    )
+    expect(new Set(sentIds()).size).toBe(2)
   })
 
-  it('keeps the id when the host fails after provider dispatch', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      return attempts === 1
-        ? {
-            id: 'request-1',
-            ok: false as const,
-            error: { code: 'runtime_error', message: 'journal resolve failed' },
-            _meta: { runtimeId: 'runtime-1' }
-          }
-        : sendResult('unknown')
-    })
+  it('uses newly uploaded attachment paths for a new action with the same image', async () => {
+    sendRequest.mockImplementation(async (method) =>
+      method === 'agentSession.send' ? sendResult('unknown') : ok({ models: [], current: {} })
+    )
     await mountSession()
-
     await act(async () => {
-      expect(await hook!.sendWithOutcome('possibly delivered')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('possibly delivered')).toBe('unknown')
-    })
-
-    expect(calls()).toHaveLength(2)
-    expect(new Set(sentIds()).size).toBe(1)
-    expect(calls().every(([, params]) => !('retryUnknown' in (params as object)))).toBe(true)
-  })
-
-  it('reuses the original uploaded attachment identity after acknowledgement loss', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+      for (const path of ['/tmp/original.png', '/tmp/reuploaded.png']) {
+        expect(
+          await hook!.sendWithOutcome('describe', undefined, undefined, [
+            {
+              path,
+              previewUri: 'file:///photo.jpg'
+            }
+          ])
+        ).toBe('unknown')
       }
-      attempts += 1
-      return attempts === 1
-        ? Promise.reject(markRpcDeliveryUnknown(new Error('Connection closed')))
-        : sendResult('unknown')
-    })
-    await mountSession()
-    const contentFingerprint = 'f'.repeat(64)
-
-    await act(async () => {
-      expect(
-        await hook!.sendWithOutcome('describe', undefined, undefined, [
-          {
-            path: '/tmp/original.png',
-            previewUri: 'file:///photo.jpg',
-            contentFingerprint
-          }
-        ])
-      ).toBe('unknown')
-      expect(
-        await hook!.sendWithOutcome('describe', undefined, undefined, [
-          {
-            path: '/tmp/reuploaded.png',
-            previewUri: 'file:///photo.jpg',
-            contentFingerprint
-          }
-        ])
-      ).toBe('unknown')
     })
-
-    expect(new Set(sentIds()).size).toBe(1)
+    expect(new Set(sentIds()).size).toBe(2)
     expect(calls()[1]?.[1]).toMatchObject({
       body: {
-        blocks: expect.arrayContaining([{ type: 'image-ref', path: '/tmp/original.png' }])
+        blocks: expect.arrayContaining([{ type: 'image-ref', path: '/tmp/reuploaded.png' }])
       }
     })
   })
 
+  it('reports a send stopped before the agent started it without sending it twice', async () => {
+    sendRequest.mockImplementation(async (method) =>
+      method === 'agentSession.send'
+        ? sendResult('rejected', DISPATCH_REJECTED_CANCELLED)
+        : ok({ models: [], current: {} })
+    )
+    await mountSession()
+    await act(async () => {
+      expect(await hook!.sendWithOutcome('stopped')).toBe('accepted')
+      expect(await hook!.sendWithOutcome('stopped')).toBe('accepted')
+    })
+    expect(calls()).toHaveLength(2)
+    expect(new Set(sentIds()).size).toBe(2)
+    expect(onSendError).not.toHaveBeenCalled()
+  })
+
   it.each(['invalid_argument', 'unauthorized'])(
-    'rotates after a %s pre-handler RPC refusal that proves the send did not run',
+    'a later Send is independent after a %s refusal',
     async (code) => {
       let attempts = 0
       sendRequest.mockImplementation(async (method) => {
         if (method !== 'agentSession.send') {
-          return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+          return ok({ models: [], current: {} })
         }
-        attempts += 1
-        return attempts === 1
+        return ++attempts === 1
           ? {
+              id: 'request-1',
               ok: false as const,
-              error: { code, message: 'Message is not authorized' },
-              _meta: { runtimeId: 'runtime-1' }
+              error: { code, message: 'Message is not authorized' }
             }
           : sendResult('accepted')
       })
       await mountSession()
-
       await act(async () => {
-        expect(await hook!.sendWithOutcome('never reached the handler')).toBe('rejected')
-        expect(await hook!.sendWithOutcome('never reached the handler')).toBe('accepted')
+        expect(await hook!.sendWithOutcome('again')).toBe('rejected')
+        expect(await hook!.sendWithOutcome('again')).toBe('accepted')
       })
-
-      expect(sentIds()).toHaveLength(2)
       expect(new Set(sentIds()).size).toBe(2)
     }
   )
 
-  it('keeps the send id after a pending-admission refusal', async () => {
+  it('a new Send goes through after a stale-fence refusal', async () => {
     let attempts = 0
     sendRequest.mockImplementation(async (method) => {
       if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
+        return ok({ models: [], current: {} })
       }
-      attempts += 1
-      return attempts === 1
+      return ++attempts === 1
         ? ok({
             ok: false,
             refusal: {
@@ -401,112 +285,33 @@ describe('mobile structured send retries', () => {
         : sendResult('accepted')
     })
     await mountSession()
-
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('retry at the current fence')).toBe('rejected')
-      expect(await hook!.sendWithOutcome('retry at the current fence')).toBe('unknown')
-    })
-
-    expect(sentIds()).toHaveLength(2)
-    expect(new Set(sentIds()).size).toBe(1)
-  })
-
-  it('keeps the id when an older host refuses an unknown replay', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      if (attempts === 1) {
-        throw markRpcDeliveryUnknown(new Error('Connection closed'))
-      }
-      return attempts === 2
-        ? ok({
-            ok: false,
-            refusal: {
-              code: 'agent_session_operation_unknown',
-              message: 'The outcome is unknown.'
-            }
-          })
-        : sendResult('unknown')
-    })
-    await mountSession()
-
     await act(async () => {
-      expect(await hook!.sendWithOutcome('old host replay')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('old host replay')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('old host replay')).toBe('unknown')
+      expect(await hook!.sendWithOutcome('again')).toBe('rejected')
+      expect(await hook!.sendWithOutcome('again')).toBe('accepted')
     })
-
-    expect(new Set(sentIds()).size).toBe(1)
-    expect(calls().every(([, params]) => !('retryUnknown' in (params as object)))).toBe(true)
+    expect(new Set(sentIds()).size).toBe(2)
   })
 
-  it('sends under a new id once the host has expired an ambiguous one', async () => {
-    let attempts = 0
-    sendRequest.mockImplementation(async (method) => {
-      if (method !== 'agentSession.send') {
-        return method === 'agentSession.options' ? ok({ models: [], current: {} }) : ok({})
-      }
-      attempts += 1
-      if (attempts === 1) {
-        throw markRpcDeliveryUnknown(new Error('Connection closed'))
-      }
-      if (attempts === 3) {
-        return sendResult('accepted')
-      }
-      return ok({
-        ok: false,
-        refusal: {
-          code: 'agent_session_operation_expired',
-          message: 'Operation expired.'
-        }
-      })
-    })
-    await mountSession()
-
-    await act(async () => {
-      expect(await hook!.sendWithOutcome('old ambiguity')).toBe('unknown')
-      expect(await hook!.sendWithOutcome('old ambiguity')).toBe('rejected')
-      expect(await hook!.sendWithOutcome('old ambiguity')).toBe('accepted')
-    })
-
-    expect(calls()).toHaveLength(3)
-    const [first, replay, fresh] = sentIds()
-    expect(replay).toBe(first)
-    expect(fresh).not.toBe(first)
-    expect(onSendError).toHaveBeenCalledWith(
-      "Orca couldn't confirm your message reached the agent. Check the chat, then send it again if needed."
+  it('never reads an old phone journal, even when storage is full or unreadable', async () => {
+    asyncStorage.getItem.mockRejectedValue(new Error('unreadable old journal'))
+    asyncStorage.setItem.mockRejectedValue(new Error('disk full'))
+    sendRequest.mockImplementation(async (method) =>
+      method === 'agentSession.send' ? sendResult('accepted') : ok({ models: [], current: {} })
     )
-  })
-
-  it('does not retain an id when the action budget expires before dispatch', async () => {
     await mountSession()
-
     await act(async () => {
-      expect(await hook!.sendWithOutcome('never attempted', undefined, 0)).toBe('rejected')
+      expect(await hook!.sendWithOutcome('new action')).toBe('accepted')
     })
-
-    expect(calls()).toHaveLength(0)
+    expect(asyncStorage.getItem).not.toHaveBeenCalled()
     expect(asyncStorage.setItem).not.toHaveBeenCalled()
+    expect(onSendError).not.toHaveBeenCalled()
   })
 
-  it('puts a store that would not take the journal on screen, and sends nothing', async () => {
-    // Inside the page the store is the app's, reached over the `storage` grant, and it rejects a
-    // journal past `PAGE_STORAGE_MAX_VALUE_CHARS` — 48 unsettled sends, measured. A refusal that
-    // resolved instead would put a mutation on the wire carrying an operation id nothing holds,
-    // and a retry after a crash would send this message twice (rulings-ota-c7.md ruling 7).
-    asyncStorage.setItem.mockImplementation(async () => {
-      throw new Error('Orca could not save orca:mobileStructuredSendOperations:v1')
-    })
+  it('sends nothing once the action budget expires', async () => {
     await mountSession()
-
     await act(async () => {
-      expect(await hook!.sendWithOutcome('the journal will not take this')).toBe('rejected')
+      expect(await hook!.sendWithOutcome('never attempted', undefined, 0)).toBe('rejected')
     })
-
-    expect(onSendError).toHaveBeenCalledWith('Message not sent')
     expect(calls()).toHaveLength(0)
   })
 })
diff --git a/mobile/src/session/use-mobile-structured-agent-session.test.tsx b/mobile/src/session/use-mobile-structured-agent-session.test.tsx
index 04b8e87304a2..db9657a4dd8b 100644
--- a/mobile/src/session/use-mobile-structured-agent-session.test.tsx
+++ b/mobile/src/session/use-mobile-structured-agent-session.test.tsx
@@ -22,8 +22,6 @@ const asyncStorage = vi.hoisted(() => ({
 
 vi.mock('@react-native-async-storage/async-storage', () => ({ default: asyncStorage }))
 
-import { resetMobileStructuredSendOperationJournalForTests } from './mobile-structured-send-operation-journal'
-
 function ok(result: unknown) {
   return { ok: true, result, _meta: { runtimeId: 'runtime-1' } }
 }
@@ -271,7 +269,7 @@ describe('useMobileStructuredAgentSession', () => {
 
   beforeEach(() => {
     vi.clearAllMocks()
-    resetMobileStructuredSendOperationJournalForTests()
+
     storedOperations = new Map()
     asyncStorage.getItem.mockImplementation(
       async (key: string) => storedOperations.get(key) ?? null
diff --git a/mobile/src/session/use-mobile-structured-agent-session.ts b/mobile/src/session/use-mobile-structured-agent-session.ts
index bb52186a4b1c..b5f17dbbfa49 100644
--- a/mobile/src/session/use-mobile-structured-agent-session.ts
+++ b/mobile/src/session/use-mobile-structured-agent-session.ts
@@ -30,7 +30,6 @@ import { useMobileStructuredPromptResponses } from './use-mobile-structured-prom
 import type { StructuredAgentSessionHostSupport } from './mobile-structured-agent-session-host-support'
 import { useMobileStructuredAgentOptions } from './use-mobile-structured-agent-options'
 import { useMobileStructuredAgentTurnTiming } from './use-mobile-structured-agent-turn-timing'
-import { useMobileStructuredSendOperationReconciliation } from './use-mobile-structured-send-operation-reconciliation'
 import {
   pendingStructuredPromptIdentity,
   requestMobileStructuredAgentSessionCancel
@@ -83,8 +82,6 @@ export function useMobileStructuredAgentSession(args: {
   sessionId: string | null
   /** Host/workspace scope used to keep same provider ids isolated. */
   sourceIdentity?: string
-  /** Authenticated identity the host keys mutation admission under. */
-  callerIdentity?: string
   enabled: boolean
   /** Live transport only; gates the connection-scoped hold, and whether child rows may read live. */
   connected: boolean
@@ -100,7 +97,6 @@ export function useMobileStructuredAgentSession(args: {
   const {
     agent,
     appendComposerText,
-    callerIdentity = '',
     client,
     connected,
     sessionId,
@@ -121,7 +117,6 @@ export function useMobileStructuredAgentSession(args: {
   const stateArgs = { client, sessionId, sessionKey, enabled, connected }
   const { state, stateRef, queuedMessages, queuePause, loadingOlder, loadEarlier } =
     useMobileStructuredAgentState(stateArgs)
-  useMobileStructuredSendOperationReconciliation(state.submissions, queuedMessages)
 
   const mutate = useMobileStructuredAgentMutate({
     client,
@@ -154,10 +149,8 @@ export function useMobileStructuredAgentSession(args: {
 
   const sendWithOutcome = useMobileStructuredSendWithOutcome({
     agent,
-    callerIdentity,
     client,
     sessionId,
-    sessionKey,
     enabled,
     queueCapable,
     stateRef,
diff --git a/mobile/src/session/use-mobile-structured-native-chat-send-bridge.ts b/mobile/src/session/use-mobile-structured-native-chat-send-bridge.ts
index 5abe42b39e60..274390eca6ba 100644
--- a/mobile/src/session/use-mobile-structured-native-chat-send-bridge.ts
+++ b/mobile/src/session/use-mobile-structured-native-chat-send-bridge.ts
@@ -8,7 +8,6 @@ type StructuredNativeChatAttachment = {
   id?: string
   path: string
   previewUri: string
-  contentFingerprint?: string
 }
 
 export function useMobileStructuredNativeChatSendBridge(args: {
diff --git a/mobile/src/session/use-mobile-structured-send-operation-reconciliation.ts b/mobile/src/session/use-mobile-structured-send-operation-reconciliation.ts
deleted file mode 100644
index 65d0f3184668..000000000000
--- a/mobile/src/session/use-mobile-structured-send-operation-reconciliation.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { useEffect } from 'react'
-import type { AgentJournalSubmission } from '../../../src/shared/agent-session-journal-types'
-import type { MobileQueuedMessageFeed } from './mobile-structured-queued-message-feed'
-import {
-  clearMobileStructuredQueuedSendOperations,
-  clearMobileStructuredSettledSendOperations
-} from './mobile-structured-send-operation-journal'
-
-export function useMobileStructuredSendOperationReconciliation(
-  submissions: readonly AgentJournalSubmission[],
-  queuedMessages: MobileQueuedMessageFeed = null
-): void {
-  useEffect(() => {
-    void clearMobileStructuredSettledSendOperations({ submissions }).catch(() => undefined)
-  }, [submissions])
-  useEffect(() => {
-    if (!queuedMessages || queuedMessages.length === 0) {
-      return
-    }
-    void clearMobileStructuredQueuedSendOperations({
-      queuedMessageIds: queuedMessages.map((draft) => draft.messageId)
-    }).catch(() => undefined)
-  }, [queuedMessages])
-}
diff --git a/mobile/src/session/use-mobile-structured-send-with-outcome.ts b/mobile/src/session/use-mobile-structured-send-with-outcome.ts
index cb1127691ce7..4a7b1e67470c 100644
--- a/mobile/src/session/use-mobile-structured-send-with-outcome.ts
+++ b/mobile/src/session/use-mobile-structured-send-with-outcome.ts
@@ -33,15 +33,12 @@ export function mobileStructuredSendQueues(
 
 export type StructuredMobileSendAttachment = StructuredAgentSessionAttachment & {
   id?: string
-  contentFingerprint?: string
 }
 
 export function useMobileStructuredSendWithOutcome(args: {
   agent: string | null
-  callerIdentity: string
   client: RpcClient | null
   sessionId: string | null
-  sessionKey: string
   enabled: boolean
   queueCapable: boolean
   stateRef: { readonly current: StructuredAgentSessionState }
@@ -59,7 +56,6 @@ export function useMobileStructuredSendWithOutcome(args: {
 ) => Promise<MobileNativeChatSendOutcome> {
   const {
     agent,
-    callerIdentity,
     client,
     commandPending,
     controller,
@@ -67,7 +63,6 @@ export function useMobileStructuredSendWithOutcome(args: {
     onSendError,
     queueCapable,
     sessionId,
-    sessionKey,
     stateRef
   } = args
   return useCallback(
@@ -121,8 +116,6 @@ export function useMobileStructuredSendWithOutcome(args: {
       return sendMobileStructuredAgentSessionMessage({
         client,
         sessionId,
-        sessionKey,
-        callerIdentity,
         expectedRuntimeFence: currentFence,
         text,
         attachments: sendAttachments,
@@ -135,7 +128,6 @@ export function useMobileStructuredSendWithOutcome(args: {
     },
     [
       agent,
-      callerIdentity,
       client,
       commandPending,
       controller,
@@ -143,7 +135,6 @@ export function useMobileStructuredSendWithOutcome(args: {
       onSendError,
       queueCapable,
       sessionId,
-      sessionKey,
       stateRef
     ]
   )
diff --git a/mobile/src/storage/mirrored-storage-keys.ts b/mobile/src/storage/mirrored-storage-keys.ts
index 590c99a77405..c8eac0c40346 100644
--- a/mobile/src/storage/mirrored-storage-keys.ts
+++ b/mobile/src/storage/mirrored-storage-keys.ts
@@ -78,8 +78,7 @@ function note(key: string, value: string | null): void {
  * refused page write left this map holding a value no store had taken and the next `init` handed
  * the page exactly that. There is nothing to undo, because nothing is written until the answer.
  *
- * Returns the store's own promise, so a caller that has something to say about a refusal — the
- * durable send journal is the one — still hears it, and a caller that has not is unchanged.
+ * Returns the store's own promise so callers can report refusals.
  */
 export function persistMirrored(key: string, value: string | null): Promise<void> {
   const write = value === null ? AsyncStorage.removeItem(key) : AsyncStorage.setItem(key, value)
diff --git a/mobile/tests-typecheck-baseline.txt b/mobile/tests-typecheck-baseline.txt
index c2eadf35e2ad..b8dda1e45a74 100644
--- a/mobile/tests-typecheck-baseline.txt
+++ b/mobile/tests-typecheck-baseline.txt
@@ -63,7 +63,6 @@ src/session/use-mobile-native-chat-image-attachments.test.ts
 src/session/use-mobile-pr-branch-context.test.ts
 src/session/use-mobile-pr-sidebar-controller.test.ts
 src/session/use-mobile-session-terminal-create-actions.test.ts
-src/session/use-mobile-structured-agent-session-send.test.tsx
 src/session/use-mobile-structured-agent-session.test.tsx
 src/session/use-mobile-structured-prompt-responses.test.tsx
 src/session/use-mobile-terminal-inventory-recovery.test.ts
diff --git a/mobile/web-entry/web-overrides.json b/mobile/web-entry/web-overrides.json
index d840f480f2ce..8c917694ce5e 100644
--- a/mobile/web-entry/web-overrides.json
+++ b/mobile/web-entry/web-overrides.json
@@ -29,10 +29,6 @@
       "file": "src/transport/host-device-token-store.web.ts",
       "reason": "expo-secure-store resolves to {} on web, and the bridge carries the RPC, so the page holds no device token."
     },
-    {
-      "file": "src/platform/native-chat-image-fingerprint.web.ts",
-      "reason": "The web image uploader uses WebCrypto SHA-256 when available to reduce JavaScript hashing of large images. Native keeps the synchronous portable fingerprint; unavailable or failed web crypto uses that same portable fallback."
-    },
     {
       "file": "src/platform/host-os.web.ts",
       "reason": "Platform.OS is web inside the shell's page, but the keyboard the page lifts over is the phone's, reported in that OS's own terms: iOS counts the home indicator. Keyboard and inset arithmetic branches on the host OS, so this answers the phone's OS from the WebView's user agent, and the page computes what the native screen computes."
diff --git a/src/shared/structured-agent-session-mutation.ts b/src/shared/structured-agent-session-mutation.ts
index 66bffc479979..d075af5d28bc 100644
--- a/src/shared/structured-agent-session-mutation.ts
+++ b/src/shared/structured-agent-session-mutation.ts
@@ -17,21 +17,15 @@ function canonicalize(value: unknown): string {
   return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalize(entry)}`).join(',')}}`
 }
 
-export function serializeStructuredAgentSessionFingerprintPayload(input: {
-  method: string
-  sessionId: string
-  fields: Record<string, unknown>
-}): string {
-  return canonicalize({ method: input.method, sessionId: input.sessionId, fields: input.fields })
-}
-
 export function structuredAgentSessionPayloadFingerprint(input: {
   method: string
   sessionId: string
   fields: Record<string, unknown>
 }): string {
   const bytes = sha256(
-    new TextEncoder().encode(serializeStructuredAgentSessionFingerprintPayload(input))
+    new TextEncoder().encode(
+      canonicalize({ method: input.method, sessionId: input.sessionId, fields: input.fields })
+    )
   )
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
 }

From 216ef2985a80a2e33c63401994727c329c3803db Mon Sep 17 00:00:00 2001
From: Neil <neil@stably.ai>
Date: Wed, 7 Oct 2026 22:42:06 -0700
Subject: [PATCH 15/17] fix(terminal): avoid replaying completed strings after
 snapshots

---
 ...artial-escape-native-continuation.test.mjs | 113 ++++++++++++++++++
 ...al-partial-escape-tail-ground-scan.test.ts |   8 +-
 .../terminal-partial-escape-tail.fuzz.test.ts |   3 +-
 src/shared/terminal-partial-escape-tail.ts    |   4 +
 4 files changed, 123 insertions(+), 5 deletions(-)
 create mode 100644 config/scripts/terminal-partial-escape-native-continuation.test.mjs

diff --git a/config/scripts/terminal-partial-escape-native-continuation.test.mjs b/config/scripts/terminal-partial-escape-native-continuation.test.mjs
new file mode 100644
index 000000000000..d42b0115c578
--- /dev/null
+++ b/config/scripts/terminal-partial-escape-native-continuation.test.mjs
@@ -0,0 +1,113 @@
+import { createRequire } from 'node:module'
+import { describe, expect, it } from 'vitest'
+import { advancePartialEscapeTail } from '../../src/shared/terminal-partial-escape-tail'
+
+const require = createRequire(import.meta.url)
+const { Terminal } = require(process.env.ORCA_PARTIAL_ESCAPE_HEADLESS ?? '@xterm/headless')
+const { SerializeAddon } = require('@xterm/addon-serialize')
+
+function model() {
+  const terminal = new Terminal({ cols: 40, rows: 6, allowProposedApi: true, logLevel: 'off' })
+  const serializer = new SerializeAddon()
+  terminal.loadAddon(serializer)
+  const effects = []
+  for (const id of [2, 7, 8, 52, 1337]) {
+    terminal.parser.registerOscHandler(id, (data) => {
+      effects.push(['osc', id, data])
+      return true
+    })
+  }
+  terminal.parser.registerDcsHandler({ final: 'q' }, (data) => {
+    effects.push(['dcs', data])
+    return true
+  })
+  terminal.onData((data) => effects.push(['reply', data]))
+  return { terminal, serializer, effects }
+}
+
+const write = (h, data) => h.terminal._core.writeSync(data)
+const state = (h) => h.terminal._core._inputHandler._parser.currentState
+const screen = (h) => {
+  const buffer = h.terminal.buffer.active
+  return {
+    cursor: [buffer.cursorX, buffer.cursorY],
+    rows: Array.from({ length: buffer.length }, (_, row) => {
+      const line = buffer.getLine(row)
+      return Array.from({ length: line.length }, (_, column) => {
+        const cell = line.getCell(column)
+        return [cell.getChars(), cell.getWidth(), cell.getFgColor(), cell.getBgColor()]
+      })
+    })
+  }
+}
+
+function compareContinuation(source, restored, prefix, continuation) {
+  source.terminal.reset()
+  restored.terminal.reset()
+  source.effects.length = 0
+  restored.effects.length = 0
+  write(source, `BEFORE${prefix}\x1b`)
+  const serialized = source.serializer.serialize()
+  const pending = advancePartialEscapeTail('', `BEFORE${prefix}\x1b`)
+  source.effects.length = 0
+  write(restored, serialized + pending)
+  expect(restored.effects, JSON.stringify({ prefix, continuation })).toEqual([])
+  expect(state(restored)).toBe(state(source))
+  write(source, continuation)
+  write(restored, continuation)
+  expect(screen(restored), JSON.stringify({ prefix, continuation })).toEqual(screen(source))
+  expect(state(restored)).toBe(state(source))
+  expect(restored.effects).toEqual(source.effects)
+}
+
+const prefixes = [
+  '\x1b]2;title',
+  '\x1b]7;file:///original',
+  '\x1b]8;;https://example.com',
+  '\x1b]52;c;aGVsbG8=',
+  '\x1b]1337;File=inline=1:AAAA',
+  '\x1bPqpayload',
+  '\x1b_Gpayload',
+  '\x1bXpayload',
+  '\x1b^payload'
+]
+
+describe('completed string continuation against the native terminal parser', () => {
+  it.each(prefixes)('matches uninterrupted output for every following byte after %j', (prefix) => {
+    const source = model()
+    const restored = model()
+    try {
+      for (let byte = 0; byte < 256; byte++) {
+        compareContinuation(source, restored, prefix, `${String.fromCharCode(byte)}AFTER`)
+      }
+    } finally {
+      source.terminal.dispose()
+      restored.terminal.dispose()
+    }
+  })
+
+  it.each([0, 32, 4095, 4096, 4097, 8192])(
+    'does not repeat completed side effects for a %i-character payload',
+    (length) => {
+      const source = model()
+      const restored = model()
+      try {
+        for (const introducer of ['\x1b]2;', '\x1b]7;', '\x1b]52;', '\x1bPq']) {
+          for (const continuation of [
+            '\\AFTER',
+            '[32mAFTER',
+            '\x18AFTER',
+            '\x1aAFTER',
+            '\x1b]7;file:///next\x07AFTER',
+            '\x1bPqnext\x1b\\AFTER'
+          ]) {
+            compareContinuation(source, restored, introducer + 'x'.repeat(length), continuation)
+          }
+        }
+      } finally {
+        source.terminal.dispose()
+        restored.terminal.dispose()
+      }
+    }
+  )
+})
diff --git a/src/shared/terminal-partial-escape-tail-ground-scan.test.ts b/src/shared/terminal-partial-escape-tail-ground-scan.test.ts
index fb3c29b65597..7dfa7e39873d 100644
--- a/src/shared/terminal-partial-escape-tail-ground-scan.test.ts
+++ b/src/shared/terminal-partial-escape-tail-ground-scan.test.ts
@@ -26,16 +26,16 @@ describe('partial escape scanning between sequences', () => {
   it.each([
     ['\x1b[38;5;', '196m'],
     ['\x1b]2;building', '\x07'],
-    ['\x1b]2;building\x1b', '\\'],
+    ['\x1b]2;building\x1b', '\\', '\x1b'],
     ['\x1bPqpayload', '\x1b\\'],
-    ['\x1bPqpayload\x1b', '\\'],
+    ['\x1bPqpayload\x1b', '\\', '\x1b'],
     ['\x1b(', 'B']
-  ])('preserves %j through every split after ordinary text', (pending, completion) => {
+  ])('preserves %j through every split after ordinary text', (pending, completion, expected = pending) => {
     const prefix = `\x1b[32m${'build output '.repeat(128)}\x1b[0m`
     for (let split = 0; split <= pending.length; split += 1) {
       const first = advancePartialEscapeTail('', prefix + pending.slice(0, split))
       const continued = advancePartialEscapeTail(first, pending.slice(split))
-      expect(continued).toBe(pending)
+      expect(continued).toBe(expected)
       expect(advancePartialEscapeTail(continued, `${completion}ready`)).toBe('')
     }
   })
diff --git a/src/shared/terminal-partial-escape-tail.fuzz.test.ts b/src/shared/terminal-partial-escape-tail.fuzz.test.ts
index 8fa015d6b035..791d6755d81b 100644
--- a/src/shared/terminal-partial-escape-tail.fuzz.test.ts
+++ b/src/shared/terminal-partial-escape-tail.fuzz.test.ts
@@ -188,6 +188,7 @@ describe('advancePartialEscapeTail differential fuzz', () => {
 
   it('ran the whole corpus', () => {
     expect(checked).toBe(963_819)
-    expect(foldSplits).toBe(6_236_429)
+    // Completed strings retain only ESC, so the same corpus has fewer tail splits.
+    expect(foldSplits).toBe(6_234_666)
   })
 })
diff --git a/src/shared/terminal-partial-escape-tail.ts b/src/shared/terminal-partial-escape-tail.ts
index 5c735dd86ec5..3dba2d4ad52f 100644
--- a/src/shared/terminal-partial-escape-tail.ts
+++ b/src/shared/terminal-partial-escape-tail.ts
@@ -146,6 +146,10 @@ export function extractPartialEscapeTail(stream: string): string {
         break
     }
   }
+  // ESC already ends a string in xterm; replay only its pending escape state.
+  if (state === 'oscEsc' || state === 'stringEsc') {
+    return '\x1b'
+  }
   return state === 'ground' ? '' : stream.slice(start)
 }
 

From 6e39b8ecb2691dd7edb1b00ae8257bc88829acac Mon Sep 17 00:00:00 2001
From: Neil <4138956+nwparker@users.noreply.github.com>
Date: Thu, 8 Oct 2026 01:59:46 -0700
Subject: [PATCH 16/17] fix: admit relay bulk frames once under backpressure
 (#26333)

* perf: stop retrying relay bulk frames after admission

* fix: prevent relay bulk retries during admission

* test: prove relay bulk admission races remain exercised

* test: limit teardown watchdog to rejected admissions
---
 src/relay/dispatcher-bulk-admission.test.ts   | 184 +++++++++++++++++
 .../dispatcher-bulk-failed-admission.test.ts  |  56 +++++
 ...spatcher-bulk-retirement-admission.test.ts |  48 +++++
 .../dispatcher-bulk-write-test-harness.ts     | 192 ++++++++++++++++++
 src/relay/dispatcher-producer-transport.ts    |  50 +++--
 5 files changed, 511 insertions(+), 19 deletions(-)
 create mode 100644 src/relay/dispatcher-bulk-admission.test.ts
 create mode 100644 src/relay/dispatcher-bulk-failed-admission.test.ts
 create mode 100644 src/relay/dispatcher-bulk-retirement-admission.test.ts
 create mode 100644 src/relay/dispatcher-bulk-write-test-harness.ts

diff --git a/src/relay/dispatcher-bulk-admission.test.ts b/src/relay/dispatcher-bulk-admission.test.ts
new file mode 100644
index 000000000000..e5b0fbf2aaf3
--- /dev/null
+++ b/src/relay/dispatcher-bulk-admission.test.ts
@@ -0,0 +1,184 @@
+import { describe, expect, it } from 'vitest'
+import { createBulkWriteHarness, nextBulkWriteTurn } from './dispatcher-bulk-write-test-harness'
+
+describe('bulk admission and sink settlement', () => {
+  it('streams more than four fixed-bulk frames without tripping the teardown watchdog', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      const sequences = Array.from({ length: 8 }, (_, seq) => seq)
+      const completion = Promise.all(
+        sequences.map((seq) =>
+          harness.dispatcher.notifyBulk('fs.streamChunk', { streamId: 1, seq, data: 'fixed' })
+        )
+      ).then(
+        () => ({ ok: true }),
+        (error: unknown) => ({ ok: false, error })
+      )
+      await nextBulkWriteTurn()
+      await harness.drain()
+      expect(await completion).toEqual({ ok: true })
+      expect(harness.frames.filter((frame) => frame.method === 'fs.streamChunk')).toEqual(
+        sequences.map((seq) => ({ method: 'fs.streamChunk', seq }))
+      )
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('retires a fixed-bulk retry when a closed writer settles it before its client closes', async () => {
+    const harness = createBulkWriteHarness(2048, 800)
+    try {
+      expect(harness.fillProducerQueue()).toBeGreaterThan(1000)
+      const completion = harness.dispatcher.notifyBulk('fs.streamChunk', {
+        streamId: 1,
+        data: 'fixed'
+      })
+      const assertion = expect(completion).rejects.toThrow('Relay writer is closed')
+      await nextBulkWriteTurn()
+      expect(harness.dispatcher.capacityRetryCount).toBe(1)
+      expect(harness.dispatcher.fixedBulkAdmissions).toEqual([])
+      expect(harness.frames).toEqual([{ method: 'pty.data' }])
+      expect(harness.pending).toHaveLength(1)
+      harness.sink.destroy(new Error('stream destroyed'))
+      await nextBulkWriteTurn()
+      const pendingWrite = harness.pending.shift()
+      if (!pendingWrite) {
+        throw new Error('Expected the native writable callback to remain pending')
+      }
+      pendingWrite.complete(new Error('pending native write failed'))
+      await assertion
+      expect(harness.sink.writableLength).toBe(0)
+      expect(harness.dispatcher.fixedBulkAdmissions).toEqual([
+        {
+          clientClosed: false,
+          writerCanAdmitZero: false,
+          retainedProducerBytes: 0,
+          settledBeforeReturn: true,
+          accepted: false
+        }
+      ])
+      expect(harness.dispatcher.capacityRetryCount).toBe(0)
+      expect(harness.dispatcher.retainedPublicationBytes).toBe(0)
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('ignores a captured capacity retry after its frame is admitted', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      harness.fillProducerQueue()
+      const completion = harness.dispatcher.notifyBulk('git.responseChunk', {
+        streamId: 1,
+        seq: 0,
+        data: 'g'.repeat(40 * 1024)
+      })
+      await nextBulkWriteTurn()
+      const retry = harness.dispatcher.lastCapacityRetry
+      if (!retry) {
+        throw new Error('Expected a capacity-blocked retry')
+      }
+      await harness.reachBulk('git.responseChunk')
+      expect(harness.dispatcher.capacityRetryCount).toBe(0)
+      retry()
+      await harness.drain()
+      await completion
+      expect(harness.frames.filter((frame) => frame.method === 'git.responseChunk')).toEqual([
+        { method: 'git.responseChunk', seq: 0 }
+      ])
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('sends a capacity-blocked frame once and advances the client chain after its callback', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      expect(harness.fillProducerQueue()).toBeGreaterThan(0)
+      let firstSettled = false
+      const first = harness.dispatcher
+        .notifyBulk('git.responseChunk', { streamId: 1, seq: 0, data: 'g'.repeat(40 * 1024) })
+        .then(() => {
+          firstSettled = true
+        })
+      const second = harness.dispatcher.notifyBulk('git.responseChunk', {
+        streamId: 1,
+        seq: 1,
+        data: 'following'
+      })
+      await nextBulkWriteTurn()
+      await harness.reachBulk('git.responseChunk')
+      expect(firstSettled).toBe(false)
+      expect(harness.frames.some((frame) => frame.seq === 1)).toBe(false)
+      await harness.releaseOne()
+      await harness.drain()
+      await Promise.all([first, second])
+      expect(harness.frames.filter((frame) => frame.method === 'git.responseChunk')).toEqual([
+        { method: 'git.responseChunk', seq: 0 },
+        { method: 'git.responseChunk', seq: 1 }
+      ])
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('preserves the admitted frame’s sink failure', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      const error = new Error('owned sink failure')
+      const result = harness.dispatcher.notifyBulk('git.responseChunk', { streamId: 1, seq: 0 })
+      const assertion = expect(result).rejects.toBe(error)
+      await nextBulkWriteTurn()
+      await harness.releaseOne(error)
+      await assertion
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('settles disposal while an admitted bulk frame awaits its callback', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      let settled = false
+      const result = harness.dispatcher
+        .notifyBulk('git.responseChunk', { streamId: 1, seq: 0 })
+        .then(() => {
+          settled = true
+        })
+      await nextBulkWriteTurn()
+      expect(settled).toBe(false)
+      harness.dispatcher.dispose()
+      await result
+      expect(settled).toBe(true)
+    } finally {
+      harness.dispose()
+    }
+  })
+
+  it('keeps fixed bulk behind retained producers and sends it once', async () => {
+    const harness = createBulkWriteHarness()
+    try {
+      const producerFrames = harness.fillProducerQueue()
+      let settled = false
+      const result = harness.dispatcher
+        .notifyBulk('fs.streamChunk', { streamId: 1, data: 'fixed' })
+        .then(() => {
+          settled = true
+        })
+      await nextBulkWriteTurn()
+      expect(harness.frames.some((frame) => frame.method === 'fs.streamChunk')).toBe(false)
+      await harness.reachBulk('fs.streamChunk')
+      expect(harness.frames.filter((frame) => frame.method === 'pty.data')).toHaveLength(
+        producerFrames
+      )
+      expect(settled).toBe(false)
+      await harness.releaseOne()
+      await result
+      expect(harness.frames.filter((frame) => frame.method === 'fs.streamChunk')).toEqual([
+        { method: 'fs.streamChunk' }
+      ])
+    } finally {
+      harness.dispose()
+    }
+  })
+})
diff --git a/src/relay/dispatcher-bulk-failed-admission.test.ts b/src/relay/dispatcher-bulk-failed-admission.test.ts
new file mode 100644
index 000000000000..3d207b0b1b93
--- /dev/null
+++ b/src/relay/dispatcher-bulk-failed-admission.test.ts
@@ -0,0 +1,56 @@
+import { expect, it } from 'vitest'
+import { RelayDispatcher } from './dispatcher'
+import type { PreparedRelayFrame, RelayClient } from './dispatcher-contract'
+import type { SinkWriteSettlement } from './dispatcher-client-writer'
+
+class FailedAdmissionDispatcher extends RelayDispatcher {
+  attempts = 0
+
+  wake(): void {
+    this.notifyLegacyCapacityIfLow()
+  }
+
+  listeners(): number {
+    return this.legacyCapacityListeners.size
+  }
+
+  protected override publishPreparedToClient(
+    client: RelayClient,
+    frame: PreparedRelayFrame,
+    lane: 'interactive' | 'ordinary' | 'fixed-bulk' | 'bulk',
+    onSettled: (result: SinkWriteSettlement) => void = () => {}
+  ): boolean {
+    this.attempts++
+    if (this.attempts === 1) {
+      return false
+    }
+    if (this.attempts === 2) {
+      this.notifyLegacyCapacityIfLow()
+      return false
+    }
+    if (this.attempts > 6) {
+      throw new Error('Admission retry did not remain bounded')
+    }
+    return super.publishPreparedToClient(client, frame, lane, onSettled)
+  }
+}
+
+it('preserves a capacity wake during a failed admission without needing another event', async () => {
+  let writes = 0
+  const dispatcher = new FailedAdmissionDispatcher(() => {
+    writes++
+    return true
+  })
+  try {
+    const completion = dispatcher.notifyBulk('git.responseChunk', { streamId: 1, seq: 0 })
+    await new Promise<void>((resolve) => setImmediate(resolve))
+    expect(dispatcher.attempts).toBe(1)
+    dispatcher.wake()
+    expect(dispatcher.attempts).toBe(3)
+    await completion
+    expect(writes).toBe(1)
+    expect(dispatcher.listeners()).toBe(0)
+  } finally {
+    dispatcher.dispose()
+  }
+})
diff --git a/src/relay/dispatcher-bulk-retirement-admission.test.ts b/src/relay/dispatcher-bulk-retirement-admission.test.ts
new file mode 100644
index 000000000000..d0d026088e4e
--- /dev/null
+++ b/src/relay/dispatcher-bulk-retirement-admission.test.ts
@@ -0,0 +1,48 @@
+import { expect, it } from 'vitest'
+import { createBulkWriteHarness, nextBulkWriteTurn } from './dispatcher-bulk-write-test-harness'
+
+it('admits each bulk frame once when retiring PTY writes releases capacity during admission', async () => {
+  const calibration = createBulkWriteHarness()
+  let capacity: number
+  try {
+    capacity = calibration.fillProducerQueue('live')
+  } finally {
+    calibration.dispose()
+  }
+
+  const failures: { retired: number; sequences: (number | undefined)[] }[] = []
+  let admissionRetryWakeCount = 0
+  const midpoint = Math.floor(capacity / 2)
+  for (let retired = midpoint - 100; retired <= midpoint + 20; retired++) {
+    const harness = createBulkWriteHarness()
+    let ptyAdmitted = true
+    harness.dispatcher.registerPtyDataPublicationAdmission(
+      (_client, params) => ptyAdmitted || params.id !== 'dying'
+    )
+    try {
+      harness.fillProducerQueue('live', capacity - retired)
+      harness.fillProducerQueue('dying', retired)
+      const completion = harness.dispatcher.notifyBulk('git.responseChunk', {
+        streamId: 1,
+        seq: 0,
+        data: 'g'.repeat(40 * 1024)
+      })
+      await nextBulkWriteTurn()
+      expect(harness.dispatcher.capacityRetryCount).toBe(1)
+      ptyAdmitted = false
+      await harness.drain()
+      await completion
+      admissionRetryWakeCount += harness.dispatcher.admissionRetryWakeCount
+      const sequences = harness.frames
+        .filter((frame) => frame.method === 'git.responseChunk')
+        .map((frame) => frame.seq)
+      if (sequences.length !== 1 || sequences[0] !== 0) {
+        failures.push({ retired, sequences })
+      }
+    } finally {
+      harness.dispose()
+    }
+  }
+  expect(failures).toEqual([])
+  expect(admissionRetryWakeCount).toBeGreaterThan(0)
+})
diff --git a/src/relay/dispatcher-bulk-write-test-harness.ts b/src/relay/dispatcher-bulk-write-test-harness.ts
new file mode 100644
index 000000000000..29f1c02d4f8f
--- /dev/null
+++ b/src/relay/dispatcher-bulk-write-test-harness.ts
@@ -0,0 +1,192 @@
+import { Writable } from 'node:stream'
+import { RelayDispatcher } from './dispatcher'
+import type { PreparedRelayFrame, RelayClient } from './dispatcher-contract'
+import type { DispatcherWriterLane, SinkWriteSettlement } from './dispatcher-client-writer'
+import { FrameDecoder, MessageType, parseJsonRpcMessage } from './protocol'
+
+type WrittenFrame = { method: string; seq?: number }
+type PendingWrite = { frame: WrittenFrame; complete: (error?: Error | null) => void }
+type FixedBulkAdmission = {
+  clientClosed: boolean
+  writerCanAdmitZero: boolean
+  retainedProducerBytes: number
+  settledBeforeReturn: boolean
+  accepted: boolean
+}
+export const nextBulkWriteTurn = (): Promise<void> =>
+  new Promise((resolve) => setImmediate(resolve))
+
+class BulkWriteDispatcher extends RelayDispatcher {
+  admissionRetryWakeCount = 0
+  fixedBulkAdmissions: FixedBulkAdmission[] = []
+  lastCapacityRetry: (() => void) | null = null
+  private bulkAdmissionDepth = 0
+  private consecutiveFixedBulkRejections = 0
+
+  get capacityRetryCount(): number {
+    return this.legacyCapacityListeners.size
+  }
+
+  get retainedPublicationBytes(): number {
+    return this.publicationLedger.retainedBytes
+  }
+
+  override onLegacyPtyCapacity(listener: () => void): () => void {
+    this.lastCapacityRetry = listener
+    return super.onLegacyPtyCapacity(listener)
+  }
+
+  protected override publishPreparedToClient(
+    client: RelayClient,
+    frame: PreparedRelayFrame,
+    lane: 'interactive' | 'ordinary' | 'fixed-bulk' | 'bulk',
+    onSettled: (result: SinkWriteSettlement) => void = () => {}
+  ): boolean {
+    if (lane !== 'bulk') {
+      return super.publishPreparedToClient(client, frame, lane, onSettled)
+    }
+    this.bulkAdmissionDepth++
+    try {
+      return super.publishPreparedToClient(client, frame, lane, onSettled)
+    } finally {
+      this.bulkAdmissionDepth--
+    }
+  }
+
+  protected override notifyLegacyCapacityIfLow(): void {
+    if (
+      this.bulkAdmissionDepth > 0 &&
+      this.capacityRetryCount > 0 &&
+      this.legacyRetentionBelowLowWater
+    ) {
+      this.admissionRetryWakeCount++
+    }
+    super.notifyLegacyCapacityIfLow()
+  }
+
+  protected override enqueuePreparedFrame(
+    client: RelayClient,
+    frame: PreparedRelayFrame,
+    lane: DispatcherWriterLane,
+    onSettled: (result: SinkWriteSettlement) => void = () => {},
+    controlOverflow: 'close-client' | 'reject' = 'close-client'
+  ): boolean {
+    if (lane !== 'fixed-bulk') {
+      return super.enqueuePreparedFrame(client, frame, lane, onSettled, controlOverflow)
+    }
+    if (this.consecutiveFixedBulkRejections >= 4) {
+      throw new Error('Settled fixed-bulk admission retried during writer teardown')
+    }
+    const before = {
+      clientClosed: client.closed,
+      writerCanAdmitZero: client.writer.canEnqueueProducer(0),
+      retainedProducerBytes: client.writer.retainedProducerBytes
+    }
+    let settledBeforeReturn = false
+    const accepted = super.enqueuePreparedFrame(
+      client,
+      frame,
+      lane,
+      (result) => {
+        settledBeforeReturn = true
+        onSettled(result)
+      },
+      controlOverflow
+    )
+    this.fixedBulkAdmissions.push({ ...before, settledBeforeReturn, accepted })
+    this.consecutiveFixedBulkRejections = accepted ? 0 : this.consecutiveFixedBulkRejections + 1
+    return accepted
+  }
+}
+
+export function createBulkWriteHarness(highWaterMark = 64 * 1024, producerDataLength = 1024) {
+  const frames: WrittenFrame[] = []
+  const pending: PendingWrite[] = []
+  const sink = new Writable({
+    highWaterMark,
+    write(bytes: Buffer, _encoding, complete) {
+      let frame: WrittenFrame | undefined
+      const decoder = new FrameDecoder((decoded) => {
+        if (decoded.type !== MessageType.Regular) {
+          return
+        }
+        const message = parseJsonRpcMessage(decoded.payload)
+        if (!('method' in message)) {
+          return
+        }
+        frame = {
+          method: message.method,
+          ...(typeof message.params?.seq === 'number' ? { seq: message.params.seq } : {})
+        }
+      })
+      decoder.feed(bytes)
+      if (!frame) {
+        throw new Error('Expected one notification frame')
+      }
+      frames.push(frame)
+      pending.push({ frame, complete })
+    }
+  })
+  sink.on('error', () => {})
+  const dispatcher = new BulkWriteDispatcher(
+    (bytes, settled) =>
+      sink.write(bytes, (error) => settled(error ? { ok: false, error } : { ok: true })),
+    {
+      supportsWriteCallback: true,
+      writableLength: () => sink.writableLength,
+      writableHighWaterMark: () => sink.writableHighWaterMark,
+      waitWriteDrain: (callback) => {
+        sink.once('drain', callback)
+        return () => sink.off('drain', callback)
+      }
+    }
+  )
+  return {
+    dispatcher,
+    sink,
+    frames,
+    pending,
+    fillProducerQueue(id = 'test-pty', limit = Number.POSITIVE_INFINITY): number {
+      let admitted = 0
+      const params = { id, data: 'p'.repeat(producerDataLength) }
+      while (admitted < limit && dispatcher.tryNotifyPtyData(params)) {
+        admitted++
+      }
+      return admitted
+    },
+    async releaseOne(error?: Error): Promise<void> {
+      pending.shift()?.complete(error)
+      await nextBulkWriteTurn()
+    },
+    async reachBulk(method: string): Promise<void> {
+      for (let count = 0; count < 3000; count++) {
+        if (pending[0]?.frame.method === method) {
+          return
+        }
+        if (!pending.length) {
+          throw new Error('No pending write before bulk admission')
+        }
+        pending.shift()?.complete()
+        await nextBulkWriteTurn()
+      }
+      throw new Error('Bulk write did not arrive within admitted queue bound')
+    },
+    async drain(): Promise<void> {
+      for (let count = 0; count < 4000; count++) {
+        if (!pending.length) {
+          await nextBulkWriteTurn()
+          if (!pending.length) {
+            return
+          }
+        }
+        pending.shift()?.complete()
+        await nextBulkWriteTurn()
+      }
+      throw new Error('Sink did not drain within admitted queue bound')
+    },
+    dispose(): void {
+      dispatcher.dispose()
+      sink.destroy()
+    }
+  }
+}
diff --git a/src/relay/dispatcher-producer-transport.ts b/src/relay/dispatcher-producer-transport.ts
index 089a69577d1e..5c1b721531cf 100644
--- a/src/relay/dispatcher-producer-transport.ts
+++ b/src/relay/dispatcher-producer-transport.ts
@@ -113,31 +113,43 @@ export abstract class RelayDispatcherProducerTransport extends RelayDispatcherRp
     }
     return new Promise<void>((resolve, reject) => {
       let removeCapacityListener: (() => void) | null = null
+      let retryFinished = false
       const finish = (): void => {
+        retryFinished = true
         removeCapacityListener?.()
         removeCapacityListener = null
       }
       const tryPublish = (): void => {
-        if (this.disposed || client.closed) {
-          finish()
-          resolve()
-          return
-        }
-        if (
-          this.publishPreparedToClient(client, frame, lane, (result) => {
+        // Retiring queued PTY output can release capacity before admission returns.
+        this.runPublicationTransaction(() => {
+          if (retryFinished) {
+            return
+          }
+          if (this.disposed || client.closed) {
             finish()
-            if (result.ok || this.disposed || client.closed) {
-              resolve()
-            } else {
-              reject(result.error)
-            }
-          })
-        ) {
-          return
-        }
-        if (!removeCapacityListener) {
-          removeCapacityListener = this.onLegacyPtyCapacity(tryPublish)
-        }
+            resolve()
+            return
+          }
+          if (
+            this.publishPreparedToClient(client, frame, lane, (result) => {
+              finish()
+              if (result.ok || this.disposed || client.closed) {
+                resolve()
+              } else {
+                reject(result.error)
+              }
+            })
+          ) {
+            finish()
+            return
+          }
+          if (retryFinished) {
+            return
+          }
+          if (!removeCapacityListener) {
+            removeCapacityListener = this.onLegacyPtyCapacity(tryPublish)
+          }
+        })
       }
       tryPublish()
     })

From 8ae5264c6383366c99a7852a928a38acff6607f7 Mon Sep 17 00:00:00 2001
From: Neil <neil@stably.ai>
Date: Wed, 7 Oct 2026 22:07:47 -0700
Subject: [PATCH 17/17] Record confirmed PR observations from their terminal
 pane

---
 .../gh-bridge-pull-requests-and-work-items.ts |   1 +
 src/preload/api/github-work-item-api.ts       |   1 +
 .../parked-terminal-byte-watcher.test.ts      |   6 +-
 .../parked-terminal-byte-watcher.ts           |  14 +-
 .../pty-connection-fresh-spawn-guards.test.ts |   3 +-
 ...nection-main-side-effect-authority.test.ts |   6 +-
 .../pty-connection/live-data-callback.ts      |   8 +-
 .../pty-connection/terminal-keydown-fit.ts    |   8 +-
 .../github-work-item-source-lookup.test.ts    |  64 ++-
 .../src/lib/github-work-item-source-lookup.ts |   1 +
 ...rees-terminal-pr-exact-observation.test.ts | 153 +++++++
 .../worktrees-terminal-pr-url-linking.test.ts | 224 +++++++----
 ...rktrees-terminal-reference-origins.test.ts | 375 ++++++++++++++++++
 ...ees-terminal-reference-source-race.test.ts | 119 ++++++
 src/renderer/src/store/slices/worktrees.ts    |   6 +-
 .../session/worktree-terminal-reference.ts    | 227 +++++++++++
 .../session/worktree-unread-activity.ts       |  75 ----
 17 files changed, 1116 insertions(+), 175 deletions(-)
 create mode 100644 src/renderer/src/store/slices/worktrees-terminal-pr-exact-observation.test.ts
 create mode 100644 src/renderer/src/store/slices/worktrees-terminal-reference-origins.test.ts
 create mode 100644 src/renderer/src/store/slices/worktrees-terminal-reference-source-race.test.ts
 create mode 100644 src/renderer/src/store/slices/worktrees/session/worktree-terminal-reference.ts

diff --git a/src/preload/api/gh-bridge-pull-requests-and-work-items.ts b/src/preload/api/gh-bridge-pull-requests-and-work-items.ts
index 3e4a5f6ce2a9..22294f6dc4e3 100644
--- a/src/preload/api/gh-bridge-pull-requests-and-work-items.ts
+++ b/src/preload/api/gh-bridge-pull-requests-and-work-items.ts
@@ -59,6 +59,7 @@ export const ghPullRequestsAndWorkItemsApi = {
   workItemByOwnerRepo: (args: {
     repoPath: string
     repoId?: string | null
+    sourceContext?: TaskSourceContext | null
     owner: string
     repo: string
     host?: string
diff --git a/src/preload/api/github-work-item-api.ts b/src/preload/api/github-work-item-api.ts
index db5842eb2cfb..47a098e2cdc7 100644
--- a/src/preload/api/github-work-item-api.ts
+++ b/src/preload/api/github-work-item-api.ts
@@ -65,6 +65,7 @@ export type GithubWorkItemApi = {
   workItemByOwnerRepo: (args: {
     repoPath: string
     repoId?: string
+    sourceContext?: TaskSourceContext | null
     owner: string
     repo: string
     host?: string
diff --git a/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.test.ts b/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.test.ts
index 6af428cbead0..03ff9c3e1100 100644
--- a/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.test.ts
+++ b/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.test.ts
@@ -395,7 +395,8 @@ describe('startParkedTerminalByteWatcher', () => {
         url: 'https://github.com/orca-dev/orca/pull/421',
         number: 421,
         slug: { owner: 'orca-dev', repo: 'orca', host: 'github.com' }
-      })
+      }),
+      expect.objectContaining({ tabId: TAB_ID, ptyId: PTY_ID })
     )
     dispose()
   })
@@ -942,7 +943,8 @@ describe('startParkedTerminalByteWatcher', () => {
       expect(mockStoreState.observeTerminalGitHubPullRequestLink).toHaveBeenCalledTimes(1)
       expect(mockStoreState.observeTerminalGitHubPullRequestLink).toHaveBeenCalledWith(
         WORKTREE_ID,
-        link
+        link,
+        expect.objectContaining({ tabId: TAB_ID, ptyId: PTY_ID })
       )
       dispose()
     })
diff --git a/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.ts b/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.ts
index bf09f5351bd3..7ea538bfd56f 100644
--- a/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.ts
+++ b/src/renderer/src/components/terminal-pane/parked-terminal-byte-watcher.ts
@@ -257,7 +257,12 @@ export function startParkedTerminalByteWatcher(
           onCommandCodeWorking: commandStatusPolicy.onCommandCodeWorking,
           onCommandCodeDone: commandStatusPolicy.onCommandCodeDone,
           onPrLink: (link) =>
-            useAppStore.getState().observeTerminalGitHubPullRequestLink(worktreeId, link)
+            useAppStore.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, {
+              tabId,
+              paneKey,
+              ptyId,
+              executionHostId: workspaceOwner?.executionHostId ?? undefined
+            })
         },
         // Why: activation-deferred tabs can start a watcher before any pane restored the title; ordinary parked tabs avoid this IPC.
         restoreTitleOnRegister: options.restoreTitleOnRegister === true
@@ -278,7 +283,12 @@ export function startParkedTerminalByteWatcher(
     commandCodeOutputStatusDetector?.observe(data)
     if (observeTerminalGitHubPRLink) {
       for (const link of observeTerminalGitHubPRLink(data)) {
-        useAppStore.getState().observeTerminalGitHubPullRequestLink(worktreeId, link)
+        useAppStore.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, {
+          tabId,
+          paneKey,
+          ptyId,
+          executionHostId: workspaceOwner?.executionHostId ?? undefined
+        })
       }
     }
   }
diff --git a/src/renderer/src/components/terminal-pane/pty-connection-fresh-spawn-guards.test.ts b/src/renderer/src/components/terminal-pane/pty-connection-fresh-spawn-guards.test.ts
index adf9f511a2c3..b67bb994c51e 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection-fresh-spawn-guards.test.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection-fresh-spawn-guards.test.ts
@@ -431,7 +431,8 @@ describe('connectPanePty', () => {
         url: 'https://github.com/acme/orca/pull/42',
         slug: { owner: 'acme', repo: 'orca', host: 'github.com' },
         number: 42
-      })
+      }),
+      expect.objectContaining({ tabId: 'tab-1' })
     )
   })
 
diff --git a/src/renderer/src/components/terminal-pane/pty-connection-main-side-effect-authority.test.ts b/src/renderer/src/components/terminal-pane/pty-connection-main-side-effect-authority.test.ts
index f96a73320a09..93d8f21918ad 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection-main-side-effect-authority.test.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection-main-side-effect-authority.test.ts
@@ -413,7 +413,11 @@ describe('connectPanePty', () => {
         facts: [{ kind: 'pr-link', link }]
       })
 
-      expect(mockStoreState.observeTerminalGitHubPullRequestLink).toHaveBeenCalledWith('wt-1', link)
+      expect(mockStoreState.observeTerminalGitHubPullRequestLink).toHaveBeenCalledWith(
+        'wt-1',
+        link,
+        expect.objectContaining({ tabId: 'tab-1', ptyId: 'tab-pty' })
+      )
     })
 
     it('does not byte-scan PR links or OSC 133 — facts are the only consumer', async () => {
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/live-data-callback.ts b/src/renderer/src/components/terminal-pane/pty-connection/live-data-callback.ts
index a523576486f5..9a20b78f900f 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/live-data-callback.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/live-data-callback.ts
@@ -1,3 +1,4 @@
+import { makePaneKey } from '../../../../../shared/stable-pane-id'
 import { useAppStore } from '@/store'
 import { takeCurrentTerminalDeliveryCredit } from '@/lib/pane-manager/terminal-delivery-credit'
 import { recordAgentHibernationPaneOutput } from '@/lib/agent-hibernation-output-activity'
@@ -64,7 +65,12 @@ export function bindLiveDataCallback(session: ConnectPanePtySession): void {
     // Why: under main side-effect authority these facts arrive via pty:sideEffect; byte-scanning here would double-fire. Remote PTYs / kill-switch-off keep this path.
     if (!session.mainSideEffectAuthority) {
       for (const link of session.observeTerminalGitHubPRLink(data)) {
-        useAppStore.getState().observeTerminalGitHubPullRequestLink(session.deps.worktreeId, link)
+        useAppStore.getState().observeTerminalGitHubPullRequestLink(session.deps.worktreeId, link, {
+          tabId: session.deps.tabId,
+          paneKey: makePaneKey(session.deps.tabId, session.pane.leafId),
+          ptyId: session.transport.getPtyId(),
+          executionHostId: session.transport.getExecutionHostId?.() ?? undefined
+        })
       }
       session.commandLifecycle.handlePtyData(data)
     }
diff --git a/src/renderer/src/components/terminal-pane/pty-connection/terminal-keydown-fit.ts b/src/renderer/src/components/terminal-pane/pty-connection/terminal-keydown-fit.ts
index f998a1c97fa6..46e944dd99fa 100644
--- a/src/renderer/src/components/terminal-pane/pty-connection/terminal-keydown-fit.ts
+++ b/src/renderer/src/components/terminal-pane/pty-connection/terminal-keydown-fit.ts
@@ -1,3 +1,4 @@
+import { makePaneKey } from '../../../../../shared/stable-pane-id'
 import { useAppStore } from '@/store'
 import { safeFit } from '@/lib/pane-manager/pane-tree-ops'
 import { bindPanePtyId, getFitOverrideForPty } from '@/lib/pane-manager/mobile-fit-overrides'
@@ -133,7 +134,12 @@ export function installTerminalKeydownFit(session: ConnectPanePtySession): void
         onPrLink: (link) =>
           useAppStore
             .getState()
-            .observeTerminalGitHubPullRequestLink(session.deps.worktreeId, link),
+            .observeTerminalGitHubPullRequestLink(session.deps.worktreeId, link, {
+              tabId: session.deps.tabId,
+              paneKey: makePaneKey(session.deps.tabId, session.pane.leafId),
+              ptyId: session.transport.getPtyId(),
+              executionHostId: session.transport.getExecutionHostId?.() ?? undefined
+            }),
         // Why: the Command Code settle policy stays here — the done settle
         // timer must consult the live store row (which hook events and
         // renderer seeds also write), so main only emits scrape facts.
diff --git a/src/renderer/src/lib/github-work-item-source-lookup.test.ts b/src/renderer/src/lib/github-work-item-source-lookup.test.ts
index 432401ce3e50..1abfc34cff54 100644
--- a/src/renderer/src/lib/github-work-item-source-lookup.test.ts
+++ b/src/renderer/src/lib/github-work-item-source-lookup.test.ts
@@ -1,7 +1,10 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { callRuntimeRpc } from '@/runtime/runtime-rpc-client'
 import type * as RuntimeRpcClient from '@/runtime/runtime-rpc-client'
-import { lookupGitHubWorkItemDetailsForSource } from './github-work-item-source-lookup'
+import {
+  lookupGitHubWorkItemDetailsForSource,
+  lookupGitHubWorkItemByOwnerRepoForSource
+} from './github-work-item-source-lookup'
 import type { TaskSourceContext } from '../../../shared/task-source-context'
 
 vi.mock('@/runtime/runtime-rpc-client', async () => {
@@ -26,12 +29,69 @@ describe('GitHub source lookup routing', () => {
     vi.stubGlobal('window', {
       api: {
         gh: {
-          workItemDetails: vi.fn()
+          workItemDetails: vi.fn(),
+          workItemByOwnerRepo: vi.fn().mockResolvedValue(null)
         }
       }
     })
   })
 
+  it.each(['local', 'ssh:build-box'] as const)(
+    'forwards %s source identity to exact repository IPC',
+    async (hostId) => {
+      const sourceContext: TaskSourceContext = { ...runtimeSourceContext, hostId, repoId: 'repo' }
+      await lookupGitHubWorkItemByOwnerRepoForSource({
+        repoPath: '/repo',
+        repoId: 'repo',
+        sourceContext,
+        owner: 'acme',
+        repo: 'orca',
+        host: 'github.com',
+        number: 42,
+        type: 'pr'
+      })
+      expect(window.api.gh.workItemByOwnerRepo).toHaveBeenCalledWith({
+        repoPath: '/repo',
+        repoId: 'repo',
+        sourceContext,
+        owner: 'acme',
+        repo: 'orca',
+        host: 'github.com',
+        number: 42,
+        type: 'pr'
+      })
+      expect(callRuntimeRpc).not.toHaveBeenCalled()
+    }
+  )
+
+  it('routes exact repository lookup to its source runtime instead of local IPC', async () => {
+    vi.mocked(callRuntimeRpc).mockResolvedValue(null)
+    await lookupGitHubWorkItemByOwnerRepoForSource({
+      repoPath: '/repo',
+      repoId: 'renderer-repo',
+      sourceContext: runtimeSourceContext,
+      owner: 'acme',
+      repo: 'orca',
+      host: 'github.com',
+      number: 42,
+      type: 'pr'
+    })
+    expect(callRuntimeRpc).toHaveBeenCalledWith(
+      { kind: 'environment', environmentId: 'env-1' },
+      'github.workItemByOwnerRepo',
+      {
+        repo: 'runtime-repo',
+        owner: 'acme',
+        ownerRepo: 'orca',
+        host: 'github.com',
+        number: 42,
+        type: 'pr'
+      },
+      { timeoutMs: 30_000 }
+    )
+    expect(window.api.gh.workItemByOwnerRepo).not.toHaveBeenCalled()
+  })
+
   it('routes runtime-owned GitHub details through runtime RPC', async () => {
     vi.mocked(callRuntimeRpc).mockResolvedValue(null)
 
diff --git a/src/renderer/src/lib/github-work-item-source-lookup.ts b/src/renderer/src/lib/github-work-item-source-lookup.ts
index da9e37757674..32cb64a505ff 100644
--- a/src/renderer/src/lib/github-work-item-source-lookup.ts
+++ b/src/renderer/src/lib/github-work-item-source-lookup.ts
@@ -83,6 +83,7 @@ export async function lookupGitHubWorkItemByOwnerRepoForSource(
       : await window.api.gh.workItemByOwnerRepo({
           repoPath: args.repoPath,
           repoId: args.repoId,
+          sourceContext: args.sourceContext,
           owner: args.owner,
           repo: args.repo,
           ...(args.host ? { host: args.host } : {}),
diff --git a/src/renderer/src/store/slices/worktrees-terminal-pr-exact-observation.test.ts b/src/renderer/src/store/slices/worktrees-terminal-pr-exact-observation.test.ts
new file mode 100644
index 000000000000..559b35dfeae5
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees-terminal-pr-exact-observation.test.ts
@@ -0,0 +1,153 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
+import type { HostedReviewInfo } from '../../../../shared/hosted-review'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { makeWorktree } from './worktrees-slice-test-fixtures'
+import {
+  createTestStore,
+  resetRemoteRuntimeMocks,
+  resetWorktreeSliceModuleMemory
+} from './worktrees-slice-test-harness'
+
+const { exactLookup } = vi.hoisted(() => ({ exactLookup: vi.fn() }))
+vi.mock('@/lib/github-work-item-source-lookup', () => ({
+  lookupGitHubWorkItemByOwnerRepoForSource: exactLookup
+}))
+const url = 'https://github.com/acme/orca/pull/42'
+const link = { number: 42, url, slug: { owner: 'acme', repo: 'orca' } }
+const secondary: GitHubWorkItem = {
+  id: '42',
+  repoId: 'repo',
+  type: 'pr',
+  number: 42,
+  title: 'Release target',
+  url,
+  state: 'open',
+  branchName: 'feature',
+  headSha: 'abc123',
+  baseRefName: 'release',
+  labels: [],
+  updatedAt: '2026-01-01',
+  author: null
+}
+function setup() {
+  const store = createTestStore()
+  const workspace = makeWorktree({ id: 'repo::/worktree', repoId: 'repo', linkedPR: null })
+  const firstBranchReview: HostedReviewInfo = {
+    provider: 'github',
+    number: 7,
+    title: 'First branch PR',
+    state: 'open',
+    status: 'success',
+    url: 'https://github.com/acme/orca/pull/7',
+    mergeable: 'MERGEABLE',
+    updatedAt: '2026-01-01'
+  }
+  const branchLookup = vi.fn().mockResolvedValue(firstBranchReview)
+  Object.defineProperty(window.api, 'hostedReview', {
+    configurable: true,
+    value: { forBranch: branchLookup }
+  })
+  store.setState({
+    repos: [{ id: 'repo', path: '/repo', displayName: 'Orca', addedAt: 0, badgeColor: '' }],
+    worktreesByRepo: { repo: [workspace] }
+  })
+  return { store, workspace, branchLookup }
+}
+async function flush() {
+  for (let index = 0; index < 30; index++) {
+    await Promise.resolve()
+  }
+}
+beforeEach(() => {
+  vi.clearAllMocks()
+  resetRemoteRuntimeMocks()
+  resetWorktreeSliceModuleMemory()
+  exactLookup.mockReset().mockResolvedValue(secondary)
+})
+
+it('confirms a second PR by exact source and head when branch discovery would return only its first PR', async () => {
+  const { store, workspace, branchLookup } = setup()
+  store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
+  await flush()
+  expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toMatchObject([
+    { provider: 'github', type: 'pr', number: 42 }
+  ])
+  expect(branchLookup).not.toHaveBeenCalled()
+  expect(exactLookup).toHaveBeenCalledWith(
+    expect.objectContaining({
+      owner: 'acme',
+      repo: 'orca',
+      host: 'github.com',
+      number: 42,
+      type: 'pr',
+      sourceContext: expect.objectContaining({ hostId: 'local', repoId: 'repo' })
+    })
+  )
+})
+
+it.each([
+  { type: 'issue' as const },
+  { number: 99 },
+  { url: 'https://github.com/foreign/repo/pull/42' },
+  { branchName: 'unrelated' },
+  { headSha: 'other-head' }
+])(
+  'rejects contradictory exact evidence without using an implicit fallback: %j',
+  async (change) => {
+    const { store, workspace, branchLookup } = setup()
+    exactLookup.mockResolvedValue({ ...secondary, ...change })
+    store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toEqual([])
+    expect(branchLookup).not.toHaveBeenCalled()
+  }
+)
+
+it('does not attach a source rejected by the configured-remote exact lookup', async () => {
+  const { store, workspace, branchLookup } = setup()
+  exactLookup.mockResolvedValue(null)
+  store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
+  await flush()
+  expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toEqual([])
+  expect(branchLookup).toHaveBeenCalledTimes(1)
+})
+
+it.each([false, true])(
+  'checks a saved push branch and its late replacement=%s',
+  async (replace) => {
+    const { store, workspace, branchLookup } = setup()
+    const pending = Promise.withResolvers<GitHubWorkItem | null>()
+    exactLookup.mockReturnValue(pending.promise)
+    const saved = {
+      ...workspace,
+      branch: 'refs/heads/local-copy',
+      pushTarget: { remoteName: 'origin', branchName: 'feature' }
+    }
+    store.setState({ worktreesByRepo: { repo: [saved] } })
+    store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
+    if (replace) {
+      store.setState({
+        worktreesByRepo: {
+          repo: [{ ...saved, pushTarget: { remoteName: 'origin', branchName: 'replacement' } }]
+        }
+      })
+    }
+    pending.resolve(secondary)
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toHaveLength(
+      replace ? 0 : 1
+    )
+    expect(branchLookup).not.toHaveBeenCalled()
+  }
+)
+
+it('retains branch confirmation on an older host without exact head evidence', async () => {
+  const { store, workspace, branchLookup } = setup()
+  exactLookup.mockResolvedValue({ ...secondary, headSha: undefined })
+  branchLookup.mockResolvedValue({ provider: 'github', number: 42, url })
+  store.getState().observeTerminalGitHubPullRequestLink(workspace.id, link)
+  await flush()
+  expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo[0])).toHaveLength(1)
+  expect(branchLookup).toHaveBeenCalledTimes(1)
+})
diff --git a/src/renderer/src/store/slices/worktrees-terminal-pr-url-linking.test.ts b/src/renderer/src/store/slices/worktrees-terminal-pr-url-linking.test.ts
index add4b84c598c..c81255c596c0 100644
--- a/src/renderer/src/store/slices/worktrees-terminal-pr-url-linking.test.ts
+++ b/src/renderer/src/store/slices/worktrees-terminal-pr-url-linking.test.ts
@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { AppState } from '../types'
+import type { HostedReviewInfo, HostedReviewForBranchArgs } from '../../../../shared/hosted-review'
 import { makeWorktree } from './worktrees-slice-test-fixtures'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
 import {
   createTestStore,
   mockApi,
@@ -8,6 +9,26 @@ import {
   resetWorktreeSliceModuleMemory
 } from './worktrees-slice-test-harness'
 
+function installReviewRead() {
+  const read = vi.fn<(args: HostedReviewForBranchArgs) => Promise<HostedReviewInfo | null>>()
+  Object.defineProperty(window.api, 'hostedReview', {
+    configurable: true,
+    value: { forBranch: read }
+  })
+  return read
+}
+
+const confirmedReview = (number: number): HostedReviewInfo => ({
+  provider: 'github',
+  number,
+  title: 'Confirmed',
+  state: 'open',
+  status: 'success',
+  mergeable: 'MERGEABLE',
+  url: `https://github.com/acme/orca/pull/${number}`,
+  updatedAt: '2026-01-01'
+})
+
 const requestWorktreeBaseFallbackNotice = vi.hoisted(() => vi.fn())
 
 vi.mock('sonner', () => ({
@@ -34,7 +55,7 @@ describe('worktree remote runtime mutations', () => {
 
   it('waits for branch confirmation before linking a terminal PR URL for a known push target', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 42 })
+    const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -50,9 +71,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
@@ -63,29 +83,39 @@ describe('worktree remote runtime mutations', () => {
     expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBeNull()
     expect(mockApi.worktrees.resolvePrBase).not.toHaveBeenCalled()
     expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
-    expect(fetchPRForBranch).toHaveBeenCalledWith('/repos/orca', 'feature/pr-link', {
+    await vi.waitFor(() => expect(readHostedReview).toHaveBeenCalled())
+    expect(readHostedReview).toHaveBeenCalledWith({
+      repoPath: '/repos/orca',
+      branch: 'feature/pr-link',
       force: true,
       repoId: 'repo1',
-      worktreeId: wt.id,
-      linkedPRNumber: null,
-      fallbackPRNumber: null,
-      fallbackPRSource: 'explicit',
-      reason: 'active'
+      active: true,
+      repoOwnerExecutionHostId: 'local',
+      currentHeadOid: wt.head,
+      linkedGitHubPR: null,
+      linkedGitLabMR: null,
+      linkedBitbucketPR: null,
+      linkedAzureDevOpsPR: null,
+      linkedGiteaPR: null
     })
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
     expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
       worktreeId: wt.id,
       executionHostId: 'local',
-      updates: { linkedPR: 42, suppressedGitHubPR: null }
+      updates: expect.objectContaining({
+        linkedItems: [{ provider: 'github', type: 'pr', number: 42 }],
+        linkedPR: 42,
+        suppressedGitHubPR: null
+      })
     })
   })
 
   it('ignores a terminal URL matching current GitHub PR suppression', () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 42 })
+    const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -98,9 +128,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
@@ -108,13 +137,13 @@ describe('worktree remote runtime mutations', () => {
       number: 42
     })
 
-    expect(fetchPRForBranch).not.toHaveBeenCalled()
+    expect(readHostedReview).not.toHaveBeenCalled()
     expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
   })
 
   it('allows terminal observation of a different PR than the suppressed one', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 43 })
+    installReviewRead().mockResolvedValue(confirmedReview(43))
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -131,32 +160,35 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/43',
       slug: { owner: 'acme', repo: 'orca' },
       number: 43
     })
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
     expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
       worktreeId: wt.id,
       executionHostId: 'local',
-      updates: { linkedPR: 43, suppressedGitHubPR: null }
+      updates: expect.objectContaining({
+        linkedItems: [{ provider: 'github', type: 'pr', number: 43 }],
+        linkedPR: 43,
+        suppressedGitHubPR: null
+      })
     })
   })
 
   it('rechecks GitHub PR suppression after branch confirmation resolves', async () => {
     const store = createTestStore()
-    let resolveLookup: (value: { number: number } | null) => void = () => {}
-    const fetchPRForBranch = vi.fn(
+    let resolveLookup: (value: HostedReviewInfo | null) => void = () => {}
+    installReviewRead().mockImplementation(
       () =>
-        new Promise<{ number: number } | null>((resolve) => {
+        new Promise<HostedReviewInfo | null>((resolve) => {
           resolveLookup = resolve
         })
     )
@@ -175,23 +207,25 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
       slug: { owner: 'acme', repo: 'orca' },
       number: 42
     })
+    for (let i = 0; i < 20; i++) {
+      await Promise.resolve()
+    }
     store.setState({
       worktreesByRepo: {
         repo1: [{ ...wt, linkedPR: null, suppressedGitHubPR: 42 }]
       }
-    } as Partial<AppState>)
+    })
 
-    resolveLookup({ number: 42 })
-    for (let i = 0; i < 6; i++) {
+    resolveLookup(confirmedReview(42))
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
@@ -200,7 +234,7 @@ describe('worktree remote runtime mutations', () => {
 
   it('waits for branch confirmation before linking a same-repo terminal PR URL', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 42 })
+    const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -215,9 +249,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
@@ -226,32 +259,42 @@ describe('worktree remote runtime mutations', () => {
     })
 
     expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBeNull()
-    expect(fetchPRForBranch).toHaveBeenCalledWith('/repos/orca', 'feature/pr-link', {
+    await vi.waitFor(() => expect(readHostedReview).toHaveBeenCalled())
+    expect(readHostedReview).toHaveBeenCalledWith({
+      repoPath: '/repos/orca',
+      branch: 'feature/pr-link',
       force: true,
       repoId: 'repo1',
-      worktreeId: wt.id,
-      linkedPRNumber: null,
-      fallbackPRNumber: null,
-      fallbackPRSource: 'explicit',
-      reason: 'active'
+      active: true,
+      repoOwnerExecutionHostId: 'local',
+      currentHeadOid: wt.head,
+      linkedGitHubPR: null,
+      linkedGitLabMR: null,
+      linkedBitbucketPR: null,
+      linkedAzureDevOpsPR: null,
+      linkedGiteaPR: null
     })
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
     expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
       worktreeId: wt.id,
       executionHostId: 'local',
-      updates: { linkedPR: 42, suppressedGitHubPR: null }
+      updates: expect.objectContaining({
+        linkedItems: [{ provider: 'github', type: 'pr', number: 42 }],
+        linkedPR: 42,
+        suppressedGitHubPR: null
+      })
     })
   })
 
-  it('does not persist a terminal PR URL when the linked PR changes before branch confirmation resolves', async () => {
+  it('preserves a manual primary while appending a PR confirmed after the selection changes', async () => {
     const store = createTestStore()
-    let resolveLookup: (value: { number: number } | null) => void = () => {}
-    const fetchPRForBranch = vi.fn(
+    let resolveLookup: (value: HostedReviewInfo | null) => void = () => {}
+    installReviewRead().mockImplementation(
       () =>
-        new Promise<{ number: number } | null>((resolve) => {
+        new Promise<HostedReviewInfo | null>((resolve) => {
           resolveLookup = resolve
         })
     )
@@ -269,9 +312,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
@@ -279,23 +321,29 @@ describe('worktree remote runtime mutations', () => {
       number: 42
     })
     expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
+    for (let i = 0; i < 20; i++) {
+      await Promise.resolve()
+    }
 
     store.setState({
       worktreesByRepo: { repo1: [{ ...wt, linkedPR: 7 }] }
-    } as Partial<AppState>)
+    })
 
-    resolveLookup({ number: 42 })
-    for (let i = 0; i < 6; i++) {
+    resolveLookup(confirmedReview(42))
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
     expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBe(7)
-    expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
+    expect(
+      getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0]).map((item) => item.number)
+    ).toEqual([7, 42])
+    expect(mockApi.worktrees.updateMeta).toHaveBeenCalled()
   })
 
-  it('does not persist a terminal PR URL when the linked PR changes while push target lookup resolves', async () => {
+  it('appends a confirmed PR without overwriting a primary changed during push target lookup', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 42 })
+    installReviewRead().mockResolvedValue(confirmedReview(42))
     let resolvePushTarget: (value: {
       baseBranch: string
       pushTarget: { remoteName: string; branchName: string }
@@ -319,9 +367,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/42',
@@ -329,7 +376,7 @@ describe('worktree remote runtime mutations', () => {
       number: 42
     })
 
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
@@ -340,23 +387,26 @@ describe('worktree remote runtime mutations', () => {
 
     store.setState({
       worktreesByRepo: { repo1: [{ ...wt, linkedPR: 7 }] }
-    } as Partial<AppState>)
+    })
 
     resolvePushTarget({
       baseBranch: 'main',
       pushTarget: { remoteName: 'origin', branchName: 'feature/pr-link' }
     })
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
     expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBe(7)
-    expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
+    expect(
+      getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0]).map((item) => item.number)
+    ).toEqual([7, 42])
+    expect(mockApi.worktrees.updateMeta).toHaveBeenCalled()
   })
 
   it('does not link an arbitrary same-repo terminal PR URL for a known push target when lookup misses', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue(null)
+    installReviewRead().mockResolvedValue(null)
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -372,9 +422,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/orca/pull/1',
@@ -382,7 +431,7 @@ describe('worktree remote runtime mutations', () => {
       number: 1
     })
 
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
@@ -393,9 +442,9 @@ describe('worktree remote runtime mutations', () => {
     })
   })
 
-  it('uses branch confirmation before linking a differently named terminal PR URL', async () => {
+  it('rejects a same-number branch result for a different repository URL', async () => {
     const store = createTestStore()
-    const fetchPRForBranch = vi.fn().mockResolvedValue({ number: 42 })
+    const readHostedReview = installReviewRead().mockResolvedValue(confirmedReview(42))
     const wt = makeWorktree({
       id: 'repo1::/path/wt1',
       repoId: 'repo1',
@@ -407,9 +456,8 @@ describe('worktree remote runtime mutations', () => {
       repos: [
         { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
       ],
-      worktreesByRepo: { repo1: [wt] },
-      fetchPRForBranch
-    } as unknown as Partial<AppState>)
+      worktreesByRepo: { repo1: [wt] }
+    })
 
     store.getState().observeTerminalGitHubPullRequestLink(wt.id, {
       url: 'https://github.com/acme/docs/pull/42',
@@ -418,24 +466,26 @@ describe('worktree remote runtime mutations', () => {
     })
 
     expect(store.getState().worktreesByRepo.repo1[0]?.linkedPR).toBeNull()
-    expect(fetchPRForBranch).toHaveBeenCalledWith('/repos/orca', 'feature/pr-link', {
+    await vi.waitFor(() => expect(readHostedReview).toHaveBeenCalled())
+    expect(readHostedReview).toHaveBeenCalledWith({
+      repoPath: '/repos/orca',
+      branch: 'feature/pr-link',
       force: true,
       repoId: 'repo1',
-      worktreeId: wt.id,
-      linkedPRNumber: null,
-      fallbackPRNumber: null,
-      fallbackPRSource: 'explicit',
-      reason: 'active'
+      active: true,
+      repoOwnerExecutionHostId: 'local',
+      currentHeadOid: wt.head,
+      linkedGitHubPR: null,
+      linkedGitLabMR: null,
+      linkedBitbucketPR: null,
+      linkedAzureDevOpsPR: null,
+      linkedGiteaPR: null
     })
 
-    for (let i = 0; i < 6; i++) {
+    for (let i = 0; i < 20; i++) {
       await Promise.resolve()
     }
 
-    expect(mockApi.worktrees.updateMeta).toHaveBeenCalledWith({
-      worktreeId: wt.id,
-      executionHostId: 'local',
-      updates: { linkedPR: 42, suppressedGitHubPR: null }
-    })
+    expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
   })
 })
diff --git a/src/renderer/src/store/slices/worktrees-terminal-reference-origins.test.ts b/src/renderer/src/store/slices/worktrees-terminal-reference-origins.test.ts
new file mode 100644
index 000000000000..9317695c46ad
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees-terminal-reference-origins.test.ts
@@ -0,0 +1,375 @@
+import type { HostedReviewInfo, HostedReviewForBranchArgs } from '../../../../shared/hosted-review'
+import { singlePaneLayoutSnapshot } from './terminal-helpers'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { makeTerminalTab, makeWorktree } from './worktrees-slice-test-fixtures'
+import {
+  createTestStore,
+  resetRemoteRuntimeMocks,
+  resetWorktreeSliceModuleMemory
+} from './worktrees-slice-test-harness'
+import { getWorkspaceAttachments } from '../../../../shared/workspace-attachments'
+import { makePaneKey } from '../../../../shared/stable-pane-id'
+
+function installReviewRead() {
+  const read = vi.fn<(args: HostedReviewForBranchArgs) => Promise<HostedReviewInfo | null>>()
+  Object.defineProperty(window.api, 'hostedReview', {
+    configurable: true,
+    value: { forBranch: read }
+  })
+  return read
+}
+
+const worktreeId = 'repo1::/path/wt1'
+const url = 'https://github.com/acme/orca/pull/42'
+const link = { url, slug: { owner: 'acme', repo: 'orca' }, number: 42 }
+const leaf = '11111111-1111-4111-8111-111111111111'
+const flush = async () => {
+  for (let i = 0; i < 20; i++) {
+    await Promise.resolve()
+  }
+}
+function setup() {
+  const store = createTestStore()
+  const readHostedReview = installReviewRead().mockResolvedValue({
+    provider: 'github',
+    number: 42,
+    title: 'Second PR',
+    state: 'open',
+    url,
+    status: 'success',
+    updatedAt: '2026-01-01',
+    mergeable: 'MERGEABLE'
+  })
+  store.setState({
+    repos: [
+      { id: 'repo1', path: '/repos/orca', displayName: 'orca', badgeColor: '#000', addedAt: 0 }
+    ],
+    worktreesByRepo: {
+      repo1: [
+        makeWorktree({
+          id: worktreeId,
+          repoId: 'repo1',
+          linkedPR: 7,
+          pushTarget: { remoteName: 'origin', branchName: 'feature' },
+          linkedItems: [{ provider: 'github', type: 'pr', number: 7 }]
+        })
+      ]
+    },
+    tabsByWorktree: {
+      [worktreeId]: [
+        makeTerminalTab({ id: 'tab-1', worktreeId, ptyId: 'pty-tab-1' }),
+        makeTerminalTab({ id: 'tab-2', worktreeId, ptyId: 'pty-tab-2' })
+      ]
+    },
+    terminalLayoutsByTabId: {
+      'tab-1': singlePaneLayoutSnapshot(leaf, 'pty-tab-1'),
+      'tab-2': singlePaneLayoutSnapshot(leaf, 'pty-tab-2')
+    },
+    ptyIdsByTabId: { 'tab-1': ['pty-tab-1'], 'tab-2': ['pty-tab-2'] },
+    agentStatusByPaneKey: {}
+  })
+  return { store, readHostedReview }
+}
+const context = (tabId: string) => ({
+  tabId,
+  paneKey: makePaneKey(tabId, leaf),
+  ptyId: `pty-${tabId}`,
+  executionHostId: 'local' as const
+})
+beforeEach(() => {
+  vi.clearAllMocks()
+  resetRemoteRuntimeMocks()
+  resetWorktreeSliceModuleMemory()
+})
+describe('terminal reference evidence', () => {
+  it('retains independently confirmed concurrent PRs when the first becomes the primary', async () => {
+    const { store, readHostedReview } = setup()
+    const initial = store.getState().worktreesByRepo.repo1[0]
+    store.setState({
+      worktreesByRepo: { repo1: [{ ...initial, linkedPR: null, linkedItems: [] }] }
+    })
+    const first = Promise.withResolvers<HostedReviewInfo | null>()
+    const second = Promise.withResolvers<HostedReviewInfo | null>()
+    readHostedReview.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise)
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    store.getState().observeTerminalGitHubPullRequestLink(
+      worktreeId,
+      {
+        ...link,
+        number: 43,
+        url: 'https://github.com/acme/orca/pull/43'
+      },
+      context('tab-2')
+    )
+    const review: HostedReviewInfo = {
+      provider: 'github',
+      number: 42,
+      title: 'Confirmed',
+      state: 'open',
+      url,
+      status: 'success',
+      mergeable: 'MERGEABLE',
+      updatedAt: '2026-01-01'
+    }
+    first.resolve(review)
+    await flush()
+    expect(store.getState().worktreesByRepo.repo1[0].linkedPR).toBe(42)
+    second.resolve({ ...review, number: 43, url: 'https://github.com/acme/orca/pull/43' })
+    await flush()
+    const current = store.getState().worktreesByRepo.repo1[0]
+    expect(current.linkedPR).toBe(42)
+    expect(
+      getWorkspaceAttachments(current).map((item) => [item.number, item.origins?.[0].tabId])
+    ).toEqual([
+      [42, 'tab-1'],
+      [43, 'tab-2']
+    ])
+  })
+
+  it('confirms a secondary review without publishing it into the primary branch cache', async () => {
+    const { store } = setup()
+    const workspace = store.getState().worktreesByRepo.repo1[0]
+    const fetchHostedReviewForBranch = vi.fn()
+    const primary: HostedReviewInfo = {
+      provider: 'github',
+      number: 7,
+      title: 'Primary',
+      state: 'open',
+      url: 'https://github.com/acme/orca/pull/7',
+      status: 'failure',
+      mergeable: 'MERGEABLE',
+      updatedAt: '2026-01-01'
+    }
+    const hostedReviewCache = {
+      'local::repo1::feature': { data: primary, fetchedAt: Date.now() }
+    }
+    store.setState({
+      fetchHostedReviewForBranch,
+      hostedReviewCache,
+      worktreesByRepo: {
+        repo1: [
+          {
+            ...workspace,
+            linkedGitLabMR: null,
+            linkedBitbucketPR: null,
+            linkedAzureDevOpsPR: null,
+            linkedGiteaPR: null,
+            linkedItems: [
+              ...getWorkspaceAttachments(workspace),
+              {
+                provider: 'github',
+                type: 'pr',
+                number: 42
+              }
+            ]
+          }
+        ]
+      }
+    })
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    expect(fetchHostedReviewForBranch).not.toHaveBeenCalled()
+    expect(store.getState().hostedReviewCache).toBe(hostedReviewCache)
+    expect(
+      getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])[1].origins?.[0].tabId
+    ).toBe('tab-1')
+  })
+  it('confirms on the terminal owner when another host has the same repository ID', async () => {
+    const { store } = setup()
+    const repo = store.getState().repos[0]
+    const readHostedReview = installReviewRead().mockResolvedValue({
+      provider: 'github',
+      number: 42,
+      title: 'Confirmed',
+      state: 'open',
+      url,
+      status: 'success',
+      mergeable: 'MERGEABLE',
+      updatedAt: '2026-01-01'
+    })
+    store.setState({
+      repos: [{ ...repo, executionHostId: 'runtime:other' }, repo]
+    })
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    expect(readHostedReview).toHaveBeenCalledWith(
+      expect.objectContaining({
+        repoPath: repo.path,
+        repoId: repo.id,
+        repoOwnerExecutionHostId: 'local'
+      })
+    )
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])[1].origins).toEqual([
+      expect.objectContaining({ hostId: 'local', tabId: 'tab-1' })
+    ])
+  })
+  it('confirms a number-only secondary attachment without requiring it to be the primary review', async () => {
+    const { store } = setup()
+    const workspace = store.getState().worktreesByRepo.repo1[0]
+    const readHostedReview = installReviewRead().mockResolvedValue({
+      provider: 'github',
+      number: 42,
+      title: 'Secondary',
+      state: 'open',
+      url,
+      status: 'success',
+      mergeable: 'MERGEABLE',
+      updatedAt: '2026-01-01'
+    })
+    store.setState({
+      worktreesByRepo: {
+        repo1: [
+          {
+            ...workspace,
+            linkedItems: [
+              ...getWorkspaceAttachments(workspace),
+              {
+                provider: 'github',
+                type: 'pr',
+                number: 42
+              }
+            ]
+          }
+        ]
+      }
+    })
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    expect(readHostedReview).toHaveBeenCalledWith(expect.objectContaining({ linkedGitHubPR: 42 }))
+    const current = store.getState().worktreesByRepo.repo1[0]
+    expect(current.linkedPR).toBe(7)
+    expect(getWorkspaceAttachments(current)[1].origins?.[0].tabId).toBe('tab-1')
+  })
+  it('rejects a different provider returned by owner-scoped branch confirmation', async () => {
+    const { store } = setup()
+    installReviewRead().mockResolvedValue({
+      provider: 'gitlab',
+      number: 42,
+      title: 'Other provider',
+      state: 'open',
+      url,
+      status: 'success',
+      mergeable: 'MERGEABLE',
+      updatedAt: '2026-01-01'
+    })
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
+  })
+  it('adds a second confirmed PR without changing which review is used for checks', async () => {
+    const { store } = setup()
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    const workspace = store.getState().worktreesByRepo.repo1[0]
+    expect(workspace.linkedPR).toBe(7)
+    expect(getWorkspaceAttachments(workspace).map((item) => item.number)).toEqual([7, 42])
+    expect(getWorkspaceAttachments(workspace)[1].origins).toEqual([
+      expect.objectContaining({ kind: 'observed', tabId: 'tab-1', hostId: 'local' })
+    ])
+  })
+  it('records two terminals for one PR and keeps repeated evidence deduplicated', async () => {
+    const { store, readHostedReview } = setup()
+    for (const tabId of ['tab-1', 'tab-2', 'tab-2']) {
+      store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context(tabId))
+      await flush()
+    }
+    expect(
+      getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])[1].origins?.map(
+        (origin) => origin.tabId
+      )
+    ).toEqual(['tab-1', 'tab-2'])
+    expect(readHostedReview.mock.calls.filter(([args]) => args.active === true)).toHaveLength(1)
+  })
+  it('does not associate a same-number PR from a different repository', async () => {
+    const { store } = setup()
+    store
+      .getState()
+      .observeTerminalGitHubPullRequestLink(
+        worktreeId,
+        { ...link, url: 'https://github.com/other/repo/pull/42' },
+        context('tab-1')
+      )
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
+  })
+  it('does not write after a failed confirmation', async () => {
+    const { store, readHostedReview } = setup()
+    readHostedReview.mockRejectedValue(new Error('Offline'))
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
+    expect(warning).toHaveBeenCalled()
+    warning.mockRestore()
+  })
+  it('ignores a stale PTY even when its caller supplies an execution host', async () => {
+    const { store, readHostedReview } = setup()
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, {
+      ...context('tab-1'),
+      ptyId: 'old-pty'
+    })
+    await flush()
+    expect(readHostedReview).not.toHaveBeenCalled()
+  })
+  it('does not attribute a delayed confirmation after the pane is rebound', async () => {
+    const { store, readHostedReview } = setup()
+    let complete: (value: Awaited<ReturnType<typeof readHostedReview>>) => void = () => {}
+    readHostedReview.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          complete = resolve
+        })
+    )
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    store.setState({
+      terminalLayoutsByTabId: { 'tab-1': singlePaneLayoutSnapshot(leaf, 'replacement-pty') }
+    })
+    complete({
+      provider: 'github',
+      number: 42,
+      title: 'Second PR',
+      state: 'open',
+      url,
+      status: 'success',
+      updatedAt: '2026-01-01',
+      mergeable: 'MERGEABLE'
+    })
+    await flush()
+    expect(getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0])).toHaveLength(1)
+  })
+  it('keeps a pending observation when only the terminal label changes', async () => {
+    const { store, readHostedReview } = setup()
+    const confirmed = await readHostedReview({ repoPath: '/repo', branch: 'branch' })
+    let complete: (value: typeof confirmed) => void = () => {}
+    readHostedReview.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          complete = resolve
+        })
+    )
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, context('tab-1'))
+    await flush()
+    store.setState({
+      tabsByWorktree: {
+        [worktreeId]: store
+          .getState()
+          .tabsByWorktree[worktreeId].map((tab) => ({ ...tab, customTitle: 'Renamed' }))
+      }
+    })
+    complete(confirmed)
+    await flush()
+    expect(
+      getWorkspaceAttachments(store.getState().worktreesByRepo.repo1[0]).map((item) => item.number)
+    ).toEqual([7, 42])
+  })
+  it('rejects an explicit host that disagrees with the PTY owner', async () => {
+    const { store, readHostedReview } = setup()
+    store.getState().observeTerminalGitHubPullRequestLink(worktreeId, link, {
+      ...context('tab-1'),
+      executionHostId: 'ssh:other'
+    })
+    await flush()
+    expect(readHostedReview).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/store/slices/worktrees-terminal-reference-source-race.test.ts b/src/renderer/src/store/slices/worktrees-terminal-reference-source-race.test.ts
new file mode 100644
index 000000000000..a07d78a52b33
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees-terminal-reference-source-race.test.ts
@@ -0,0 +1,119 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import type { HostedReviewInfo } from '../../../../shared/hosted-review'
+import type { Repo } from '../../../../shared/repo-types'
+import { bumpProviderRuntimeSessionGeneration } from '@/lib/provider-runtime-context'
+import { makeWorktree } from './worktrees-slice-test-fixtures'
+import {
+  createTestStore,
+  mockApi,
+  resetRemoteRuntimeMocks,
+  resetWorktreeSliceModuleMemory
+} from './worktrees-slice-test-harness'
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  resetRemoteRuntimeMocks()
+  resetWorktreeSliceModuleMemory()
+})
+
+it.each([
+  'remote',
+  'account',
+  'path',
+  'removed',
+  'instance',
+  'head',
+  'credentials',
+  'label'
+] as const)('rechecks %s before persisting delayed terminal confirmation', async (change) => {
+  const store = createTestStore()
+  const workspace = makeWorktree({ id: 'repo::/worktree', repoId: 'repo', linkedPR: null })
+  const repo: Repo = {
+    id: 'repo',
+    path: '/repo',
+    displayName: 'Orca',
+    addedAt: 0,
+    badgeColor: '',
+    gitRemoteIdentity: {
+      canonicalKey: 'github.com/acme/orca',
+      remoteName: 'origin',
+      remoteUrl: 'https://github.com/acme/orca.git'
+    }
+  }
+  const review: HostedReviewInfo = {
+    provider: 'github',
+    number: 42,
+    title: 'Review',
+    url: 'https://github.com/acme/orca/pull/42',
+    state: 'open',
+    status: 'success',
+    mergeable: 'MERGEABLE',
+    updatedAt: '2026-01-01'
+  }
+  const pending = Promise.withResolvers<HostedReviewInfo | null>()
+  Object.defineProperty(window.api, 'hostedReview', {
+    configurable: true,
+    value: { forBranch: vi.fn(() => pending.promise) }
+  })
+  store.setState({ repos: [repo], worktreesByRepo: { repo: [workspace] } })
+  store.getState().observeTerminalGitHubPullRequestLink(workspace.id, {
+    number: 42,
+    url: review.url,
+    slug: { owner: 'acme', repo: 'orca' }
+  })
+  store.setState({
+    repos:
+      change === 'removed'
+        ? []
+        : [
+            {
+              ...repo,
+              ...(change === 'remote'
+                ? {
+                    gitRemoteIdentity: {
+                      ...repo.gitRemoteIdentity,
+                      canonicalKey: 'github.com/other/repo',
+                      remoteName: 'origin',
+                      remoteUrl: 'https://github.com/other/repo.git'
+                    }
+                  }
+                : {}),
+              ...(change === 'account'
+                ? { ghAccount: { host: 'github.com', user: 'another-user' } }
+                : {}),
+              ...(change === 'path' ? { path: '/replacement-repo' } : {}),
+              ...(change === 'label' ? { displayName: 'Renamed' } : {})
+            }
+          ],
+    worktreesByRepo: {
+      repo: [
+        {
+          ...workspace,
+          ...(change === 'head' ? { head: 'new-head' } : {}),
+          ...(change === 'instance'
+            ? {
+                identity: {
+                  key: 'wt2:local:replacement',
+                  executionHostId: 'local' as const,
+                  instanceId: 'replacement'
+                }
+              }
+            : {})
+        }
+      ]
+    }
+  })
+  if (change === 'credentials') {
+    bumpProviderRuntimeSessionGeneration()
+  }
+  pending.resolve(review)
+  for (let i = 0; i < 20; i++) {
+    await Promise.resolve()
+  }
+  if (change === 'label') {
+    expect(mockApi.worktrees.updateMeta).toHaveBeenCalled()
+  } else {
+    expect(mockApi.worktrees.updateMeta).not.toHaveBeenCalled()
+    expect(store.getState().worktreesByRepo.repo[0].linkedPR).toBeNull()
+  }
+})
diff --git a/src/renderer/src/store/slices/worktrees.ts b/src/renderer/src/store/slices/worktrees.ts
index 330d27e7bb2d..873bb72253a4 100644
--- a/src/renderer/src/store/slices/worktrees.ts
+++ b/src/renderer/src/store/slices/worktrees.ts
@@ -1,3 +1,4 @@
+import { createObserveTerminalGitHubPullRequestLink } from './worktrees/session/worktree-terminal-reference'
 import type { StateCreator } from 'zustand'
 import type { AppState } from '../types'
 import type { WorktreeSlice } from './worktree-helpers'
@@ -37,8 +38,7 @@ import { createSetWorktreesPinnedAndReveal } from './worktrees/session/worktree-
 import {
   createBumpWorktreeActivity,
   createClearWorktreeUnread,
-  createMarkWorktreeUnread,
-  createObserveTerminalGitHubPullRequestLink
+  createMarkWorktreeUnread
 } from './worktrees/session/worktree-unread-activity'
 import {
   createMarkWorktreeVisited,
@@ -101,7 +101,7 @@ export const createWorktreeSlice: StateCreator<AppState, [], [], WorktreeSlice>
   updateWorktreesMeta: createUpdateWorktreesMeta(set, get),
   setWorktreesPinnedAndReveal: createSetWorktreesPinnedAndReveal(set, get),
   markWorktreeUnread: createMarkWorktreeUnread(set, get),
-  observeTerminalGitHubPullRequestLink: createObserveTerminalGitHubPullRequestLink(set, get),
+  observeTerminalGitHubPullRequestLink: createObserveTerminalGitHubPullRequestLink(get),
   clearWorktreeUnread: createClearWorktreeUnread(set, get),
   bumpWorktreeActivity: createBumpWorktreeActivity(set, get),
   markWorktreeVisited: createMarkWorktreeVisited(set, get),
diff --git a/src/renderer/src/store/slices/worktrees/session/worktree-terminal-reference.ts b/src/renderer/src/store/slices/worktrees/session/worktree-terminal-reference.ts
new file mode 100644
index 000000000000..31c130dc9c7f
--- /dev/null
+++ b/src/renderer/src/store/slices/worktrees/session/worktree-terminal-reference.ts
@@ -0,0 +1,227 @@
+import type { Repo } from '../../../../../../shared/repo-types'
+import {
+  getRepoExecutionHostId,
+  parseExecutionHostId
+} from '../../../../../../shared/execution-host'
+import { getProviderRuntimeContextKey } from '@/lib/provider-runtime-context'
+import { getRuntimeEnvironmentRevision } from '@/runtime/runtime-environment-revision'
+import type { WorktreeSlice } from '../../worktree-helpers'
+import type { WorktreeSliceGet } from '../listing/worktree-slice-types'
+import { branchName } from '@/lib/git-utils'
+import { resolveTerminalNotificationOwner } from '@/attention/notification-subject-owner'
+import { getWorkspaceAttachmentTerminalOrigin } from '@/lib/workspace-attachment-terminal-origin'
+import { getWorkspaceAttachments } from '../../../../../../shared/workspace-attachments'
+import { getWorkspaceAttachmentKey } from '../../../../../../shared/workspace-attachment-normalization'
+import {
+  getWorkspaceAttachmentOriginKey,
+  mergeWorkspaceAttachmentOrigins
+} from '../../../../../../shared/workspace-attachment-origins'
+import { isGitHubPRSuppressed } from '../../../../../../shared/worktree/github-pr-suppression'
+import type { WorkspaceAttachment, Worktree } from '../../../../../../shared/worktree/types'
+import { findKnownWorktreeById } from '../listing/detected-worktree-meta'
+import { findRepoForHost } from '../../repo-host-identity'
+import { readHostedReviewForRepo } from '@/lib/hosted-review-repo-read'
+import { lookupGitHubWorkItemByOwnerRepoForSource } from '@/lib/github-work-item-source-lookup'
+import { buildTaskSourceContextFromRepo } from '../../../../../../shared/task-source-context'
+
+function terminalReviewSourceKey(repo: Repo | null | undefined): string {
+  const host = repo && parseExecutionHostId(getRepoExecutionHostId(repo))
+  return JSON.stringify([
+    repo?.id,
+    repo?.path,
+    host?.id,
+    repo?.connectionId,
+    repo?.gitRemoteIdentity?.canonicalKey,
+    repo?.ghAccount,
+    getProviderRuntimeContextKey(null),
+    host?.kind === 'runtime' ? getRuntimeEnvironmentRevision(host.environmentId) : null
+  ])
+}
+
+export function createObserveTerminalGitHubPullRequestLink(
+  get: WorktreeSliceGet
+): WorktreeSlice['observeTerminalGitHubPullRequestLink'] {
+  const pending = new Set<string>()
+  return (worktreeId, link, context) => {
+    const state = get()
+    const owner = context ? resolveTerminalNotificationOwner(state, worktreeId, context) : null
+    const hostId = owner?.executionHostId ?? undefined
+    if (context && (!hostId || (context.executionHostId && context.executionHostId !== hostId))) {
+      return
+    }
+    const worktree = findKnownWorktreeById(state, worktreeId, hostId)
+    if (
+      !worktree ||
+      worktree.isBare ||
+      worktree.isArchived ||
+      isGitHubPRSuppressed(worktree, link.number)
+    ) {
+      return
+    }
+    const repo = findRepoForHost(state.repos, worktree.repoId, {
+      hostId: hostId ?? worktree.hostId,
+      settings: state.settings
+    })
+    if (!repo || (repo.kind && repo.kind !== 'git')) {
+      return
+    }
+    const sourceKey = terminalReviewSourceKey(repo)
+    const branch = branchName(worktree.branch)
+    let confirmedPushBranch: string | undefined
+    const origin = context
+      ? getWorkspaceAttachmentTerminalOrigin(state, worktreeId, context, hostId)
+      : undefined
+    if (context && !origin) {
+      return
+    }
+    const contextIsCurrent = (): boolean => {
+      if (!context) {
+        return true
+      }
+      const latest = get()
+      const latestOwner = resolveTerminalNotificationOwner(latest, worktreeId, context)
+      const latestOrigin = getWorkspaceAttachmentTerminalOrigin(latest, worktreeId, context, hostId)
+      return (
+        latestOwner?.executionHostId === hostId &&
+        Boolean(
+          latestOrigin &&
+          origin &&
+          getWorkspaceAttachmentOriginKey(latestOrigin) === getWorkspaceAttachmentOriginKey(origin)
+        )
+      )
+    }
+    const linked = getWorkspaceAttachments(worktree).find(
+      (item) =>
+        item.provider === 'github' &&
+        item.type === 'pr' &&
+        item.number === link.number &&
+        (!item.url || item.url === link.url)
+    )
+    const requestKey = JSON.stringify([hostId, worktreeId, link.url, origin])
+    if (pending.has(requestKey)) {
+      return
+    }
+    const stillEligible = (current: Worktree | undefined): boolean =>
+      Boolean(
+        current &&
+        contextIsCurrent() &&
+        !current.isArchived &&
+        !current.isBare &&
+        current.identity?.key === worktree.identity?.key &&
+        current.head === worktree.head &&
+        terminalReviewSourceKey(
+          findRepoForHost(get().repos, current.repoId, {
+            hostId: hostId ?? current.hostId,
+            settings: get().settings
+          })
+        ) === sourceKey &&
+        current.branch === worktree.branch &&
+        (!confirmedPushBranch || current.pushTarget?.branchName === confirmedPushBranch) &&
+        !isGitHubPRSuppressed(current, link.number)
+      )
+    const persist = async (): Promise<void> => {
+      const current = findKnownWorktreeById(get(), worktreeId, hostId)
+      if (!stillEligible(current)) {
+        return
+      }
+      const items = getWorkspaceAttachments(current)
+      const prior = items.find(
+        (item) =>
+          item.provider === 'github' &&
+          item.type === 'pr' &&
+          item.number === link.number &&
+          (!item.url || item.url === link.url)
+      )
+      if (linked && !prior) {
+        return
+      }
+      if (!origin && prior) {
+        return
+      }
+      const attachment: WorkspaceAttachment = {
+        ...(prior ?? { provider: 'github', type: 'pr', number: link.number }),
+        ...(origin
+          ? { url: link.url, origins: mergeWorkspaceAttachmentOrigins(prior?.origins, [origin]) }
+          : {})
+      }
+      if (prior && JSON.stringify(prior) === JSON.stringify(attachment)) {
+        return
+      }
+      const linkedItems = prior
+        ? items.map((item) =>
+            getWorkspaceAttachmentKey(item) === getWorkspaceAttachmentKey(prior) ? attachment : item
+          )
+        : [...items, attachment]
+      await get().updateWorktreeMeta(
+        worktreeId,
+        { linkedItems },
+        { executionHostId: hostId, shouldApply: stillEligible }
+      )
+    }
+    if (linked?.url === link.url && origin) {
+      pending.add(requestKey)
+      void persist()
+        .catch((error) => console.warn('Could not record reference terminal', error))
+        .finally(() => pending.delete(requestKey))
+      return
+    }
+    pending.add(requestKey)
+    const confirm = async (): Promise<boolean> => {
+      if (!linked) {
+        const exact = await lookupGitHubWorkItemByOwnerRepoForSource({
+          repoPath: repo.path,
+          repoId: repo.id,
+          sourceContext: buildTaskSourceContextFromRepo({
+            provider: 'github',
+            projectId: repo.id,
+            repo
+          }),
+          owner: link.slug.owner,
+          repo: link.slug.repo,
+          host: new URL(link.url).hostname,
+          number: link.number,
+          type: 'pr'
+        }).catch(() => null)
+        if (exact) {
+          const headBranch = exact.branchName?.trim()
+          const headMatches =
+            headBranch === branch || headBranch === worktree.pushTarget?.branchName
+          if (
+            exact.type !== 'pr' ||
+            exact.number !== link.number ||
+            exact.url !== link.url ||
+            (headBranch && !headMatches) ||
+            (exact.headSha && exact.headSha !== worktree.head)
+          ) {
+            return false
+          }
+          if (headBranch && exact.headSha && worktree.head) {
+            confirmedPushBranch = headBranch === branch ? undefined : headBranch
+            return true
+          }
+        }
+      }
+      // Older hosts may omit exact head evidence; retain their branch-confirmation path.
+      const pr = await readHostedReviewForRepo(repo, state.settings, {
+        branch,
+        force: true,
+        active: true,
+        currentHeadOid: worktree.head,
+        linkedGitHubPR: linked ? link.number : null,
+        linkedGitLabMR: null,
+        linkedBitbucketPR: null,
+        linkedAzureDevOpsPR: null,
+        linkedGiteaPR: null
+      })
+      return pr?.provider === 'github' && pr.number === link.number && pr.url === link.url
+    }
+    void confirm()
+      .then(async (confirmed) => {
+        if (confirmed) {
+          await persist()
+        }
+      })
+      .catch((error) => console.warn('Could not confirm terminal reference', error))
+      .finally(() => pending.delete(requestKey))
+  }
+}
diff --git a/src/renderer/src/store/slices/worktrees/session/worktree-unread-activity.ts b/src/renderer/src/store/slices/worktrees/session/worktree-unread-activity.ts
index bea375b8292b..fc8515ab5c3e 100644
--- a/src/renderer/src/store/slices/worktrees/session/worktree-unread-activity.ts
+++ b/src/renderer/src/store/slices/worktrees/session/worktree-unread-activity.ts
@@ -2,8 +2,6 @@ import type { WorktreeSlice } from '../../worktree-helpers'
 import type { WorktreeSliceGet, WorktreeSliceSet } from '../listing/worktree-slice-types'
 import { parseWorkspaceKey } from '../../../../../../shared/workspace-scope'
 import { applyWorktreeUpdates, getRepoIdFromWorktreeId } from '../../worktree-helpers'
-import { branchName } from '@/lib/git-utils'
-import { refreshHostedReviewCard } from '../../hosted-review-card-refresh'
 import {
   applyDetectedWorktreeUpdates,
   findKnownWorktreeById
@@ -16,7 +14,6 @@ import {
 } from '../listing/worktree-owner-settings'
 import { persistWorktreeMeta } from '../metadata/worktree-meta-persist'
 import { isRuntimeSelectorNotFoundError } from '../listing/runtime-worktree-rpc-errors'
-import { isGitHubPRSuppressed } from '../../../../../../shared/worktree/github-pr-suppression'
 
 export function createMarkWorktreeUnread(
   set: WorktreeSliceSet,
@@ -97,78 +94,6 @@ export function createMarkWorktreeUnread(
   }
 }
 
-export function createObserveTerminalGitHubPullRequestLink(
-  _set: WorktreeSliceSet,
-  get: WorktreeSliceGet
-): WorktreeSlice['observeTerminalGitHubPullRequestLink'] {
-  return (worktreeId, link) => {
-    const state = get()
-    const worktree = findKnownWorktreeById(state, worktreeId)
-    if (!worktree || worktree.isBare || worktree.isArchived) {
-      return
-    }
-    const repo = state.repos.find((candidate) => candidate.id === worktree.repoId)
-    if (!repo || (repo.kind && repo.kind !== 'git')) {
-      return
-    }
-    if (
-      isGitHubPRSuppressed(worktree, link.number) ||
-      (typeof worktree.linkedPR === 'number' && worktree.linkedPR !== link.number)
-    ) {
-      return
-    }
-
-    const branch = branchName(worktree.branch)
-    const alreadyLinked = worktree.linkedPR === link.number
-
-    const fetchPRForBranch = get().fetchPRForBranch
-    if (typeof fetchPRForBranch === 'function') {
-      void fetchPRForBranch(repo.path, branch, {
-        force: true,
-        repoId: repo.id,
-        worktreeId,
-        linkedPRNumber: alreadyLinked ? link.number : null,
-        fallbackPRNumber: null,
-        fallbackPRSource: alreadyLinked ? null : 'explicit',
-        reason: 'active'
-      }).then((pr) => {
-        if (!alreadyLinked && pr?.number === link.number) {
-          // Why: terminal output can carry arbitrary PR URLs (docs/agents/logs).
-          // Persist only after branch lookup confirms it and the user hasn't picked another PR mid-flight.
-          void get().updateWorktreeMeta(
-            worktreeId,
-            { linkedPR: link.number },
-            {
-              shouldApply: (currentWorktree) =>
-                Boolean(
-                  currentWorktree &&
-                  !currentWorktree.isBare &&
-                  !currentWorktree.isArchived &&
-                  !isGitHubPRSuppressed(currentWorktree, link.number) &&
-                  (currentWorktree.linkedPR == null || currentWorktree.linkedPR === link.number)
-                )
-            }
-          )
-        }
-      })
-      return
-    }
-
-    const fetchHostedReviewForBranch = get().fetchHostedReviewForBranch
-    if (typeof fetchHostedReviewForBranch === 'function') {
-      // Why: full app stores have fetchPRForBranch (syncs the hosted-review cache); this is only a slice-test fallback.
-      void refreshHostedReviewCard(fetchHostedReviewForBranch, {
-        repoPath: repo.path,
-        repoId: repo.id,
-        branch,
-        linkedGitHubPR: alreadyLinked ? link.number : null,
-        fallbackGitHubPR: null,
-        linkedGitLabMR: worktree.linkedGitLabMR ?? null
-      })
-    }
-  }
-}
-
 export function createClearWorktreeUnread(
   set: WorktreeSliceSet,
   get: WorktreeSliceGet