diff --git a/src/renderer/src/components/task-page-cache-selectors.test.ts b/src/renderer/src/components/task-page-cache-selectors.test.ts
index ef1a0e20efee..81c1f1c139af 100644
--- a/src/renderer/src/components/task-page-cache-selectors.test.ts
+++ b/src/renderer/src/components/task-page-cache-selectors.test.ts
@@ -235,6 +235,38 @@ describe('task page cache selectors', () => {
     ).toBe(origin)
   })
 
+  it('opens the copy the clicked twin host returned, not the other host cached copy', () => {
+    const local = { ...workItem('pr:7', 'twin'), repoHostId: 'local' as const }
+    const remote = { ...local, repoHostId: 'ssh:builder' as const }
+    const cache = {
+      local: entry<GitHubWorkItem[]>([local]),
+      remote: entry<GitHubWorkItem[]>([remote])
+    }
+
+    expect(
+      findTaskPageDialogWorkItem(cache, {
+        id: remote.id,
+        repoId: remote.repoId,
+        url: remote.url,
+        repoHostId: remote.repoHostId
+      })
+    ).toBe(remote)
+  })
+
+  it('keeps each twin host row on its own copy when the cache syncs the table', () => {
+    const local = { ...workItem('pr:7', 'twin'), repoHostId: 'local' as const }
+    const remote = { ...local, repoHostId: 'ssh:builder' as const }
+    const pages = [[local, { ...remote }]]
+
+    const nextPages = reconcileTaskPagePagesWithWorkItemsCache(pages, [
+      entry<GitHubWorkItem[]>([local]),
+      entry<GitHubWorkItem[]>([remote])
+    ])
+
+    expect(nextPages[0]?.map((item) => item.repoHostId)).toEqual(['local', 'ssh:builder'])
+    expect(nextPages[0]?.[1]).toBe(remote)
+  })
+
   it('reconciles paged table rows with patched work-item cache entries', () => {
     const stale = {
       ...workItem('pr-1', 'repo-1'),
diff --git a/src/renderer/src/components/task-page-cache-selectors.ts b/src/renderer/src/components/task-page-cache-selectors.ts
index 7cab1b34ece5..7885009c962f 100644
--- a/src/renderer/src/components/task-page-cache-selectors.ts
+++ b/src/renderer/src/components/task-page-cache-selectors.ts
@@ -29,6 +29,7 @@ export type TaskPageDialogWorkItemKey = {
   id: string
   repoId: string
   url: string
+  repoHostId?: GitHubWorkItem['repoHostId']
 } | null
 
 export type TaskPageRepoSourceState = {
@@ -121,10 +122,6 @@ export function selectTaskPageUnresolvedSourceRepos(
   return unresolved
 }
 
-function taskPageWorkItemCacheKey(item: GitHubWorkItem): string {
-  return `${item.repoId}\u0000${item.id}`
-}
-
 export function reconcileTaskPagePagesWithWorkItemsCache(
   pages: TaskPageWorkItemPages,
   entries: readonly (CacheEntry<readonly GitHubWorkItem[]> | undefined)[]
@@ -132,7 +129,7 @@ export function reconcileTaskPagePagesWithWorkItemsCache(
   const cachedItems = new Map<string, GitHubWorkItem>()
   for (const entry of entries) {
     for (const item of entry?.data ?? []) {
-      cachedItems.set(taskPageWorkItemCacheKey(item), item)
+      cachedItems.set(taskPageWorkItemKey(item), item)
     }
   }
 
@@ -143,7 +140,7 @@ export function reconcileTaskPagePagesWithWorkItemsCache(
     }
     let pageChanged = false
     const nextPage = page.map((item) => {
-      const cached = cachedItems.get(taskPageWorkItemCacheKey(item))
+      const cached = cachedItems.get(taskPageWorkItemKey(item))
       if (!cached || cached === item) {
         return item
       }
@@ -244,7 +241,9 @@ export function findTaskPageDialogWorkItem(
       (wi) =>
         wi.id === dialogWorkItemKey.id &&
         wi.repoId === dialogWorkItemKey.repoId &&
-        wi.url === dialogWorkItemKey.url
+        wi.url === dialogWorkItemKey.url &&
+        // Why: a twin's other host caches the same PR; its copy routes edits to that host.
+        (!dialogWorkItemKey.repoHostId || wi.repoHostId === dialogWorkItemKey.repoHostId)
     )
     if (found) {
       return found
diff --git a/src/renderer/src/components/task-page-work-item-signatures.ts b/src/renderer/src/components/task-page-work-item-signatures.ts
index 8abb2f07a192..9671d1e7fbc3 100644
--- a/src/renderer/src/components/task-page-work-item-signatures.ts
+++ b/src/renderer/src/components/task-page-work-item-signatures.ts
@@ -1,7 +1,8 @@
 import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
 
+// Why the host: a twin's two hosts return the same PR under one repo id.
 export function taskPageWorkItemKey(item: GitHubWorkItem): string {
-  return `${item.repoId}\u0000${item.id}`
+  return `${item.repoId}\u0000${item.repoHostId ?? ''}\u0000${item.id}`
 }
 
 export function sortedStrings(values: readonly string[] | undefined): string {
diff --git a/src/renderer/src/components/task-page/github/Rows.tsx b/src/renderer/src/components/task-page/github/Rows.tsx
index 2597095f5ae6..e0d9a9bfe79d 100644
--- a/src/renderer/src/components/task-page/github/Rows.tsx
+++ b/src/renderer/src/components/task-page/github/Rows.tsx
@@ -1,4 +1,5 @@
 import type { TaskPageComposerActionsModel } from '../../use-task-page-composer-actions'
+import { getGitHubWorkItemRepo } from '@/lib/github-work-item-repo-row'
 import { findGithubWorkItemWorkspaceAttachment } from '@/lib/github-work-item-workspace-attachment'
 import { getWorktreeAttachmentLabel } from '@/lib/worktree-attachment-label'
 import { formatPRDelta } from '@/components/task-page-pr-delta-summary'
@@ -48,7 +49,7 @@ export function TaskPageGitHubRows({
   model: TaskPageComposerActionsModel
 }): React.JSX.Element | null {
   const {
-    repoMap,
+    repos,
     allWorktrees,
     selectedRepos,
     openGitHubDetailPage,
@@ -65,7 +66,7 @@ export function TaskPageGitHubRows({
     <div className="divide-y divide-border/40">
       {!showGitHubTaskSkeletons &&
         filteredWorkItems.map((item) => {
-          const itemRepo = repoMap.get(item.repoId) ?? null
+          const itemRepo = getGitHubWorkItemRepo(repos, item) ?? null
           const attachedWorkspace = findGithubWorkItemWorkspaceAttachment(
             allWorktrees,
             item.repoId,
@@ -106,7 +107,7 @@ export function TaskPageGitHubRows({
             // Why: clickable div not a <button> — it nests buttons, and button-in-button is invalid HTML that breaks hydration.
             <div
               // Why: key on repoId+item.id — repos sharing an upstream reuse item.id, so a bare key collides and React silently drops rows.
-              key={`${item.repoId}:${item.id}`}
+              key={`${item.repoId}:${item.repoHostId ?? ''}:${item.id}`}
               role="button"
               tabIndex={0}
               onClick={() => openGitHubDetailPage(item)}
diff --git a/src/renderer/src/components/task-page/github/rows-twin-host-routing.test.tsx b/src/renderer/src/components/task-page/github/rows-twin-host-routing.test.tsx
new file mode 100644
index 000000000000..02d811430b58
--- /dev/null
+++ b/src/renderer/src/components/task-page/github/rows-twin-host-routing.test.tsx
@@ -0,0 +1,102 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/react'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import type { GitHubWorkItem } from '../../../../../shared/github/work-item-types'
+import type { Repo } from '../../../../../shared/repo-types'
+import type { TaskSourceContext } from '../../../../../shared/task-source-context'
+import type { TaskPageComposerActionsModel } from '../../use-task-page-composer-actions'
+import { TaskPageGitHubRows } from './Rows'
+
+type CellProps = { repo: Repo | null; sourceContext: TaskSourceContext | null }
+const cellProps = vi.hoisted(() => new Map<string, CellProps>())
+vi.mock('./ReviewCell', () => ({
+  PRReviewCell: (props: CellProps) => (cellProps.set('review', props), null)
+}))
+vi.mock('./MergeCell', () => ({
+  PRMergeCell: (props: CellProps) => (cellProps.set('merge', props), null)
+}))
+vi.mock('./StatusCell', () => ({
+  GHStatusCell: (props: CellProps) => (cellProps.set('status', props), null)
+}))
+vi.mock('./AssigneesCell', () => ({
+  GHAssigneesCell: (props: CellProps) => (cellProps.set('assignees', props), null)
+}))
+vi.mock('./ChecksCell', () => ({ PRChecksCell: () => null }))
+
+const sshRow: Repo = {
+  id: 'twin',
+  path: '/remote/twin',
+  displayName: 'Twin',
+  badgeColor: '#000',
+  addedAt: 1,
+  connectionId: 'builder'
+}
+const localRow: Repo = {
+  id: 'twin',
+  path: '/laptop/twin',
+  displayName: 'Twin',
+  badgeColor: '#000',
+  addedAt: 2,
+  executionHostId: 'local'
+}
+const pr: GitHubWorkItem = {
+  id: 'pr-7',
+  type: 'pr',
+  number: 7,
+  title: 'Fix it',
+  state: 'open',
+  url: 'https://github.com/o/r/pull/7',
+  labels: [],
+  updatedAt: '2026-10-20T00:00:00Z',
+  author: 'octo',
+  repoId: 'twin',
+  repoHostId: 'ssh:builder'
+}
+
+function renderRows(item: GitHubWorkItem, showPRManagementColumns: boolean) {
+  const repos = [sshRow, localRow]
+  const model = {
+    repos,
+    // By id a map keeps the last twin, which is the row that did not return the item.
+    repoMap: new Map(repos.map((repo) => [repo.id, repo])),
+    allWorktrees: [],
+    selectedRepos: repos,
+    openGitHubDetailPage: vi.fn(),
+    githubWorkItemMutation: vi.fn(),
+    filteredWorkItems: [item],
+    showGitHubTaskSkeletons: false,
+    showPRManagementColumns,
+    githubTaskGridClass: '',
+    ensurePRChecksLoaded: vi.fn(),
+    handleUseWorkItem: vi.fn(),
+    handleOpenOrUseGitHubWorkItem: vi.fn()
+  }
+  render(
+    <TooltipProvider>
+      {/* oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the rows read only the fields above. */}
+      <TaskPageGitHubRows model={model as unknown as TaskPageComposerActionsModel} />
+    </TooltipProvider>
+  )
+}
+
+afterEach(() => {
+  cleanup()
+  cellProps.clear()
+})
+
+describe('GitHub task rows on a repo id two hosts share', () => {
+  it.each(['review', 'merge'])('%s runs on the host that returned the PR', (cell) => {
+    renderRows(pr, true)
+
+    expect(cellProps.get(cell)?.repo).toBe(sshRow)
+    expect(cellProps.get(cell)?.sourceContext?.hostId).toBe('ssh:builder')
+  })
+
+  it.each(['status', 'assignees'])('%s edits run on the host that returned the item', (cell) => {
+    renderRows({ ...pr, type: 'issue', id: 'issue-7' }, false)
+
+    expect(cellProps.get(cell)?.repo).toBe(sshRow)
+    expect(cellProps.get(cell)?.sourceContext?.hostId).toBe('ssh:builder')
+  })
+})
diff --git a/src/renderer/src/components/use-task-page-github-detail.ts b/src/renderer/src/components/use-task-page-github-detail.ts
index 655accb61d7b..38f9e9043974 100644
--- a/src/renderer/src/components/use-task-page-github-detail.ts
+++ b/src/renderer/src/components/use-task-page-github-detail.ts
@@ -1,5 +1,6 @@
 import type { TaskPageGitHubListStateModel } from './use-task-page-github-list-state'
 import { useAppStore } from '@/store'
+import { getGitHubWorkItemRepo } from '@/lib/github-work-item-repo-row'
 import { useState, useMemo, useLayoutEffect, useCallback, useEffect } from 'react'
 import type { ItemDialogTab } from '@/components/GitHubItemDialog'
 import { stripRepoQualifiers } from '../../../shared/task-query'
@@ -24,6 +25,7 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
   const {
     pageData,
     openTaskPage,
+    repos,
     repoMap,
     selectedRepos,
     primaryRepo,
@@ -50,7 +52,8 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
     ? {
         id: githubTaskDrawerWorkItem.id,
         repoId: githubTaskDrawerWorkItem.repoId,
-        url: githubTaskDrawerWorkItem.url
+        url: githubTaskDrawerWorkItem.url,
+        repoHostId: githubTaskDrawerWorkItem.repoHostId
       }
     : null
   const appliedWorkItemsCacheQuery = useMemo(
@@ -105,7 +108,8 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
     pendingGithubScrollRestoreRef,
     taskListPositionRef
   ])
-  const dialogRepoPath = dialogWorkItem ? (repoMap.get(dialogWorkItem.repoId)?.path ?? null) : null
+  const dialogRepo = dialogWorkItem ? getGitHubWorkItemRepo(repos, dialogWorkItem) : undefined
+  const dialogRepoPath = dialogRepo?.path ?? null
   const dialogSourceContext = useMemo(() => {
     if (!dialogWorkItem) {
       return null
@@ -113,12 +117,13 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
     if (
       pageData.openGitHubSourceContext?.provider === 'github' &&
       pageData.openGitHubWorkItem?.id === dialogWorkItem.id &&
-      pageData.openGitHubWorkItem.repoId === dialogWorkItem.repoId
+      pageData.openGitHubWorkItem.repoId === dialogWorkItem.repoId &&
+      pageData.openGitHubWorkItem.repoHostId === dialogWorkItem.repoHostId
     ) {
       return pageData.openGitHubSourceContext
     }
-    return getTaskPageRepoSourceContext(repoMap.get(dialogWorkItem.repoId), 'github')
-  }, [dialogWorkItem, pageData.openGitHubSourceContext, pageData.openGitHubWorkItem, repoMap])
+    return getTaskPageRepoSourceContext(dialogRepo, 'github')
+  }, [dialogRepo, dialogWorkItem, pageData.openGitHubSourceContext, pageData.openGitHubWorkItem])
   const gitlabDialogRepo = useMemo(
     () =>
       gitlabDialogItem
@@ -178,7 +183,10 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
           taskSource: 'github',
           preselectedRepoId: item.repoId,
           openGitHubWorkItem: item,
-          openGitHubSourceContext: getTaskPageRepoSourceContext(repoMap.get(item.repoId), 'github'),
+          openGitHubSourceContext: getTaskPageRepoSourceContext(
+            getGitHubWorkItemRepo(repos, item),
+            'github'
+          ),
           openGitHubInitialTab: initialTab
         },
         {
@@ -193,7 +201,7 @@ export function useTaskPageGitHubDetail(model: TaskPageGitHubListStateModel) {
       githubResumeContextKey,
       openTaskPage,
       pendingGithubScrollRestoreRef,
-      repoMap,
+      repos,
       taskListPositionRef
     ]
   )
diff --git a/src/renderer/src/components/use-task-page-github-list-projection.ts b/src/renderer/src/components/use-task-page-github-list-projection.ts
index 9c7cdacf8bbd..59ff43e2b5a6 100644
--- a/src/renderer/src/components/use-task-page-github-list-projection.ts
+++ b/src/renderer/src/components/use-task-page-github-list-projection.ts
@@ -1,4 +1,5 @@
 import type { TaskPageJiraCreationMetadataModel } from './use-task-page-jira-creation-metadata'
+import { getGitHubWorkItemRepo } from '@/lib/github-work-item-repo-row'
 import { useCallback, useMemo, useEffect } from 'react'
 import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
 import { taskPageGitHubItemKey } from '@/components/task-page-github-work-item-mutation-registry'
@@ -13,7 +14,7 @@ import {
 import { sameOptionalGitHubOwnerRepo } from './task-page-github-review-model'
 export function useTaskPageGitHubListProjection(model: TaskPageJiraCreationMetadataModel) {
   const {
-    repoMap,
+    repos,
     fetchPRChecks,
     taskSource,
     githubMode,
@@ -102,7 +103,7 @@ export function useTaskPageGitHubListProjection(model: TaskPageJiraCreationMetad
       if (item.type !== 'pr' || item.checksSummary) {
         return
       }
-      const repo = repoMap.get(item.repoId)
+      const repo = getGitHubWorkItemRepo(repos, item)
       if (!repo) {
         return
       }
@@ -134,7 +135,7 @@ export function useTaskPageGitHubListProjection(model: TaskPageJiraCreationMetad
         )
       })
     },
-    [fetchPRChecks, patchTaskPageWorkItemRows, repoMap]
+    [fetchPRChecks, patchTaskPageWorkItemRows, repos]
   )
   useEffect(() => {
     if (taskSource !== 'github' || githubMode !== 'items' || !showPRManagementColumns) {
diff --git a/src/renderer/src/components/use-task-page-workspace-actions-twin-host.test.tsx b/src/renderer/src/components/use-task-page-workspace-actions-twin-host.test.tsx
new file mode 100644
index 000000000000..f974ce4074b8
--- /dev/null
+++ b/src/renderer/src/components/use-task-page-workspace-actions-twin-host.test.tsx
@@ -0,0 +1,56 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { renderHook } from '@testing-library/react'
+import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
+import type { Repo } from '../../../shared/repo-types'
+import type { TaskPageSearchActionsModel } from './use-task-page-search-actions'
+import { useTaskPageWorkspaceActions } from './use-task-page-workspace-actions'
+
+vi.mock('@/store', () => ({
+  useAppStore: { getState: () => ({ recordFeatureInteraction: vi.fn() }) }
+}))
+
+const sshRow: Repo = {
+  id: 'twin',
+  path: '/remote/twin',
+  displayName: 'Twin',
+  badgeColor: '#000',
+  addedAt: 1,
+  connectionId: 'builder'
+}
+const localRow: Repo = { ...sshRow, path: '/laptop/twin', addedAt: 2, connectionId: undefined }
+const pr: GitHubWorkItem = {
+  id: 'pr-7',
+  type: 'pr',
+  number: 7,
+  title: 'Fix it',
+  state: 'open',
+  url: 'https://github.com/o/r/pull/7',
+  labels: [],
+  updatedAt: '2026-10-20T00:00:00Z',
+  author: 'octo',
+  repoId: 'twin',
+  repoHostId: 'ssh:builder'
+}
+
+describe('starting work from a PR card on a repo id two hosts share', () => {
+  it('opens the composer for the host that returned the PR', () => {
+    const openModal = vi.fn()
+    const repos = [sshRow, localRow]
+    // By id a map keeps the last twin, which is the row that did not return the PR.
+    const model = { repos, repoMap: new Map(repos.map((repo) => [repo.id, repo])), openModal }
+    const { result } = renderHook(() =>
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the hook reads only these fields.
+      useTaskPageWorkspaceActions(model as unknown as TaskPageSearchActionsModel)
+    )
+
+    result.current.handleUseWorkItem(pr)
+
+    expect(openModal).toHaveBeenCalledWith(
+      'new-workspace-composer',
+      expect.objectContaining({
+        taskSourceContext: expect.objectContaining({ hostId: 'ssh:builder', repoId: 'twin' })
+      })
+    )
+  })
+})
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 7373643b90c0..25d3bb9d7ac2 100644
--- a/src/renderer/src/components/use-task-page-workspace-actions.ts
+++ b/src/renderer/src/components/use-task-page-workspace-actions.ts
@@ -4,6 +4,7 @@ import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
 import type { GitLabWorkItem } from '../../../shared/gitlab-types'
 import type { LinkedWorkItemSummary } from '@/lib/new-workspace'
 import { useAppStore } from '@/store'
+import { getGitHubWorkItemRepo } from '@/lib/github-work-item-repo-row'
 import { findGithubWorkItemWorkspaceAttachment } from '@/lib/github-work-item-workspace-attachment'
 import { activateAndRevealWorktree } from '@/lib/worktree-activation'
 import { toast } from 'sonner'
@@ -14,7 +15,7 @@ import {
   getTaskPageRepoSourceContext
 } from './task-page-source-context'
 export function useTaskPageWorkspaceActions(model: TaskPageSearchActionsModel) {
-  const { repoMap, openModal } = model
+  const { repos, repoMap, openModal } = model
   const openComposerForItem = useCallback(
     (item: GitHubWorkItem): void => {
       const linkedWorkItem: LinkedWorkItemSummary = {
@@ -32,14 +33,17 @@ export function useTaskPageWorkspaceActions(model: TaskPageSearchActionsModel) {
       openModal('new-workspace-composer', {
         linkedWorkItem,
         initialGitHubWorkItem: item,
-        taskSourceContext: getTaskPageRepoSourceContext(repoMap.get(item.repoId), 'github'),
+        taskSourceContext: getTaskPageRepoSourceContext(
+          getGitHubWorkItemRepo(repos, item),
+          'github'
+        ),
         prefilledName: getGitHubWorkItemWorkspaceSeed(item),
         initialRepoId: item.repoId,
         enableIssueAutomation: item.type === 'issue',
         telemetrySource: 'sidebar'
       })
     },
-    [openModal, repoMap]
+    [openModal, repos]
   )
   const handleUseWorkItem = useCallback(
     (item: GitHubWorkItem): void => {
diff --git a/src/renderer/src/lib/github-work-item-repo-row.test.ts b/src/renderer/src/lib/github-work-item-repo-row.test.ts
new file mode 100644
index 000000000000..d1930123635c
--- /dev/null
+++ b/src/renderer/src/lib/github-work-item-repo-row.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import type { Repo } from '../../../shared/repo-types'
+import { getGitHubWorkItemRepo } from './github-work-item-repo-row'
+
+const localRow: Repo = {
+  id: 'twin',
+  path: '/laptop/twin',
+  displayName: 'Twin',
+  badgeColor: '#000',
+  addedAt: 1
+}
+const sshRow: Repo = { ...localRow, path: '/remote/twin', connectionId: 'builder' }
+const runtimeRow: Repo = { ...localRow, executionHostId: 'runtime:env-1' }
+
+describe('getGitHubWorkItemRepo', () => {
+  it('picks the twin on the stamped host', () => {
+    expect(
+      getGitHubWorkItemRepo([sshRow, localRow], { repoId: 'twin', repoHostId: 'ssh:builder' })
+    ).toBe(sshRow)
+  })
+
+  it('refuses a twin whose stamped host has no row', () => {
+    expect(
+      getGitHubWorkItemRepo([sshRow, localRow], { repoId: 'twin', repoHostId: 'runtime:gone' })
+    ).toBeUndefined()
+  })
+
+  it('keeps a lone row even when the fetch stamped the source host', () => {
+    expect(getGitHubWorkItemRepo([runtimeRow], { repoId: 'twin', repoHostId: 'local' })).toBe(
+      runtimeRow
+    )
+  })
+
+  it('keeps the by-id row for an unstamped item', () => {
+    expect(getGitHubWorkItemRepo([sshRow, localRow], { repoId: 'twin' })).toBe(localRow)
+  })
+})
diff --git a/src/renderer/src/lib/github-work-item-repo-row.ts b/src/renderer/src/lib/github-work-item-repo-row.ts
new file mode 100644
index 000000000000..d12b98d197f3
--- /dev/null
+++ b/src/renderer/src/lib/github-work-item-repo-row.ts
@@ -0,0 +1,27 @@
+import { getRepoExecutionHostId } from '../../../shared/execution-host'
+import type { GitHubWorkItem } from '../../../shared/github/work-item-types'
+import type { Repo } from '../../../shared/repo-types'
+
+/**
+ * The repo row that returned a work item. A stamped item resolves on its own host, so a twin id
+ * never lends it the other host's row; an unstamped one keeps the by-id row a repo map gives.
+ */
+export function getGitHubWorkItemRepo(
+  repos: readonly Repo[],
+  item: Pick<GitHubWorkItem, 'repoId' | 'repoHostId'>
+): Repo | undefined {
+  let byId: Repo | undefined
+  let rowCount = 0
+  for (const repo of repos) {
+    if (repo.id !== item.repoId) {
+      continue
+    }
+    if (item.repoHostId && getRepoExecutionHostId(repo) === item.repoHostId) {
+      return repo
+    }
+    byId = repo
+    rowCount += 1
+  }
+  // Why: only a twin needs the stamp; a lone row stays the item's row whatever it was stamped.
+  return item.repoHostId && rowCount > 1 ? undefined : byId
+}
diff --git a/src/renderer/src/store/github/work-item-aggregate-actions.ts b/src/renderer/src/store/github/work-item-aggregate-actions.ts
index af5ba00a96c3..7837eee86fe0 100644
--- a/src/renderer/src/store/github/work-item-aggregate-actions.ts
+++ b/src/renderer/src/store/github/work-item-aggregate-actions.ts
@@ -28,7 +28,8 @@ import {
   getWorkItemsCacheKeyForOwner,
   isGitHubUnavailableWorkItemsError,
   listGitHubWorkItemsForRepo,
-  getGitHubSourceTarget
+  getGitHubSourceTarget,
+  getGitHubWorkItemRowHostId
 } from './work-item-routing'
 
 export const createWorkItemAggregateActions = (
@@ -160,7 +161,17 @@ export const createWorkItemAggregateActions = (
             failedCount += 1
             return [] as GitHubWorkItem[]
           }
-          return envelope.items.map((item): GitHubWorkItem => ({ ...item, repoId: r.repoId }))
+          const repoHostId = getGitHubWorkItemRowHostId(
+            requestState,
+            r.repoId,
+            r.path,
+            r.sourceContext
+          )
+          return envelope.items.map((item): GitHubWorkItem => ({
+            ...item,
+            repoId: r.repoId,
+            ...(repoHostId ? { repoHostId } : {})
+          }))
         } catch (err) {
           if (isGitHubWorkItemsSshRemoteRequiredError(err)) {
             if (options?.requireComplete) {
diff --git a/src/renderer/src/store/github/work-item-fetch-actions.ts b/src/renderer/src/store/github/work-item-fetch-actions.ts
index 70ac75ef212b..6d3482bb6b7d 100644
--- a/src/renderer/src/store/github/work-item-fetch-actions.ts
+++ b/src/renderer/src/store/github/work-item-fetch-actions.ts
@@ -21,6 +21,7 @@ import { findRepoForGitHubOwner } from './repository-routing'
 import {
   getGitHubWorkItemRequestContext,
   getGitHubWorkItemSourceCacheScope,
+  getGitHubWorkItemRowHostId,
   getGitHubWorkItemSourceHostId,
   getWorkItemsCacheKeyForOwner,
   listGitHubWorkItemsForRepo,
@@ -138,7 +139,17 @@ export const createWorkItemFetchActions = (
           ...(options?.noCache ? { noCache: true } : {})
         })
         // Why: stamp repoId at the fetch boundary so downstream consumers can rely on it — main doesn't know Orca's Repo.id.
-        const items: GitHubWorkItem[] = envelope.items.map((item) => ({ ...item, repoId }))
+        const repoHostId = getGitHubWorkItemRowHostId(
+          requestState,
+          repoId,
+          repoPath,
+          options?.sourceContext
+        )
+        const items: GitHubWorkItem[] = envelope.items.map((item) => ({
+          ...item,
+          repoId,
+          ...(repoHostId ? { repoHostId } : {})
+        }))
         if (options?.requireComplete && (envelope.errors?.issues || envelope.errors?.prs)) {
           throw new Error('GitHub work-item fetch returned a partial result.')
         }
diff --git a/src/renderer/src/store/github/work-item-routing.ts b/src/renderer/src/store/github/work-item-routing.ts
index d0ba72f8c584..d1ae66f231a4 100644
--- a/src/renderer/src/store/github/work-item-routing.ts
+++ b/src/renderer/src/store/github/work-item-routing.ts
@@ -114,6 +114,23 @@ export function getGitHubWorkItemSourceHostId(
     : undefined
 }
 
+/** The host whose row a fetch read, never the focused server: items carry it to their actions. */
+export function getGitHubWorkItemRowHostId(
+  state: Partial<Pick<AppState, 'repos'>>,
+  repoId: string,
+  repoPath: string,
+  sourceContext?: TaskSourceContext | null
+): ExecutionHostId | undefined {
+  const sourceHostId = sourceContext?.provider === 'github' ? sourceContext.hostId : undefined
+  const rows = state.repos?.filter((entry) => entry.id === repoId) ?? []
+  // Why not by id alone: a twin would resolve to whichever row is listed first.
+  const row =
+    rows.find((entry) => getRepoExecutionHostId(entry) === sourceHostId) ??
+    rows.find((entry) => entry.path === repoPath) ??
+    (rows.length === 1 ? rows[0] : undefined)
+  return row ? getRepoExecutionHostId(row) : sourceHostId
+}
+
 export function getGitHubWorkItemSourceCacheScope(
   state: AppState,
   repo: Pick<Repo, 'connectionId' | 'executionHostId'> | undefined,
diff --git a/src/renderer/src/store/slices/github-work-items-twin-host-stamp.test.ts b/src/renderer/src/store/slices/github-work-items-twin-host-stamp.test.ts
new file mode 100644
index 000000000000..0b2eca6e1854
--- /dev/null
+++ b/src/renderer/src/store/slices/github-work-items-twin-host-stamp.test.ts
@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createTestStore, mockApi, resetRemoteRuntimeMocks } from './github-slice-test-harness'
+import type { GitHubWorkItem } from '../../../../shared/github/work-item-types'
+import type { Repo } from '../../../../shared/repo-types'
+
+const localRow: Repo = {
+  id: 'twin',
+  path: '/laptop/twin',
+  displayName: 'Twin',
+  badgeColor: '#000',
+  addedAt: 1
+}
+const sshRow: Repo = { ...localRow, path: '/remote/twin', addedAt: 2, connectionId: 'builder' }
+const item: Omit<GitHubWorkItem, 'repoId'> = {
+  id: 'pr-7',
+  type: 'pr',
+  number: 7,
+  title: 'Fix it',
+  state: 'open',
+  url: 'https://github.com/o/r/pull/7',
+  labels: [],
+  updatedAt: '2026-10-20T00:00:00Z',
+  author: 'octo'
+}
+const sources = {
+  issues: { owner: 'o', repo: 'r' },
+  prs: { owner: 'o', repo: 'r' },
+  originCandidate: { owner: 'o', repo: 'r' },
+  upstreamCandidate: null
+}
+
+describe('work items fetched for a repo id two hosts share', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetRemoteRuntimeMocks()
+    mockApi.gh.listWorkItems.mockResolvedValue({ items: [item], sources })
+  })
+
+  it('carry the host of the row that returned them, on the first page', async () => {
+    const store = createTestStore()
+    store.setState({ repos: [localRow, sshRow] })
+
+    const result = await store
+      .getState()
+      .fetchWorkItemsAcrossRepos([{ repoId: 'twin', path: '/remote/twin' }], 24, 100, '')
+
+    expect(result.items.map((entry) => entry.repoHostId)).toEqual(['ssh:builder'])
+  })
+
+  it('carry the host of the row that returned them, on later pages', async () => {
+    const store = createTestStore()
+    store.setState({ repos: [localRow, sshRow] })
+
+    const result = await store
+      .getState()
+      .fetchWorkItemsNextPage([{ repoId: 'twin', path: '/remote/twin' }], 24, 100, '', 1)
+
+    expect(result.items.map((entry) => entry.repoHostId)).toEqual(['ssh:builder'])
+  })
+})
diff --git a/src/shared/github/work-item-types.ts b/src/shared/github/work-item-types.ts
index 437a1af20f05..3ab4c6593305 100644
--- a/src/shared/github/work-item-types.ts
+++ b/src/shared/github/work-item-types.ts
@@ -1,4 +1,5 @@
 import type { ClassifiedError } from '../classified-error'
+import type { ExecutionHostId } from '../execution-host'
 import type { PRCheckDetail } from './check-types'
 import type { GitHubIssueTimelineItem, PRComment } from './comment-types'
 import type {
@@ -58,6 +59,9 @@ export type GitHubWorkItem = {
    *  to know which repo an item came from. Stamped by the renderer fetcher
    *  (`fetchWorkItems`) and by optimistic stubs on the new-issue path. */
   repoId: string
+  /** Why: one repo id can name a row on two hosts. The renderer fetcher stamps the host whose row
+   *  returned the item, so its actions run there, not on whichever twin a by-id lookup finds. */
+  repoHostId?: ExecutionHostId
 }
 
 export type GitHubWorkItemDetails = {