diff --git a/src/main/ai-vault/session-scanner-codex-parser.test.ts b/src/main/ai-vault/session-scanner-codex-parser.test.ts
index 2025a1e89dc..396e43c1b44 100644
--- a/src/main/ai-vault/session-scanner-codex-parser.test.ts
+++ b/src/main/ai-vault/session-scanner-codex-parser.test.ts
@@ -108,6 +108,78 @@ describe('parseCodexSessionFile', () => {
     })
   })
 
+  // A fork of a legacy-history thread copies the parent's session_meta in after its own.
+  it("keeps a fork's own session_meta when its parent's follows it", async () => {
+    const root = await mkdtemp(join(tmpdir(), 'orca-ai-vault-codex-fork-'))
+    tempRoots.push(root)
+    const sessionPath = join(root, 'sessions', '2026', '10', '07', 'rollout-fork.jsonl')
+    await mkdir(dirname(sessionPath), { recursive: true })
+
+    await writeFile(
+      sessionPath,
+      jsonLines([
+        {
+          timestamp: '2026-10-07T10:00:00.000Z',
+          type: 'session_meta',
+          payload: {
+            id: 'fork-session',
+            forked_from_id: 'parent-session',
+            cwd: '/repo/fork',
+            git: { branch: 'fork-branch' }
+          }
+        },
+        {
+          timestamp: '2026-10-07T09:00:00.000Z',
+          type: 'session_meta',
+          payload: {
+            id: 'parent-session',
+            title: 'Parent chat',
+            history_mode: 'paginated',
+            cwd: '/repo/parent',
+            git: { branch: 'parent-branch' }
+          }
+        },
+        {
+          timestamp: '2026-10-07T09:00:01.000Z',
+          type: 'response_item',
+          payload: {
+            type: 'message',
+            role: 'user',
+            content: [{ type: 'input_text', text: 'Copied prompt' }]
+          }
+        },
+        {
+          timestamp: '2026-10-07T09:00:02.000Z',
+          type: 'response_item',
+          payload: {
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: 'Copied reply' }]
+          }
+        }
+      ])
+    )
+
+    const sessionStat = await stat(sessionPath)
+    const session = await parseCodexSessionFile(
+      {
+        path: sessionPath,
+        mtimeMs: sessionStat.mtimeMs,
+        modifiedAt: sessionStat.mtime.toISOString()
+      },
+      'darwin',
+      root
+    )
+
+    expect(session).toMatchObject({
+      sessionId: 'fork-session',
+      cwd: '/repo/fork',
+      branch: 'fork-branch',
+      title: 'Copied prompt',
+      messageCount: 2
+    })
+  })
+
   it('uses user-message events instead of later injected user-role records', async () => {
     const root = await mkdtemp(join(tmpdir(), 'orca-ai-vault-codex-last-prompt-'))
     tempRoots.push(root)
diff --git a/src/main/ai-vault/session-scanner-codex-parser.ts b/src/main/ai-vault/session-scanner-codex-parser.ts
index f1be610f566..b5e9714ea97 100644
--- a/src/main/ai-vault/session-scanner-codex-parser.ts
+++ b/src/main/ai-vault/session-scanner-codex-parser.ts
@@ -142,7 +142,9 @@ function consumeCodexRecordLine(state: CodexSessionParseState, line: string): vo
   updateTimeline(accumulator, extractString(record.timestamp))
 
   const payload = asRecord(record.payload)
-  if (record.type === 'session_meta' && payload) {
+  // Codex keeps the first session_meta canonical; a fork copies its parent's in after it, and
+  // such a later one is ignored below like any other record type this parser does not read.
+  if (record.type === 'session_meta' && payload && !state.sawSessionMeta) {
     state.nonUserOrigin = readCodexNonUserOrigin(payload)
     if (state.nonUserOrigin) {
       return
diff --git a/src/main/ai-vault/structured-session-ownership.test.ts b/src/main/ai-vault/structured-session-ownership.test.ts
index f708023c087..3307032a340 100644
--- a/src/main/ai-vault/structured-session-ownership.test.ts
+++ b/src/main/ai-vault/structured-session-ownership.test.ts
@@ -165,6 +165,50 @@ describe('structured AI Vault ownership', () => {
       )
     ).resolves.toBeUndefined()
   })
+
+  // A fork writes a new conversation, so "Resume in New CLI" on a chat-owned row must pass.
+  it.each([
+    {
+      provider: 'claude' as const,
+      command: `claude '--resume' '${PROVIDER_SESSION}' '--fork-session'`
+    },
+    { provider: 'claude' as const, command: `claude --continue --fork-session` },
+    { provider: 'codex' as const, command: `CODEX_HOME=/h codex 'fork' '${PROVIDER_SESSION}'` }
+  ])('allows a fork of the owned session: $command', async ({ provider, command }) => {
+    installOwnership({ provider })
+
+    await expect(
+      assertLegacyAiVaultResumeCommandAllowed(command, async () => undefined)
+    ).resolves.toBeUndefined()
+  })
+
+  it.each([
+    // After `--` the flag is prompt text, so Claude resumes the owned session as a writer.
+    `claude --resume ${PROVIDER_SESSION} -- --fork-session`,
+    // `--session-id` makes the fork write under the id it names.
+    `claude --resume ${PROVIDER_SESSION} --fork-session --session-id ${PROVIDER_SESSION}`,
+    `claude --resume ${PROVIDER_SESSION} --fork-session --session-id=${PROVIDER_SESSION}`
+  ])('refuses a fork flag that does not make a fork: %s', async (command) => {
+    installOwnership({ provider: 'claude' })
+
+    await expect(
+      assertLegacyAiVaultResumeCommandAllowed(command, async () => undefined)
+    ).rejects.toThrow('agent_session_conflict')
+  })
+
+  it('prepares a fork of the owned session but still refuses a resume of it', () => {
+    installOwnership()
+    const args = {
+      agent: 'codex' as const,
+      sessionId: PROVIDER_SESSION,
+      filePath: `/sessions/rollout-${PROVIDER_SESSION}.jsonl`,
+      codexHome: null,
+      executionHostId: 'local' as const
+    }
+
+    expect(() => assertLegacyAiVaultResumeAllowed({ ...args, fork: true })).not.toThrow()
+    expect(() => assertLegacyAiVaultResumeAllowed(args)).toThrow('agent_session_conflict')
+  })
 })
 
 function installOwnership(overrides: Partial<StructuredProviderSessionOwnership> = {}): void {
diff --git a/src/main/ai-vault/structured-session-ownership.ts b/src/main/ai-vault/structured-session-ownership.ts
index 5a24b325430..7f4d81a4b9e 100644
--- a/src/main/ai-vault/structured-session-ownership.ts
+++ b/src/main/ai-vault/structured-session-ownership.ts
@@ -99,7 +99,8 @@ function ownershipLookup():
 }
 
 export function assertLegacyAiVaultResumeAllowed(args: AiVaultPrepareSessionResumeArgs): void {
-  const ownership = findResumeOwnership(args)
+  // A fork writes a new conversation, and preparing its home never writes this one.
+  const ownership = args.fork ? null : findResumeOwnership(args)
   if (ownership) {
     refuseLegacyWriter(ownership)
   }
@@ -202,6 +203,10 @@ function parseResumeInvocation(command: string): ResumeInvocation | null {
   }
   const provider = /codex(?:\.exe)?$/i.test(normalized[executableIndex]!) ? 'codex' : 'claude'
   const args = normalized.slice(executableIndex + 1)
+  // `codex fork` already falls through below: it carries no `resume` marker.
+  if (provider === 'claude' && isClaudeForkInvocation(args)) {
+    return null
+  }
   // `--continue`/`-c` resume the most recent session and never take an id, so a
   // following token is a prompt, not a target — they are always target-less.
   const targetlessFlags = provider === 'codex' ? [] : ['--continue', '-c']
@@ -230,6 +235,19 @@ function parseResumeInvocation(command: string): ResumeInvocation | null {
   }
 }
 
+/** A fork reads the conversation and writes a new one, so it is no second writer. Not when
+ *  `--session-id` names the id it writes under, and nothing after `--` is an option. */
+function isClaudeForkInvocation(args: readonly string[]): boolean {
+  const terminatorIndex = args.indexOf('--')
+  const options = (terminatorIndex === -1 ? args : args.slice(0, terminatorIndex)).map((token) =>
+    token.toLowerCase()
+  )
+  return (
+    options.includes('--fork-session') &&
+    !options.some((token) => token === '--session-id' || token.startsWith('--session-id='))
+  )
+}
+
 function refuseLegacyWriter(ownership: StructuredProviderSessionOwnership): never {
   throw new Error(
     agentSessionLeaseAdmitsWriter(ownership.lease)
diff --git a/src/main/codex/codex-ai-vault-session-resume.test.ts b/src/main/codex/codex-ai-vault-session-resume.test.ts
index 97fa5738e7c..b68e672c053 100644
--- a/src/main/codex/codex-ai-vault-session-resume.test.ts
+++ b/src/main/codex/codex-ai-vault-session-resume.test.ts
@@ -4,6 +4,15 @@ import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { ManagedCodexHomeTemporarilyUnavailableError } from '../codex-accounts/host-codex-managed-home-ownership'
 import { prepareCodexAiVaultSessionResume } from './codex-ai-vault-session-resume'
+import { getOrcaManagedCodexHomePath } from './codex-home-paths'
+
+const ROLLOUT_RELATIVE_PATH = join(
+  'sessions',
+  '2026',
+  '08',
+  '17',
+  'rollout-2026-08-17T10-00-00-session.jsonl'
+)
 
 // Why: session backfill resolves Orca's managed Codex home from userData, which otherwise resolves to the live one.
 let userDataRoot: string
@@ -12,6 +21,7 @@ beforeEach(() => {
   vi.stubEnv('ORCA_USER_DATA_PATH', userDataRoot)
 })
 afterEach(() => {
+  vi.restoreAllMocks()
   vi.unstubAllEnvs()
   rmSync(userDataRoot, { recursive: true, force: true })
 })
@@ -21,20 +31,15 @@ describe('prepareCodexAiVaultSessionResume', () => {
   let peerHome: string
   let selectedHome: string
   let peerRolloutPath: string
+  let preparePinnedLaunchHome: ReturnType<typeof vi.fn<(home: string) => Promise<void>>>
 
   beforeEach(() => {
+    preparePinnedLaunchHome = vi.fn(async () => undefined)
     root = mkdtempSync(join(tmpdir(), 'orca-codex-ai-vault-resume-'))
     peerHome = join(root, 'codex-accounts', 'account-a', 'home')
     selectedHome = join(root, 'codex-accounts', 'account-b', 'home')
-    const relativeRolloutPath = join(
-      'sessions',
-      '2026',
-      '08',
-      '17',
-      'rollout-2026-08-17T10-00-00-session.jsonl'
-    )
-    peerRolloutPath = join(peerHome, relativeRolloutPath)
-    const selectedRolloutPath = join(selectedHome, relativeRolloutPath)
+    peerRolloutPath = join(peerHome, ROLLOUT_RELATIVE_PATH)
+    const selectedRolloutPath = join(selectedHome, ROLLOUT_RELATIVE_PATH)
     mkdirSync(dirname(peerRolloutPath), { recursive: true })
     mkdirSync(dirname(selectedRolloutPath), { recursive: true })
     writeFileSync(peerRolloutPath, '{"type":"session_meta"}\n', 'utf-8')
@@ -67,8 +72,109 @@ describe('prepareCodexAiVaultSessionResume', () => {
 
   it('preserves deliberate no-selection behavior for a proven-untrusted home', async () => {
     await expect(prepare(() => null)).resolves.toEqual({ useRealCodexHome: false })
+    expect(preparePinnedLaunchHome).not.toHaveBeenCalled()
   })
 
+  // A fork tab has no provider session, so no pane spawn readies the home it keeps.
+  it('readies the row home for a fork that keeps it', async () => {
+    await expect(prepareFork()).resolves.toEqual({ useRealCodexHome: false })
+    expect(preparePinnedLaunchHome).toHaveBeenCalledExactlyOnceWith(peerHome)
+  })
+
+  it('leaves a repinned fork to the pane spawn, which readies the selected home', async () => {
+    await expect(prepareFork({ resolveSelectedHome: () => selectedHome })).resolves.toEqual({
+      useRealCodexHome: false,
+      substituteCodexHome: selectedHome
+    })
+    expect(preparePinnedLaunchHome).not.toHaveBeenCalled()
+  })
+
+  it('readies no home for a fork from a home this host does not list', async () => {
+    await expect(prepareFork({ discoveryHomes: [selectedHome] })).resolves.toEqual({
+      useRealCodexHome: false
+    })
+    expect(preparePinnedLaunchHome).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    ['no runtime home service', { runtimeHome: null }],
+    ['a rollout on another host', { executionHostId: 'runtime:paired' }],
+    ['a WSL home', { codexHome: String.raw`\\wsl.localhost\Ubuntu\home\u\.codex` }]
+  ] as const)('never looks for a fork home with %s', async (_name, overrides) => {
+    const discovery = vi.fn(() => [peerHome, selectedHome])
+
+    await expect(prepareFork({ ...overrides, discovery })).resolves.toEqual({
+      useRealCodexHome: false
+    })
+    expect(discovery).not.toHaveBeenCalled()
+    expect(preparePinnedLaunchHome).not.toHaveBeenCalled()
+  })
+
+  it('leaves a fork moved into the real home to the pane spawn', async () => {
+    const legacyHome = getOrcaManagedCodexHomePath()
+    const legacyRolloutPath = join(legacyHome, ROLLOUT_RELATIVE_PATH)
+    mkdirSync(dirname(legacyRolloutPath), { recursive: true })
+    writeFileSync(legacyRolloutPath, '{"type":"session_meta"}\n', 'utf-8')
+
+    await expect(
+      prepareFork({
+        codexHome: legacyHome,
+        filePath: legacyRolloutPath,
+        isSystemDefaultRealHome: () => true,
+        discoveryHomes: [legacyHome]
+      })
+    ).resolves.toEqual({ useRealCodexHome: true })
+    expect(preparePinnedLaunchHome).not.toHaveBeenCalled()
+  })
+
+  it('still answers a fork when readying its home fails', async () => {
+    preparePinnedLaunchHome.mockRejectedValue(new Error('hooks file unreadable'))
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    await expect(prepareFork()).resolves.toEqual({ useRealCodexHome: false })
+    expect(preparePinnedLaunchHome).toHaveBeenCalledOnce()
+  })
+
+  function prepareFork(
+    overrides: {
+      resolveSelectedHome?: () => string | null
+      isSystemDefaultRealHome?: () => boolean
+      discoveryHomes?: readonly string[]
+      discovery?: () => string[]
+      runtimeHome?: null
+      executionHostId?: string
+      codexHome?: string
+      filePath?: string
+    } = {}
+  ) {
+    const runtimeHome =
+      overrides.runtimeHome === null
+        ? null
+        : {
+            isHostSystemDefaultRealHomeSelected: overrides.isSystemDefaultRealHome ?? (() => false),
+            resolveSelectedHostAccountCodexHomePathForResume:
+              overrides.resolveSelectedHome ?? (() => null),
+            getHostCodexHomePathsForSessionDiscovery:
+              overrides.discovery ??
+              (() => [...(overrides.discoveryHomes ?? [peerHome, selectedHome])])
+          }
+    return prepareCodexAiVaultSessionResume(
+      {
+        agent: 'codex',
+        filePath: overrides.filePath ?? peerRolloutPath,
+        codexHome: overrides.codexHome ?? peerHome,
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the test feeds host ids the RPC may receive; the function only compares them.
+        executionHostId: (overrides.executionHostId ?? 'local') as 'local',
+        fork: true
+      },
+      {
+        runtimeHome,
+        systemCodexHomePath: join(root, 'system-codex-home'),
+        preparePinnedLaunchHome
+      }
+    )
+  }
+
   function prepare(
     resolveSelectedHome: () => string | null,
     isSystemDefaultRealHome: () => boolean = () => false
@@ -83,9 +189,11 @@ describe('prepareCodexAiVaultSessionResume', () => {
       {
         runtimeHome: {
           isHostSystemDefaultRealHomeSelected: isSystemDefaultRealHome,
-          resolveSelectedHostAccountCodexHomePathForResume: resolveSelectedHome
+          resolveSelectedHostAccountCodexHomePathForResume: resolveSelectedHome,
+          getHostCodexHomePathsForSessionDiscovery: () => [peerHome, selectedHome]
         },
-        systemCodexHomePath: join(root, 'system-codex-home')
+        systemCodexHomePath: join(root, 'system-codex-home'),
+        preparePinnedLaunchHome
       }
     )
   }
diff --git a/src/main/codex/codex-ai-vault-session-resume.ts b/src/main/codex/codex-ai-vault-session-resume.ts
index e2932e029af..3a4201060dc 100644
--- a/src/main/codex/codex-ai-vault-session-resume.ts
+++ b/src/main/codex/codex-ai-vault-session-resume.ts
@@ -2,27 +2,77 @@ import type {
   AiVaultPrepareSessionResumeArgs,
   AiVaultPrepareSessionResumeResult
 } from '../../shared/ai-vault-resume-preparation'
+import { normalizeRuntimePathForComparison } from '../../shared/cross-platform-path'
+import { LOCAL_EXECUTION_HOST_ID } from '../../shared/execution-host'
+import { parseWslUncPath } from '../../shared/wsl-paths'
 import type { CodexRuntimeHomeService } from '../codex-accounts/runtime-home-service'
+import { getSystemCodexHomePath } from './codex-home-paths'
 import { prepareLegacySharedCodexSessionResume } from './codex-legacy-session-resume'
+import {
+  resolveTrustedCodexSessionResumeHome,
+  trustedCodexResumeHomes
+} from './codex-session-resume-home'
 
 type CodexAiVaultRuntimeHome = Pick<
   CodexRuntimeHomeService,
-  'isHostSystemDefaultRealHomeSelected' | 'resolveSelectedHostAccountCodexHomePathForResume'
+  | 'isHostSystemDefaultRealHomeSelected'
+  | 'resolveSelectedHostAccountCodexHomePathForResume'
+  | 'getHostCodexHomePathsForSessionDiscovery'
 >
 
+type CodexAiVaultResumeOptions = {
+  runtimeHome: CodexAiVaultRuntimeHome | null
+  systemCodexHomePath: string | undefined
+  /** Readies a home a pane will pin as CODEX_HOME instead of the selected account's. */
+  preparePinnedLaunchHome: (home: string) => Promise<void>
+}
+
 /** Keeps window and serve AI Vault resumes behind the same refusing account-home gate. */
-export function prepareCodexAiVaultSessionResume(
+export async function prepareCodexAiVaultSessionResume(
   args: AiVaultPrepareSessionResumeArgs,
-  options: {
-    runtimeHome: CodexAiVaultRuntimeHome | null
-    systemCodexHomePath: string | undefined
-  }
+  options: CodexAiVaultResumeOptions
 ): Promise<AiVaultPrepareSessionResumeResult> {
-  return prepareLegacySharedCodexSessionResume(args, {
+  const result = await prepareLegacySharedCodexSessionResume(args, {
     isHostSystemDefaultRealHomeSelected: () =>
       options.runtimeHome?.isHostSystemDefaultRealHomeSelected() === true,
     getSelectedHostAccountCodexHomePath: () =>
       options.runtimeHome?.resolveSelectedHostAccountCodexHomePathForResume() ?? null,
     systemCodexHomePath: options.systemCodexHomePath
   })
+  // Why: a fork carries no provider session, so the pane spawn never readies the home a resume
+  // would; when it keeps the row's own home, that home needs the same hooks here.
+  if (args.fork && !result.useRealCodexHome && !result.substituteCodexHome) {
+    try {
+      await readyForkLaunchHome(args, options)
+    } catch (error) {
+      // Why: hook setup is best-effort; the fork still launches without it.
+      console.warn('[codex-ai-vault-resume] could not ready the fork launch home:', error)
+    }
+  }
+  return result
+}
+
+async function readyForkLaunchHome(
+  args: AiVaultPrepareSessionResumeArgs,
+  options: CodexAiVaultResumeOptions
+): Promise<void> {
+  if (
+    !options.runtimeHome ||
+    !args.codexHome ||
+    args.executionHostId !== LOCAL_EXECUTION_HOST_ID ||
+    parseWslUncPath(args.codexHome) !== null
+  ) {
+    return
+  }
+  // Only a home this host lists that holds this rollout: the proof a resume needs before it pins one.
+  const home = resolveTrustedCodexSessionResumeHome({
+    transcriptPath: args.filePath,
+    trustedCodexHomes: trustedCodexResumeHomes(options.runtimeHome, getSystemCodexHomePath())
+  })
+  if (
+    home &&
+    normalizeRuntimePathForComparison(home) === normalizeRuntimePathForComparison(args.codexHome)
+  ) {
+    await options.preparePinnedLaunchHome(home)
+  }
 }
diff --git a/src/main/codex/codex-session-resume-home.ts b/src/main/codex/codex-session-resume-home.ts
index 86186333347..a9845840b64 100644
--- a/src/main/codex/codex-session-resume-home.ts
+++ b/src/main/codex/codex-session-resume-home.ts
@@ -100,6 +100,15 @@ function resolveTrustedCodexSessionResume(args: {
   return null
 }
 
+/** The homes this host itself lists for Codex sessions: the only ones a pane may pin as CODEX_HOME. */
+export function trustedCodexResumeHomes(
+  runtimeHome: { getHostCodexHomePathsForSessionDiscovery(): string[] },
+  systemHomePath: string
+): string[] {
+  // Why: codexSessionSourceHome is import-only; treating it as CODEX_HOME would mutate history sources and bypass account auth.
+  return [systemHomePath, ...runtimeHome.getHostCodexHomePathsForSessionDiscovery()]
+}
+
 export function resolveTrustedCodexSessionResumeHome(args: {
   transcriptPath: string | undefined
   trustedCodexHomes: readonly string[]
diff --git a/src/main/runtime/rpc/methods/ai-vault.test.ts b/src/main/runtime/rpc/methods/ai-vault.test.ts
index 2a179b847e2..17b2a4c3967 100644
--- a/src/main/runtime/rpc/methods/ai-vault.test.ts
+++ b/src/main/runtime/rpc/methods/ai-vault.test.ts
@@ -226,6 +226,30 @@ describe('aiVault.prepareSessionResume', () => {
       executionHostId: 'local'
     })
   })
+
+  it('carries a fork request through to the host preparation', async () => {
+    const prepareAiVaultSessionResume = vi.fn().mockResolvedValue({ useRealCodexHome: false })
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the handler reads only these runtime members.
+    const runtime = {
+      getRuntimeId: () => 'test-runtime',
+      ensureStructuredAgentSessionHost: vi.fn(async () => undefined),
+      prepareAiVaultSessionResume
+    } as unknown as OrcaRuntimeService
+    const dispatcher = new RpcDispatcher({ runtime, methods: AI_VAULT_METHODS })
+
+    await dispatcher.dispatch(
+      makeRequest('aiVault.prepareSessionResume', {
+        agent: 'codex',
+        filePath: '/managed/sessions/rollout-a.jsonl',
+        codexHome: '/managed',
+        fork: true
+      })
+    )
+
+    expect(prepareAiVaultSessionResume).toHaveBeenCalledWith(
+      expect.objectContaining({ fork: true, executionHostId: 'local' })
+    )
+  })
 })
 
 // Session history and terminal resume are not chats: a process whose chats are refused still
diff --git a/src/main/runtime/rpc/methods/ai-vault.ts b/src/main/runtime/rpc/methods/ai-vault.ts
index 2b4c0601990..af6ff78b23a 100644
--- a/src/main/runtime/rpc/methods/ai-vault.ts
+++ b/src/main/runtime/rpc/methods/ai-vault.ts
@@ -112,6 +112,7 @@ export const AI_VAULT_METHODS = [
       const args: AiVaultPrepareSessionResumeArgs = {
         agent: params.agent,
         ...(params.sessionId ? { sessionId: params.sessionId } : {}),
+        ...(params.fork ? { fork: true } : {}),
         filePath: params.filePath,
         codexHome: params.codexHome,
         // Why: the RPC executes on the transcript-owning host; never let a
diff --git a/src/main/startup/codex-session-resume-launch.ts b/src/main/startup/codex-session-resume-launch.ts
index e6ac35b04ff..cd7a6619851 100644
--- a/src/main/startup/codex-session-resume-launch.ts
+++ b/src/main/startup/codex-session-resume-launch.ts
@@ -1,6 +1,9 @@
 import type { AgentProviderSessionMetadata } from '../../shared/agent-session-resume'
 import type { CodexAccountSelectionTarget } from '../codex-accounts/runtime-selection'
-import type { CodexSessionResumePreparation } from '../codex/codex-session-resume-home'
+import {
+  trustedCodexResumeHomes,
+  type CodexSessionResumePreparation
+} from '../codex/codex-session-resume-home'
 import { prepareCodexSessionResume } from '../codex/codex-session-resume-preparation'
 import {
   prepareCodexAccountRestartResume,
@@ -27,8 +30,7 @@ export async function prepareCodexSessionResumeForLaunch(args: {
     return null
   }
   const systemHomePath = getSystemCodexHomePath()
-  // Why: codexSessionSourceHome is import-only; treating it as CODEX_HOME would mutate history sources and bypass account auth.
-  const trustedHomes = [systemHomePath, ...runtimeHome.getHostCodexHomePathsForSessionDiscovery()]
+  const trustedHomes = trustedCodexResumeHomes(runtimeHome, systemHomePath)
   // Why: resolved eagerly, once, before any ranking or provenance match. The
   // marker read used to be deferred into the ranking thunk so a
   // provenance-present resume never paid for it, but that optimisation let an
@@ -87,29 +89,7 @@ export async function prepareCodexSessionResumeForLaunch(args: {
         : migrated.useRealCodexHome
           ? systemHomePath
           : sessionSource.homePath
-      const isSystemHome =
-        normalizeRuntimePathForComparison(resumeHome) ===
-        normalizeRuntimePathForComparison(systemHomePath)
-      const isHooksEnabled = (): boolean =>
-        isAgentStatusHooksEnabledForAgent(store.getSettings(), 'codex')
-      const hooksEnabled = isHooksEnabled()
-      try {
-        if (isSystemHome) {
-          // Why bounded: the resume waits only briefly for a reconcile; it runs on ~/.codex whatever the selection.
-          await reconcileCodexHooksForLaunch()
-        } else if (hooksEnabled) {
-          await codexHookService.installForLaunchPrep(resumeHome, true, isHooksEnabled)
-        } else {
-          await codexHookService.refreshRuntimeUserHooksForLaunchPrep(resumeHome)
-        }
-      } catch (error) {
-        // Why: hook repair is best-effort; session provenance must still win over the currently selected home.
-        console.warn('[codex-hook-service] failed to prepare automatic resume home:', error)
-      }
-      if (!isSystemHome) {
-        // Why: this pins the resumed pane's CODEX_HOME, and hook repair above can skip or fail before its config mirror applies the daemon guard.
-        ensureCodexDaemonSocketGuard(resumeHome)
-      }
+      await prepareCodexPinnedLaunchHome(resumeHome, systemHomePath)
       return resumeHome
     }
   })
@@ -122,3 +102,32 @@ export async function prepareCodexSessionResumeForLaunch(args: {
       }
     : preparation
 }
+
+/** Hook repair and the daemon-socket guard for a pane that pins `home` as its CODEX_HOME rather
+ *  than launching in the selected account's home, which the pane spawn prepares itself. */
+export async function prepareCodexPinnedLaunchHome(
+  home: string,
+  systemHomePath: string = getSystemCodexHomePath()
+): Promise<void> {
+  const isSystemHome =
+    normalizeRuntimePathForComparison(home) === normalizeRuntimePathForComparison(systemHomePath)
+  const isHooksEnabled = (): boolean =>
+    isAgentStatusHooksEnabledForAgent(state.store?.getSettings(), 'codex')
+  try {
+    if (isSystemHome) {
+      // Why bounded: the resume waits only briefly for a reconcile; it runs on ~/.codex whatever the selection.
+      await reconcileCodexHooksForLaunch()
+    } else if (isHooksEnabled()) {
+      await codexHookService.installForLaunchPrep(home, true, isHooksEnabled)
+    } else {
+      await codexHookService.refreshRuntimeUserHooksForLaunchPrep(home)
+    }
+  } catch (error) {
+    // Why: hook repair is best-effort; it must not stop the pane from launching in this home.
+    console.warn('[codex-hook-service] failed to prepare automatic resume home:', error)
+  }
+  if (!isSystemHome) {
+    // Why: this pins the pane's CODEX_HOME, and hook repair above can skip or fail before its config mirror applies the daemon guard.
+    ensureCodexDaemonSocketGuard(home)
+  }
+}
diff --git a/src/main/startup/main-process-runtime-service.ts b/src/main/startup/main-process-runtime-service.ts
index 31f5986b019..5639540083a 100644
--- a/src/main/startup/main-process-runtime-service.ts
+++ b/src/main/startup/main-process-runtime-service.ts
@@ -13,6 +13,7 @@ import { browserManager } from '../browser/browser-manager'
 import { loadAgentSessionClaimSigner } from '../runtime/agent-session-claim-identity'
 import { getProfileUserDataPath } from '../orca-profiles/profile-storage-paths'
 import { prepareCodexAiVaultSessionResume } from '../codex/codex-ai-vault-session-resume'
+import { prepareCodexPinnedLaunchHome } from './codex-session-resume-launch'
 import { resolveHostCodexSessionSourceHome } from '../codex/codex-session-source-home'
 import { isAgentStatusHooksEnabled } from '../agent-hooks/managed-agent-hook-controls'
 import { getDaemonProvider } from '../daemon/daemon-init'
@@ -139,7 +140,8 @@ export function initializeMainProcessRuntime(): OrcaRuntimeService {
     prepareAiVaultSessionResume: (args) =>
       prepareCodexAiVaultSessionResume(args, {
         runtimeHome: state.codexRuntimeHome,
-        systemCodexHomePath: resolveHostCodexSessionSourceHome(store.getSettings())
+        systemCodexHomePath: resolveHostCodexSessionSourceHome(store.getSettings()),
+        preparePinnedLaunchHome: (home) => prepareCodexPinnedLaunchHome(home)
       }),
     prepareCodexStructuredLaunch: ({ launchEnv }) =>
       prepareCodexRuntimeHomeForLaunch(undefined, launchEnv),
diff --git a/src/main/startup/main-window-core-services.ts b/src/main/startup/main-window-core-services.ts
index a68a2461a51..96c8c65c18e 100644
--- a/src/main/startup/main-window-core-services.ts
+++ b/src/main/startup/main-window-core-services.ts
@@ -13,7 +13,10 @@ import {
   handlePtyExit
 } from './main-process-pty-startup'
 import { prepareCodexRuntimeHomeForLaunch } from './codex-launch-preparation'
-import { prepareCodexSessionResumeForLaunch } from './codex-session-resume-launch'
+import {
+  prepareCodexPinnedLaunchHome,
+  prepareCodexSessionResumeForLaunch
+} from './codex-session-resume-launch'
 import { isRecoveryReloadInFlight } from './main-window-lifecycle-flags'
 import { RELAY_HOST_CLOSE_REASON } from '../../shared/relay-host-close-reason'
 
@@ -82,7 +85,8 @@ export function attachMainWindowCoreServices(
       prepareAiVaultSessionResume: (args) =>
         prepareCodexAiVaultSessionResume(args, {
           runtimeHome: codexRuntimeHome,
-          systemCodexHomePath: resolveHostCodexSessionSourceHome(store.getSettings())
+          systemCodexHomePath: resolveHostCodexSessionSourceHome(store.getSettings()),
+          preparePinnedLaunchHome: (home) => prepareCodexPinnedLaunchHome(home)
         }),
       onBeforeRelaunch: async () => {
         state.isQuitting = true
diff --git a/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx b/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx
index 9e56bc0a5a0..fdf095aec30 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx
@@ -376,6 +376,7 @@ export default function AiVaultPanel(): React.JSX.Element {
             getSessionResumeInChat={getSessionResumeInChat}
             onContinueInNewSession={launchActions.handleContinueInNewSession}
             onResumeInNewChat={launchActions.handleResumeInNewChat}
+            onResumeInNewCli={launchActions.handleResumeInNewCli}
             onCopyResume={(session, worktreeId) =>
               void launchActions.copyResumeCommand(session, worktreeId)
             }
diff --git a/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx b/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx
index 776da3fac81..5f0b6f40337 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx
@@ -7,12 +7,14 @@ import {
   MessagesSquare,
   PanelTopOpen,
   Play,
+  SquareTerminal,
   Trash2
 } from 'lucide-react'
 import { DropdownMenuItem, DropdownMenuSeparator } from '@/components/ui/dropdown-menu'
 import { ContextMenuItem, ContextMenuSeparator } from '@/components/ui/context-menu'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { translate } from '@/i18n/i18n'
+import { ResumeInNewCliTooltipText } from './ai-vault-session-cli-fork-copy'
 
 export function SessionActionMenuItems({
   menuKind = 'dropdown',
@@ -22,6 +24,7 @@ export function SessionActionMenuItems({
   onResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   onJumpToOriginalPane,
   showJumpToWorktree,
   onJumpToWorktree,
@@ -41,6 +44,8 @@ export function SessionActionMenuItems({
   onResume: () => void
   onContinueInNewSession?: () => void
   onResumeInNewChat?: () => void
+  // Offered only on rows native chat owns, where it forks: see ai-vault-session-cli-fork.
+  onResumeInNewCli?: () => void
   onJumpToOriginalPane?: () => void
   showJumpToWorktree: boolean
   onJumpToWorktree?: () => void
@@ -104,11 +109,27 @@ export function SessionActionMenuItems({
         <Item onSelect={onResumeInNewChat}>
           <MessagesSquare className="size-3.5" />
           {translate(
-            'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewChat',
-            'Resume in New Chat'
+            'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewNativeChat',
+            'Resume in New Native Chat'
           )}
         </Item>
       ) : null}
+      {onResumeInNewCli ? (
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <Item onSelect={onResumeInNewCli}>
+              <SquareTerminal className="size-3.5" />
+              {translate(
+                'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewCli',
+                'Resume in New CLI'
+              )}
+            </Item>
+          </TooltipTrigger>
+          <TooltipContent side={menuKind === 'context' ? 'right' : 'left'} sideOffset={8}>
+            <ResumeInNewCliTooltipText />
+          </TooltipContent>
+        </Tooltip>
+      ) : null}
       {onContinueInNewSession ? (
         <Item onSelect={onContinueInNewSession}>
           <MessageSquarePlus className="size-3.5" />
diff --git a/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx b/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx
index fd7a8394f74..04e308d8bac 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx
@@ -7,7 +7,8 @@ import {
   MessageSquare,
   MessageSquarePlus,
   MessagesSquare,
-  Play
+  Play,
+  SquareTerminal
 } from 'lucide-react'
 import { Button } from '@/components/ui/button'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
@@ -19,6 +20,7 @@ import {
 } from '../../../../shared/ai-vault-types'
 import { translate } from '@/i18n/i18n'
 import { FirstPromptCard } from './ai-vault-first-prompt-card'
+import { ResumeInNewCliTooltipText } from './ai-vault-session-cli-fork-copy'
 import { sessionDetailConversationTurns, sessionPromptPreview } from './ai-vault-session-display'
 import { SessionSubagentsSection } from './AiVaultSessionSubagents'
 import { SessionUnsavedConversationNotice } from './AiVaultSessionUnsavedNotice'
@@ -41,6 +43,7 @@ export function SessionInlineDetails({
   subagentResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   onOpenLog
 }: {
   id: string
@@ -56,6 +59,7 @@ export function SessionInlineDetails({
   subagentResume?: AiVaultSubagentResumeActions
   onContinueInNewSession?: () => void
   onResumeInNewChat?: () => void
+  onResumeInNewCli?: () => void
   onOpenLog?: () => void
 }): React.JSX.Element {
   // A zero-turn transcript would resume into an empty conversation, so the plain
@@ -86,6 +90,7 @@ export function SessionInlineDetails({
       showResumeInNewTab ||
       onContinueInNewSession ||
       onResumeInNewChat ||
+      onResumeInNewCli ||
       onOpenLog ? (
         <div className="flex flex-wrap items-center gap-1.5 border-b border-sidebar-border/80 bg-sidebar-accent/15 px-3 py-2">
           {showResumeInWorktree ? (
@@ -146,11 +151,37 @@ export function SessionInlineDetails({
             >
               <MessagesSquare className="size-3.5" />
               {translate(
-                'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewChat',
-                'Resume in New Chat'
+                'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewNativeChat',
+                'Resume in New Native Chat'
               )}
             </Button>
           ) : null}
+          {onResumeInNewCli ? (
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <Button
+                  type="button"
+                  variant="secondary"
+                  size="xs"
+                  draggable={false}
+                  onClick={(event) => {
+                    event.stopPropagation()
+                    onResumeInNewCli()
+                  }}
+                  className="h-7 shrink-0 px-2.5 text-[11px]"
+                >
+                  <SquareTerminal className="size-3.5" />
+                  {translate(
+                    'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewCli',
+                    'Resume in New CLI'
+                  )}
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent side="top" sideOffset={4}>
+                <ResumeInNewCliTooltipText />
+              </TooltipContent>
+            </Tooltip>
+          ) : null}
           {onContinueInNewSession ? (
             <Button
               type="button"
diff --git a/src/renderer/src/components/right-sidebar/AiVaultSessionRow.tsx b/src/renderer/src/components/right-sidebar/AiVaultSessionRow.tsx
index e6f4dd4a3f9..4b34a41dbcf 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultSessionRow.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultSessionRow.tsx
@@ -46,6 +46,7 @@ export function VaultSessionRow({
   onResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   resumeLabel: defaultResumeLabel,
   resumeActions,
   onResumeInWorktree,
@@ -76,6 +77,7 @@ export function VaultSessionRow({
   onResume: () => void
   onContinueInNewSession?: () => void
   onResumeInNewChat?: () => void
+  onResumeInNewCli?: () => void
   resumeLabel: string
   resumeActions: AiVaultSessionResumeActions
   onResumeInWorktree: () => void
@@ -199,6 +201,7 @@ export function VaultSessionRow({
               onResume={onResume}
               onContinueInNewSession={onContinueInNewSession}
               onResumeInNewChat={onResumeInNewChat}
+              onResumeInNewCli={onResumeInNewCli}
               onCopyResume={onCopyResume}
               onCopyId={onCopyId}
               onCopyPath={onCopyPath}
@@ -246,6 +249,7 @@ export function VaultSessionRow({
               subagentResume={subagentResume}
               onContinueInNewSession={onContinueInNewSession}
               onResumeInNewChat={onResumeInNewChat}
+              onResumeInNewCli={onResumeInNewCli}
               onOpenLog={onOpenLog}
             />
           ) : null}
@@ -263,6 +267,7 @@ export function VaultSessionRow({
           onResume={onResume}
           onContinueInNewSession={onContinueInNewSession}
           onResumeInNewChat={onResumeInNewChat}
+          onResumeInNewCli={onResumeInNewCli}
           onCopyResume={onCopyResume}
           onCopyId={onCopyId}
           onCopyPath={onCopyPath}
diff --git a/src/renderer/src/components/right-sidebar/AiVaultSessionVirtualList.tsx b/src/renderer/src/components/right-sidebar/AiVaultSessionVirtualList.tsx
index 0f077dc07ea..4bc51ea44cc 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultSessionVirtualList.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultSessionVirtualList.tsx
@@ -50,6 +50,7 @@ export function AiVaultSessionVirtualList({
   onResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   onCopyResume,
   onCopyId,
   onCopyPath,
@@ -81,6 +82,7 @@ export function AiVaultSessionVirtualList({
   onResume: (session: AiVaultSession, worktreeId: string) => void
   onContinueInNewSession: (session: AiVaultSession, worktreeId: string) => void
   onResumeInNewChat: (session: AiVaultSession, worktreeId: string) => void
+  onResumeInNewCli: (session: AiVaultSession, worktreeId: string) => void
   onCopyResume: (session: AiVaultSession, worktreeId?: string | null) => void
   onCopyId: (session: AiVaultSession) => void
   onCopyPath: (session: AiVaultSession) => void
@@ -227,6 +229,7 @@ export function AiVaultSessionVirtualList({
                 onResume={onResume}
                 onContinueInNewSession={onContinueInNewSession}
                 onResumeInNewChat={onResumeInNewChat}
+                onResumeInNewCli={onResumeInNewCli}
                 onCopyResume={onCopyResume}
                 onCopyId={onCopyId}
                 onCopyPath={onCopyPath}
diff --git a/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.test.tsx b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.test.tsx
index cb7eff864e5..806e84db35f 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.test.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.test.tsx
@@ -39,6 +39,7 @@ function renderSession(session: AiVaultSession, blocked = false, searchHit?: AiV
   const buildResumeStartup = vi.fn(() => ({ command: session.resumeCommand }))
   const onCopyResume = vi.fn()
   const onResume = vi.fn()
+  const onResumeInNewCli = vi.fn()
   render(
     <TooltipProvider>
       <AiVaultVirtualRow
@@ -73,6 +74,7 @@ function renderSession(session: AiVaultSession, blocked = false, searchHit?: AiV
         onResume={onResume}
         onContinueInNewSession={vi.fn()}
         onResumeInNewChat={vi.fn()}
+        onResumeInNewCli={onResumeInNewCli}
         onCopyResume={onCopyResume}
         onCopyId={vi.fn()}
         onCopyPath={vi.fn()}
@@ -83,7 +85,7 @@ function renderSession(session: AiVaultSession, blocked = false, searchHit?: AiV
       />
     </TooltipProvider>
   )
-  return { buildResumeStartup, onCopyResume, onResume }
+  return { buildResumeStartup, onCopyResume, onResume, onResumeInNewCli }
 }
 
 describe('AiVaultVirtualRow resume command actions', () => {
@@ -169,3 +171,40 @@ describe('AiVaultVirtualRow resume command actions', () => {
     expect(onResume).toHaveBeenCalledExactlyOnceWith(session, 'worktree-1')
   })
 })
+
+describe('AiVaultVirtualRow Resume in New CLI', () => {
+  const owner = { sessionId: 'chat-1', workspaceId: 'worktree-1' }
+
+  it.each(['claude', 'codex'] as const)(
+    'offers the fork on a chat-owned %s row from both menus',
+    async (agent) => {
+      const session: AiVaultSession = { ...cliSession, agent, structuredSession: owner }
+      const { onResumeInNewCli, onResume } = renderSession(session)
+      const user = userEvent.setup()
+
+      await user.click(screen.getByTestId('ai-vault-session-more-actions'))
+      await user.click(await screen.findByRole('menuitem', { name: 'Resume in New CLI' }))
+      expect(onResumeInNewCli).toHaveBeenCalledExactlyOnceWith(session, 'worktree-1')
+
+      fireEvent.contextMenu(screen.getByText('CLI session'))
+      await user.click(await screen.findByRole('menuitem', { name: 'Resume in New CLI' }))
+      expect(onResumeInNewCli).toHaveBeenCalledTimes(2)
+      expect(onResume).not.toHaveBeenCalled()
+    }
+  )
+
+  it.each([
+    { name: 'a terminal row', session: cliSession },
+    {
+      name: 'a chat-owned row of an agent that cannot fork',
+      session: { ...cliSession, agent: 'gemini' as const, structuredSession: owner }
+    }
+  ])('does not offer the fork on $name', async ({ session }) => {
+    renderSession(session)
+    const user = userEvent.setup()
+
+    await user.click(screen.getByTestId('ai-vault-session-more-actions'))
+    await screen.findByRole('menu')
+    expect(screen.queryByRole('menuitem', { name: 'Resume in New CLI' })).toBeNull()
+  })
+})
diff --git a/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx
index 92be9e9b874..6c75e8b3ce3 100644
--- a/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx
+++ b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx
@@ -23,6 +23,7 @@ import {
   canUseLocalAiVaultSessionPathActions
 } from './ai-vault-session-path-actions'
 import { canContinueAiVaultSessionInNewSession } from './ai-vault-session-continuation'
+import { aiVaultSessionCliForkWorktreeId } from './ai-vault-session-cli-fork'
 import type { AiVaultResumeInChatEligibility } from './ai-vault-session-resume-in-chat'
 import type { AiVaultSearchHit } from '../../../../shared/ai-vault-search-types'
 import { canResumeAiVaultSearchHit, hasAiVaultSearchHitPath } from './ai-vault-search-session'
@@ -55,6 +56,7 @@ export function AiVaultVirtualRow({
   onResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   onCopyResume,
   onCopyId,
   onCopyPath,
@@ -87,6 +89,7 @@ export function AiVaultVirtualRow({
   onResume: (session: AiVaultSession, worktreeId: string) => void
   onContinueInNewSession: (session: AiVaultSession, worktreeId: string) => void
   onResumeInNewChat: (session: AiVaultSession, worktreeId: string) => void
+  onResumeInNewCli: (session: AiVaultSession, worktreeId: string) => void
   onCopyResume: (session: AiVaultSession, worktreeId?: string | null) => void
   onCopyId: (session: AiVaultSession) => void
   onCopyPath: (session: AiVaultSession) => void
@@ -126,6 +129,13 @@ export function AiVaultVirtualRow({
       ? aiVaultSessionRowResumeGating(row.session, resumeState)
       : { resumeDisabled: true, canCopyResumeCommand: false }
   const resumeLabel = resumeState ? aiVaultSessionResumeLabel(resumeState) : ''
+  const cliForkWorktreeId =
+    row.type === 'session'
+      ? aiVaultSessionCliForkWorktreeId(row.session, {
+          worktreeId: resumeState?.worktreeId,
+          disabled: resumeGating.resumeDisabled
+        })
+      : null
   const canOpenLocalSessionPaths =
     row.type === 'session' && canUseLocalAiVaultSessionPathActions(row.session.executionHostId)
   // Why: in-Orca View Log additionally withholds synthetic (SQLite/OpenCode)
@@ -210,6 +220,11 @@ export function AiVaultVirtualRow({
               ? () => onResumeInNewChat(row.session, resumeInChat.workspaceId)
               : undefined
           }
+          onResumeInNewCli={
+            searchResumeAllowed && cliForkWorktreeId
+              ? () => onResumeInNewCli(row.session, cliForkWorktreeId)
+              : undefined
+          }
           onResumeInWorktree={() => {
             if (searchResumeAllowed && resumeActions?.worktree.worktreeId) {
               onResume(row.session, resumeActions.worktree.worktreeId)
diff --git a/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx b/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx
index c842414f6e2..e93f3147850 100644
--- a/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx
+++ b/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx
@@ -55,6 +55,7 @@ export function SessionRowTrailingActions({
   onResume,
   onContinueInNewSession,
   onResumeInNewChat,
+  onResumeInNewCli,
   onCopyResume,
   onCopyId,
   onCopyPath,
@@ -80,6 +81,7 @@ export function SessionRowTrailingActions({
   onContinueInNewSession?: () => void
   /** Passed through to the overflow menu only; the resting row keeps its two-icon budget. */
   onResumeInNewChat?: () => void
+  onResumeInNewCli?: () => void
   onCopyResume?: () => void
   onCopyId: () => void
   onCopyPath?: () => void
@@ -265,6 +267,7 @@ export function SessionRowTrailingActions({
             onResume={onResume}
             onContinueInNewSession={onContinueInNewSession}
             onResumeInNewChat={onResumeInNewChat}
+            onResumeInNewCli={onResumeInNewCli}
             onJumpToOriginalPane={onJumpToOriginalPane}
             showJumpToWorktree={showJumpToWorktree}
             onJumpToWorktree={onJumpToWorktree}
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork-copy.tsx b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork-copy.tsx
new file mode 100644
index 00000000000..09d39962455
--- /dev/null
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork-copy.tsx
@@ -0,0 +1,24 @@
+import type React from 'react'
+import { translate } from '@/i18n/i18n'
+
+/** Shared by the row menus and the details button, which offer the same fork. Two block lines, not
+ *  one wrapped string: the tooltip balances wrapped text inside a box sized before balancing, which
+ *  leaves a gap beside the shorter lines. */
+export function ResumeInNewCliTooltipText(): React.JSX.Element {
+  return (
+    <>
+      <span className="block">
+        {translate(
+          'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewCliTooltipFork',
+          'Forks this conversation into a new CLI session.'
+        )}
+      </span>
+      <span className="block">
+        {translate(
+          'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewCliTooltipChat',
+          'The native chat stays as it is.'
+        )}
+      </span>
+    </>
+  )
+}
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.test.ts
new file mode 100644
index 00000000000..4b524e4ca26
--- /dev/null
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+import {
+  aiVaultSessionCliForkWorktreeId,
+  describeAiVaultCliForkFailure
+} from './ai-vault-session-cli-fork'
+
+const OWNED = { sessionId: 'chat-1', workspaceId: 'repo-1::worktree-1' }
+const RESUMABLE = { worktreeId: 'repo-1::worktree-2', disabled: false }
+
+describe('Resume in New CLI eligibility', () => {
+  it('offers the fork for Claude and Codex rows native chat owns', () => {
+    expect(
+      aiVaultSessionCliForkWorktreeId({ agent: 'claude', structuredSession: OWNED }, RESUMABLE)
+    ).toBe('repo-1::worktree-2')
+    expect(
+      aiVaultSessionCliForkWorktreeId({ agent: 'codex', structuredSession: OWNED }, RESUMABLE)
+    ).toBe('repo-1::worktree-2')
+  })
+
+  it('leaves rows no chat owns to plain Resume', () => {
+    expect(aiVaultSessionCliForkWorktreeId({ agent: 'claude' }, RESUMABLE)).toBeNull()
+  })
+
+  it('withholds the fork when resume is blocked or has no target', () => {
+    const session = { agent: 'claude' as const, structuredSession: OWNED }
+    expect(aiVaultSessionCliForkWorktreeId(session, { worktreeId: 'w', disabled: true })).toBeNull()
+    expect(
+      aiVaultSessionCliForkWorktreeId(session, { worktreeId: null, disabled: false })
+    ).toBeNull()
+  })
+})
+
+describe('Resume in New CLI failure text', () => {
+  const UPDATE = 'Update Orca on the host that runs this chat to resume it in a new CLI.'
+
+  it.each([
+    'agent_session_conflict',
+    'agent_session_ownership_unknown',
+    // Electron wraps an error thrown by a main-process handler.
+    "Error invoking remote method 'aiVault:prepareSessionResume': Error: agent_session_conflict"
+  ])('asks for a host update when an older host refuses the fork: %s', (message) => {
+    expect(describeAiVaultCliForkFailure(message)).toBe(UPDATE)
+  })
+
+  it('passes any other failure through unchanged', () => {
+    const message = 'The session host is unavailable. Reconnect it and retry resume.'
+    expect(describeAiVaultCliForkFailure(message)).toBe(message)
+  })
+})
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.ts
new file mode 100644
index 00000000000..84f7dde79de
--- /dev/null
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-cli-fork.ts
@@ -0,0 +1,31 @@
+import { translate } from '@/i18n/i18n'
+import { compactIpcErrorMessage } from '@/lib/ipc-error'
+import type { AiVaultSession } from '../../../../shared/ai-vault-types'
+
+/**
+ * Where "Resume in New CLI" opens its copy of a conversation native chat owns, or null when the row
+ * does not offer it. A row no chat owns already resumes in the CLI through plain Resume, and only
+ * Claude and Codex can fork.
+ */
+export function aiVaultSessionCliForkWorktreeId(
+  session: Pick<AiVaultSession, 'agent' | 'structuredSession'>,
+  resume: { worktreeId: string | null | undefined; disabled: boolean }
+): string | null {
+  if (!session.structuredSession || resume.disabled || !resume.worktreeId) {
+    return null
+  }
+  return session.agent === 'claude' || session.agent === 'codex' ? resume.worktreeId : null
+}
+
+/** The toast for a failed "Resume in New CLI". Only a host whose guard predates the fork refuses
+ *  the fork as a second writer, so that refusal asks for the update instead of naming a code. */
+export function describeAiVaultCliForkFailure(message: string): string {
+  // The desktop preparation's refusal arrives inside Electron's IPC wrapper.
+  const code = compactIpcErrorMessage(message)
+  return code === 'agent_session_conflict' || code === 'agent_session_ownership_unknown'
+    ? translate(
+        'auto.components.right.sidebar.AiVaultPanel.resumeInNewCliHostTooOld',
+        'Update Orca on the host that runs this chat to resume it in a new CLI.'
+      )
+    : message
+}
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.test.ts
new file mode 100644
index 00000000000..9d72b9b7ae9
--- /dev/null
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.test.ts
@@ -0,0 +1,156 @@
+// @vitest-environment happy-dom
+import { renderHook, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { AiVaultSession } from '../../../../shared/ai-vault-types'
+import type { WebRuntimeTerminalCreateOutcome } from '@/runtime/web-runtime-session'
+
+const mocks = vi.hoisted(() => ({
+  buildAiVaultForkStartupForWorktree: vi.fn(),
+  buildAiVaultResumeStartupForWorktree: vi.fn(),
+  prepareAiVaultSessionForFork: vi.fn(),
+  prepareAiVaultSessionForResume: vi.fn(),
+  launchAiVaultSessionInNewTab: vi.fn(),
+  activateAiVaultResumeWorkspace: vi.fn(),
+  toastError: vi.fn(),
+  toastSuccess: vi.fn()
+}))
+
+vi.mock('@/lib/ai-vault-session-fork-startup', () => ({
+  buildAiVaultForkStartupForWorktree: mocks.buildAiVaultForkStartupForWorktree
+}))
+vi.mock('@/lib/ai-vault-resume-command', () => ({
+  buildAiVaultResumeStartupForWorktree: mocks.buildAiVaultResumeStartupForWorktree,
+  buildAiVaultResumeCopyCommandForWorktree: vi.fn()
+}))
+vi.mock('@/lib/ai-vault-session-resume-preparation', () => ({
+  prepareAiVaultSessionForFork: mocks.prepareAiVaultSessionForFork,
+  prepareAiVaultSessionForResume: mocks.prepareAiVaultSessionForResume,
+  dropDeletedSshResumeCwd: async (session: unknown) => session
+}))
+vi.mock('@/lib/launch-ai-vault-session', () => ({
+  launchAiVaultSessionInNewTab: mocks.launchAiVaultSessionInNewTab
+}))
+vi.mock('./ai-vault-session-launch-target', () => ({
+  resolveAiVaultSessionLaunchTarget: (args: { targetWorktreeId?: string }) => ({
+    status: 'ready',
+    worktreeId: args.targetWorktreeId
+  }),
+  resolveAiVaultTargetWorkspacePath: vi.fn(),
+  aiVaultResumeUnsupportedMessage: vi.fn()
+}))
+vi.mock('./ai-vault-session-resume-in-chat-launch', () => ({
+  activateAiVaultResumeWorkspace: mocks.activateAiVaultResumeWorkspace,
+  resumeAiVaultSessionInNewChat: vi.fn()
+}))
+vi.mock('sonner', () => ({ toast: { error: mocks.toastError, success: mocks.toastSuccess } }))
+vi.mock('@/store', () => ({
+  useAppStore: { getState: () => ({ activeWorktreeId: 'worktree-1', settings: {} }) }
+}))
+
+import { useAiVaultSessionLaunchActions } from './ai-vault-session-launch-actions'
+
+const owned: AiVaultSession = {
+  id: 'local:claude:provider-1:/p.jsonl',
+  executionHostId: 'local',
+  agent: 'claude',
+  sessionId: 'provider-1',
+  title: 'Claude Chat',
+  cwd: '/repo',
+  branch: null,
+  model: null,
+  filePath: '/p.jsonl',
+  codexHome: null,
+  createdAt: null,
+  updatedAt: null,
+  modifiedAt: '2026-10-07T00:00:00.000Z',
+  messageCount: 1,
+  totalTokens: 0,
+  previewMessages: [],
+  queuedMessageCount: 0,
+  subagentTranscriptCount: 0,
+  resumeCommand: 'claude --resume provider-1',
+  subagent: null,
+  structuredSession: { sessionId: 'chat-1', workspaceId: 'worktree-1' }
+}
+
+const FORK_STARTUP = { command: "claude --resume 'provider-1' --fork-session", cwd: '/repo' }
+
+function renderActions() {
+  return renderHook(() =>
+    useAiVaultSessionLaunchActions({
+      activeWorktree: null,
+      activeWorktreeId: 'worktree-1',
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the mocked launch target never reads it.
+      targetState: {} as never
+    })
+  ).result.current
+}
+
+describe('Resume in New CLI launch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.prepareAiVaultSessionForFork.mockImplementation(async (session) => session)
+    mocks.buildAiVaultForkStartupForWorktree.mockReturnValue(FORK_STARTUP)
+    mocks.launchAiVaultSessionInNewTab.mockReturnValue({ tabId: 'tab-1' })
+  })
+
+  it('opens the fork plan in the chosen workspace, never the plain resume plan', async () => {
+    renderActions().handleResumeInNewCli(owned, 'worktree-2')
+
+    await waitFor(() => expect(mocks.launchAiVaultSessionInNewTab).toHaveBeenCalledTimes(1))
+    expect(mocks.prepareAiVaultSessionForFork).toHaveBeenCalledWith(owned)
+    expect(mocks.buildAiVaultForkStartupForWorktree).toHaveBeenCalledWith(
+      expect.objectContaining({ worktreeId: 'worktree-2', session: owned })
+    )
+    expect(mocks.launchAiVaultSessionInNewTab).toHaveBeenCalledWith({
+      agent: 'claude',
+      worktreeId: 'worktree-2',
+      ...FORK_STARTUP
+    })
+    expect(mocks.activateAiVaultResumeWorkspace).toHaveBeenCalledWith('worktree-2')
+    expect(mocks.prepareAiVaultSessionForResume).not.toHaveBeenCalled()
+    expect(mocks.buildAiVaultResumeStartupForWorktree).not.toHaveBeenCalled()
+    expect(mocks.toastError).not.toHaveBeenCalled()
+  })
+
+  it('shows one toast and opens nothing when the agent cannot fork', async () => {
+    mocks.buildAiVaultForkStartupForWorktree.mockReturnValue(null)
+
+    renderActions().handleResumeInNewCli(owned, 'worktree-2')
+
+    await waitFor(() => expect(mocks.toastError).toHaveBeenCalledTimes(1))
+    expect(mocks.toastError).toHaveBeenCalledWith('This session cannot be opened in the CLI.')
+    expect(mocks.launchAiVaultSessionInNewTab).not.toHaveBeenCalled()
+  })
+
+  // A host whose guard predates the fork refuses it as a second writer.
+  it('asks for a host update, once, when an older paired host refuses the fork', async () => {
+    mocks.launchAiVaultSessionInNewTab.mockReturnValue({
+      tabId: null,
+      runtimeLaunch: Promise.resolve<WebRuntimeTerminalCreateOutcome>({
+        status: 'failed',
+        message: 'agent_session_conflict'
+      })
+    })
+
+    renderActions().handleResumeInNewCli(owned, 'worktree-2')
+
+    await waitFor(() => expect(mocks.toastError).toHaveBeenCalledTimes(1))
+    expect(mocks.toastError).toHaveBeenCalledWith(
+      'Update Orca on the host that runs this chat to resume it in a new CLI.'
+    )
+    expect(mocks.toastSuccess).not.toHaveBeenCalled()
+  })
+
+  it('asks for a host update when an older paired host refuses the fork preparation', async () => {
+    mocks.prepareAiVaultSessionForFork.mockRejectedValue(new Error('agent_session_conflict'))
+
+    renderActions().handleResumeInNewCli(owned, 'worktree-2')
+
+    await waitFor(() => expect(mocks.toastError).toHaveBeenCalledTimes(1))
+    expect(mocks.toastError).toHaveBeenCalledWith(
+      'Update Orca on the host that runs this chat to resume it in a new CLI.'
+    )
+    expect(mocks.launchAiVaultSessionInNewTab).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
index 8929540443a..d2dd3dd7866 100644
--- a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
+++ b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-actions.ts
@@ -3,18 +3,22 @@ import { toast } from 'sonner'
 import {
   buildAiVaultResumeCopyCommandForWorktree,
   buildAiVaultResumeStartupForWorktree,
-  type AiVaultResumeCommandSession
+  type AiVaultResumeCommandSession,
+  type AiVaultResumeStartup
 } from '@/lib/ai-vault-resume-command'
+import { buildAiVaultForkStartupForWorktree } from '@/lib/ai-vault-session-fork-startup'
 import { launchAiVaultSessionInNewTab } from '@/lib/launch-ai-vault-session'
 import { useAppStore } from '@/store'
 import type { AiVaultAgent, AiVaultSession } from '../../../../shared/ai-vault-types'
 import {
   dropDeletedSshResumeCwd,
+  prepareAiVaultSessionForFork,
   prepareAiVaultSessionForResume
 } from '@/lib/ai-vault-session-resume-preparation'
 import type { Worktree } from '../../../../shared/worktree/types'
 import { translate } from '@/i18n/i18n'
 import { agentLabel } from './ai-vault-session-filters'
+import { describeAiVaultCliForkFailure } from './ai-vault-session-cli-fork'
 import type { AiVaultSessionResumeTargetState } from './ai-vault-session-resume'
 import { prepareAiVaultSessionContinuation } from './ai-vault-session-continuation'
 import type { AgentSessionContinuationRequest } from '@/lib/agent-session-continuation'
@@ -88,12 +92,13 @@ export function useAiVaultSessionLaunchActions({
     [buildResumeCommand]
   )
 
-  const handleResume = useCallback(
-    (session: AiVaultSession, targetWorktreeId?: string): void => {
-      if (session.structuredSession) {
-        void activateAiVaultStructuredSession(session)
-        return
-      }
+  const launchInTerminal = useCallback(
+    (
+      session: AiVaultSession,
+      targetWorktreeId: string | undefined,
+      prepareStartup: (worktreeId: string) => Promise<AiVaultResumeStartup>,
+      describeFailure: (message: string) => string = (message) => message
+    ): void => {
       const targetId = resolveAiVaultSessionLaunchTargetOrNotify({
         sessionFilePath: session.filePath,
         sessionExecutionHostId: session.executionHostId,
@@ -104,7 +109,6 @@ export function useAiVaultSessionLaunchActions({
       if (!targetId) {
         return
       }
-
       const showQueuedToast = (): void => {
         toast.success(
           translate(
@@ -114,19 +118,18 @@ export function useAiVaultSessionLaunchActions({
           )
         )
       }
-      void prepareAiVaultSessionForResume(session)
-        .then(dropDeletedSshResumeCwd)
-        .then((preparedSession) => {
+      void prepareStartup(targetId.worktreeId)
+        .then((startup) => {
           const launchResult = launchAiVaultSessionInNewTab({
             agent: session.agent,
             worktreeId: targetId.worktreeId,
-            ...buildResumeStartup(preparedSession, targetId.worktreeId)
+            ...startup
           })
           if (launchResult.tabId === null) {
             void launchResult.runtimeLaunch.then((outcome) => {
               if (outcome.status === 'failed') {
                 toast.error(
-                  outcome.message ||
+                  describeFailure(outcome.message) ||
                     translate(
                       'auto.lib.launch.agent.in.new.tab.11cce5cc77',
                       'Could not launch {{value0}} in a new terminal.',
@@ -147,9 +150,49 @@ export function useAiVaultSessionLaunchActions({
           }
           showQueuedToast()
         })
-        .catch(notifyAiVaultSessionPreparationFailure)
+        .catch((error: unknown) => notifyAiVaultSessionPreparationFailure(error, describeFailure))
     },
-    [activeWorktree?.id, activeWorktreeId, buildResumeStartup, targetState]
+    [activeWorktree?.id, activeWorktreeId, targetState]
+  )
+
+  const handleResume = useCallback(
+    (session: AiVaultSession, targetWorktreeId?: string): void => {
+      if (session.structuredSession) {
+        void activateAiVaultStructuredSession(session)
+        return
+      }
+      launchInTerminal(session, targetWorktreeId, (worktreeId) =>
+        prepareAiVaultSessionForResume(session)
+          .then(dropDeletedSshResumeCwd)
+          .then((preparedSession) => buildResumeStartup(preparedSession, worktreeId))
+      )
+    },
+    [buildResumeStartup, launchInTerminal]
+  )
+
+  // Native chat keeps the conversation it owns; the terminal gets a copy (see the fork builder).
+  const handleResumeInNewCli = useCallback(
+    (session: AiVaultSession, targetWorktreeId: string): void => {
+      const prepareStartup = async (worktreeId: string): Promise<AiVaultResumeStartup> => {
+        const startup = buildAiVaultForkStartupForWorktree({
+          state: useAppStore.getState(),
+          worktreeId,
+          session: await prepareAiVaultSessionForFork(session).then(dropDeletedSshResumeCwd),
+          commandOverride: agentCmdOverrides?.[session.agent]
+        })
+        if (!startup) {
+          throw new Error(
+            translate(
+              'auto.components.right.sidebar.AiVaultPanel.resumeInNewCliUnavailable',
+              'This session cannot be opened in the CLI.'
+            )
+          )
+        }
+        return startup
+      }
+      launchInTerminal(session, targetWorktreeId, prepareStartup, describeAiVaultCliForkFailure)
+    },
+    [agentCmdOverrides, launchInTerminal]
   )
 
   const handleResumeInNewChat = useCallback(
@@ -224,6 +267,7 @@ export function useAiVaultSessionLaunchActions({
     buildResumeStartup,
     copyResumeCommand,
     handleResume,
+    handleResumeInNewCli,
     handleResumeInNewChat,
     handleContinueInNewSession,
     continuationRequest,
@@ -231,10 +275,13 @@ export function useAiVaultSessionLaunchActions({
   }
 }
 
-function notifyAiVaultSessionPreparationFailure(error: unknown): void {
+function notifyAiVaultSessionPreparationFailure(
+  error: unknown,
+  describeFailure: (message: string) => string = (message) => message
+): void {
   toast.error(
     error instanceof Error
-      ? error.message
+      ? describeFailure(error.message)
       : translate(
           'auto.components.right.sidebar.AiVaultPanel.prepareSessionResumeFailed',
           'Could not prepare this session for resume.'
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index 1e0acd6902d..25baa79eb85 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -13887,7 +13887,9 @@
             "sessionDeleteFailed": "Couldn't delete the session",
             "resumeInChatConflict": "Another chat is already holding this conversation.",
             "resumeInChatTranscriptMissing": "This conversation's history could not be loaded, so it cannot be resumed in chat.",
-            "resumeInChatFailed": "Could not resume this session in a new chat."
+            "resumeInChatFailed": "Could not resume this session in a new chat.",
+            "resumeInNewCliUnavailable": "This session cannot be opened in the CLI.",
+            "resumeInNewCliHostTooOld": "Update Orca on the host that runs this chat to resume it in a new CLI."
           },
           "AiVaultPanelControls": {
             "scanningSessions": "Scanning sessions",
@@ -14023,7 +14025,10 @@
             "deleteReasonNonLocalHost": "Only sessions on this device can be deleted.",
             "deleteReasonSyntheticPath": "This session can't be deleted from Orca.",
             "deleteReasonUnsupportedAgent": "{{value0}} sessions can't be deleted from Orca.",
-            "resumeInNewChat": "Resume in New Chat"
+            "resumeInNewNativeChat": "Resume in New Native Chat",
+            "resumeInNewCli": "Resume in New CLI",
+            "resumeInNewCliTooltipFork": "Forks this conversation into a new CLI session.",
+            "resumeInNewCliTooltipChat": "The native chat stays as it is."
           },
           "AiVaultSessionDeleteDialog": {
             "title": "Delete this session?",
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index a66a847af42..020e9cf1c13 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -13653,7 +13653,9 @@
             "sessionDeleteFailed": "No se pudo eliminar la sesión",
             "resumeInChatConflict": "Otro chat ya está manteniendo esta conversación.",
             "resumeInChatTranscriptMissing": "El historial de esta conversación no se pudo cargar, por lo que no se puede reanudar en el chat.",
-            "resumeInChatFailed": "No se pudo reanudar esta sesión en un chat nuevo."
+            "resumeInChatFailed": "No se pudo reanudar esta sesión en un chat nuevo.",
+            "resumeInNewCliUnavailable": "Esta sesión no se puede abrir en la CLI.",
+            "resumeInNewCliHostTooOld": "Actualiza Orca en el host que ejecuta este chat para reanudarlo en una nueva CLI."
           },
           "AiVaultPanelControls": {
             "scanningSessions": "Buscando sesiones",
@@ -13789,7 +13791,10 @@
             "deleteReasonNonLocalHost": "Solo se pueden eliminar las sesiones de este dispositivo.",
             "deleteReasonSyntheticPath": "Esta sesión no se puede eliminar desde Orca.",
             "deleteReasonUnsupportedAgent": "Las sesiones de {{value0}} no se pueden eliminar desde Orca.",
-            "resumeInNewChat": "Reanudar en nuevo chat"
+            "resumeInNewNativeChat": "Reanudar en un nuevo chat nativo",
+            "resumeInNewCli": "Reanudar en una nueva CLI",
+            "resumeInNewCliTooltipFork": "Hace un fork de esta conversación en una nueva sesión de CLI.",
+            "resumeInNewCliTooltipChat": "El chat nativo queda como está."
           },
           "AiVaultSessionDeleteDialog": {
             "title": "¿Eliminar esta sesión?",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index 7219b7871db..46622f0ffc1 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -13758,7 +13758,9 @@
             "sessionDeleteFailed": "Impossible de supprimer la session",
             "resumeInChatConflict": "Un autre chat tient déjà cette conversation.",
             "resumeInChatTranscriptMissing": "L'historique de cette conversation n'a pas pu être chargé, elle ne peut donc pas être reprise dans le chat.",
-            "resumeInChatFailed": "Impossible de reprendre cette session dans un nouveau chat."
+            "resumeInChatFailed": "Impossible de reprendre cette session dans un nouveau chat.",
+            "resumeInNewCliUnavailable": "Impossible d'ouvrir cette session dans la CLI.",
+            "resumeInNewCliHostTooOld": "Mettez à jour Orca sur l'hôte qui exécute ce chat pour le reprendre dans une nouvelle CLI."
           },
           "AiVaultPanelControls": {
             "scanningSessions": "Analyse des sessions",
@@ -13894,7 +13896,10 @@
             "deleteReasonNonLocalHost": "Seules les sessions de cet appareil peuvent être supprimées.",
             "deleteReasonSyntheticPath": "Cette session ne peut pas être supprimée depuis Orca.",
             "deleteReasonUnsupportedAgent": "{{value0}} sessions ne peuvent pas être supprimées depuis Orca.",
-            "resumeInNewChat": "Reprendre dans une nouvelle discussion"
+            "resumeInNewNativeChat": "Reprendre dans un nouveau chat natif",
+            "resumeInNewCli": "Reprendre dans une nouvelle CLI",
+            "resumeInNewCliTooltipFork": "Forke cette conversation dans une nouvelle session CLI.",
+            "resumeInNewCliTooltipChat": "Le chat natif reste tel quel."
           },
           "AiVaultSessionDeleteDialog": {
             "title": "Supprimer cette session ?",
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index c0f63177170..e5e78f750fe 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -13653,7 +13653,9 @@
             "sessionDeleteFailed": "セッションを削除できませんでした",
             "resumeInChatConflict": "別のチャットですでにこの会話が行われています。",
             "resumeInChatTranscriptMissing": "この会話の履歴を読み込めなかったため、チャットで再開できません。",
-            "resumeInChatFailed": "新規チャットでこのセッションを再開できませんでした。"
+            "resumeInChatFailed": "新規チャットでこのセッションを再開できませんでした。",
+            "resumeInNewCliUnavailable": "このセッションは CLI で開けません。",
+            "resumeInNewCliHostTooOld": "このチャットを新しい CLI で再開するには、チャットを実行しているホストの Orca を更新してください。"
           },
           "AiVaultPanelControls": {
             "scanningSessions": "セッションをスキャンしています",
@@ -13789,7 +13791,10 @@
             "deleteReasonNonLocalHost": "このデバイス上のセッションのみ削除できます。",
             "deleteReasonSyntheticPath": "このセッションは Orca では削除できません。",
             "deleteReasonUnsupportedAgent": "{{value0}} のセッションは Orca では削除できません。",
-            "resumeInNewChat": "新規チャットで再開"
+            "resumeInNewNativeChat": "新規ネイティブチャットで再開",
+            "resumeInNewCli": "新規 CLI で再開",
+            "resumeInNewCliTooltipFork": "この会話を新しい CLI セッションにフォークします。",
+            "resumeInNewCliTooltipChat": "ネイティブチャットはそのまま残ります。"
           },
           "AiVaultSessionDeleteDialog": {
             "title": "このセッションを削除しますか?",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 00d8a7c0e75..3d9b8ed3e88 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -13653,7 +13653,9 @@
             "sessionDeleteFailed": "세션을 삭제하지 못했습니다",
             "resumeInChatConflict": "다른 채팅에서 이미 이 대화를 진행 중입니다.",
             "resumeInChatTranscriptMissing": "이 대화 기록을 로드할 수 없어 채팅에서 재개할 수 없습니다.",
-            "resumeInChatFailed": "새 채팅에서 이 세션을 재개할 수 없습니다."
+            "resumeInChatFailed": "새 채팅에서 이 세션을 재개할 수 없습니다.",
+            "resumeInNewCliUnavailable": "이 세션은 CLI에서 열 수 없습니다.",
+            "resumeInNewCliHostTooOld": "이 채팅을 새 CLI에서 재개하려면 채팅을 실행하는 호스트의 Orca를 업데이트하세요."
           },
           "AiVaultPanelControls": {
             "scanningSessions": "세션 스캔 중",
@@ -13789,7 +13791,10 @@
             "deleteReasonNonLocalHost": "이 기기에 있는 세션만 삭제할 수 있습니다.",
             "deleteReasonSyntheticPath": "이 세션은 Orca에서 삭제할 수 없습니다.",
             "deleteReasonUnsupportedAgent": "{{value0}} 세션은 Orca에서 삭제할 수 없습니다.",
-            "resumeInNewChat": "새 채팅에서 재개"
+            "resumeInNewNativeChat": "새 기본 채팅에서 재개",
+            "resumeInNewCli": "새 CLI에서 재개",
+            "resumeInNewCliTooltipFork": "이 대화를 새 CLI 세션으로 포크합니다.",
+            "resumeInNewCliTooltipChat": "기본 채팅은 그대로 유지됩니다."
           },
           "AiVaultSessionDeleteDialog": {
             "title": "이 세션을 삭제할까요?",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 4c6442899f1..65da17b2c29 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -13653,7 +13653,9 @@
             "sessionDeleteFailed": "无法删除会话",
             "resumeInChatConflict": "另一个聊天室已经在进行此对话。",
             "resumeInChatTranscriptMissing": "无法加载此对话的历史记录，因此无法在聊天中恢复。",
-            "resumeInChatFailed": "无法在新聊天中恢复此会话。"
+            "resumeInChatFailed": "无法在新聊天中恢复此会话。",
+            "resumeInNewCliUnavailable": "无法在 CLI 中打开此会话。",
+            "resumeInNewCliHostTooOld": "请更新运行此聊天的主机上的 Orca，才能在新的 CLI 中恢复它。"
           },
           "AiVaultPanelControls": {
             "scanningSessions": "正在扫描会话",
@@ -13789,7 +13791,10 @@
             "deleteReasonNonLocalHost": "只能删除此设备上的会话。",
             "deleteReasonSyntheticPath": "此会话无法在 Orca 中删除。",
             "deleteReasonUnsupportedAgent": "{{value0}} 会话无法在 Orca 中删除。",
-            "resumeInNewChat": "在新聊天中继续"
+            "resumeInNewNativeChat": "在新的本机聊天中恢复",
+            "resumeInNewCli": "在新的 CLI 中恢复",
+            "resumeInNewCliTooltipFork": "将此对话派生到新的 CLI 会话中。",
+            "resumeInNewCliTooltipChat": "本机聊天保持不变。"
           },
           "AiVaultSessionDeleteDialog": {
             "title": "要删除此会话吗？",
diff --git a/src/renderer/src/lib/ai-vault-resume-command.ts b/src/renderer/src/lib/ai-vault-resume-command.ts
index f6192d31e99..76676ce10ec 100644
--- a/src/renderer/src/lib/ai-vault-resume-command.ts
+++ b/src/renderer/src/lib/ai-vault-resume-command.ts
@@ -19,19 +19,13 @@ import {
   resolveTuiAgentLaunchArgs,
   resolveTuiAgentLaunchEnv
 } from '../../../shared/tui-agent-launch-defaults'
-import { parseWslUncPath } from '../../../shared/wsl-paths'
 import type { AgentStartupShell } from '../../../shared/tui-agent-startup-shell'
 import type { AppState } from '@/store/types'
 import type { AiVaultSessionDragPayload } from '@/lib/ai-vault-session-drag'
-import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
-import { CLIENT_PLATFORM } from '@/lib/new-workspace'
 import { buildAgentResumeStartupPlan } from '@/lib/tui-agent-startup'
-import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner'
-import { LOCAL_EXECUTION_HOST_ID, parseExecutionHostId } from '../../../shared/execution-host'
-import {
-  getAiVaultResumeWorkspacePath,
-  resolveAiVaultResumeStartupShell
-} from '@/lib/ai-vault-resume-shell'
+import { LOCAL_EXECUTION_HOST_ID } from '../../../shared/execution-host'
+import { resolveAiVaultResumeStartupShell } from '@/lib/ai-vault-resume-shell'
+import { getAiVaultResumeCodexHome, getAiVaultResumePlatform } from '@/lib/ai-vault-resume-platform'
 
 export type AiVaultResumeCommandSession = Pick<
   AiVaultSession,
@@ -50,7 +44,7 @@ export type AiVaultResumeStartup = {
   providerSession?: AgentProviderSessionMetadata
 }
 
-type AiVaultResumeWorktreeArgs = {
+export type AiVaultResumeWorktreeArgs = {
   state: Pick<
     AppState,
     | 'activeRepoId'
@@ -147,24 +141,8 @@ function buildAiVaultResumeForWorktree(
       ...(providerSession ? { providerSession } : {})
     }
   }
-  const platform =
-    args.session.executionHostId &&
-    args.session.executionHostId !== LOCAL_EXECUTION_HOST_ID &&
-    args.session.executionHostPlatform
-      ? args.session.executionHostPlatform
-      : getAiVaultResumePlatform(args.state, args.worktreeId)
-  const codexHome = getAiVaultResumeCodexHome(args.session.codexHome, platform)
-  const isLocalSession =
-    !args.session.executionHostId || args.session.executionHostId === LOCAL_EXECUTION_HOST_ID
+  const { platform, codexHome, liveShell } = resolveAiVaultResumeHost(args)
   const resumeFilePath = normalizeAiVaultResumeFilePath(args.session.filePath, platform)
-  // Why: local shell settings do not describe a remote Windows host, whose
-  // queued resume command uses the remote default PowerShell syntax.
-  const liveShell: AgentStartupShell | undefined =
-    platform === 'win32'
-      ? isLocalSession
-        ? resolveAiVaultResumeShell(args)
-        : 'powershell'
-      : undefined
   const cwd = embedCwd ? args.session.cwd : null
   const startupCwd = !embedCwd && args.session.cwd ? { cwd: args.session.cwd } : {}
   if (isAntigravityReferenceSession(args.session)) {
@@ -254,21 +232,36 @@ function buildAiVaultResumeForWorktree(
   }
 }
 
-function resolveAiVaultResumeShell(args: AiVaultResumeWorktreeArgs): AgentStartupShell {
-  const platform =
-    args.session.executionHostId &&
-    args.session.executionHostId !== LOCAL_EXECUTION_HOST_ID &&
-    args.session.executionHostPlatform
-      ? args.session.executionHostPlatform
-      : getAiVaultResumePlatform(args.state, args.worktreeId)
+/** The platform and live shell a resume line is written for, and the Codex home it pins. */
+export function resolveAiVaultResumeHost(args: AiVaultResumeWorktreeArgs): {
+  platform: NodeJS.Platform
+  codexHome: string | null
+  liveShell: AgentStartupShell | undefined
+} {
   const isLocalSession =
     !args.session.executionHostId || args.session.executionHostId === LOCAL_EXECUTION_HOST_ID
-  return resolveAiVaultResumeStartupShell({
-    state: args.state,
-    worktreeId: args.worktreeId,
+  const platform =
+    !isLocalSession && args.session.executionHostPlatform
+      ? args.session.executionHostPlatform
+      : getAiVaultResumePlatform(args.state, args.worktreeId)
+  // Why: local shell settings do not describe a remote Windows host, whose
+  // queued resume command uses the remote default PowerShell syntax.
+  const liveShell: AgentStartupShell | undefined =
+    platform === 'win32'
+      ? isLocalSession
+        ? resolveAiVaultResumeStartupShell({
+            state: args.state,
+            worktreeId: args.worktreeId,
+            platform,
+            isLocalSession
+          })
+        : 'powershell'
+      : undefined
+  return {
     platform,
-    isLocalSession
-  })
+    codexHome: getAiVaultResumeCodexHome(args.session.codexHome, platform),
+    liveShell
+  }
 }
 
 export function getAiVaultAgentProviderSession(
@@ -290,47 +283,3 @@ export function getAiVaultAgentProviderSession(
   }
   return { key: 'session_id', id: session.sessionId }
 }
-
-function getAiVaultResumeCodexHome(
-  codexHome: string | null,
-  platform: NodeJS.Platform
-): string | null {
-  // Why: WSL UNC Codex homes must be POSIX when invoking Linux commands.
-  // Keep original paths unchanged for non-Linux targets.
-  if (!codexHome || platform !== 'linux') {
-    return codexHome
-  }
-  return parseWslUncPath(codexHome)?.linuxPath ?? codexHome
-}
-
-function getAiVaultResumePlatform(
-  state: Pick<
-    AppState,
-    | 'activeRepoId'
-    | 'activeWorktreeId'
-    | 'folderWorkspaces'
-    | 'projectGroups'
-    | 'projects'
-    | 'repos'
-    | 'settings'
-    | 'worktreesByRepo'
-  >,
-  worktreeId?: string | null
-): NodeJS.Platform {
-  const targetWorktreeId = worktreeId ?? state.activeWorktreeId
-  const executionHost = parseExecutionHostId(getExecutionHostIdForWorktree(state, targetWorktreeId))
-  if (executionHost?.kind === 'ssh' || executionHost?.kind === 'runtime') {
-    return 'linux'
-  }
-
-  const projectRuntime = getLocalProjectExecutionRuntimeContext(state, worktreeId, CLIENT_PLATFORM)
-  if (projectRuntime?.status === 'repair-required') {
-    return projectRuntime.repair.preferredRuntime.kind === 'wsl' ? 'linux' : CLIENT_PLATFORM
-  }
-  if (projectRuntime?.status === 'resolved' && projectRuntime.runtime.kind === 'wsl') {
-    return 'linux'
-  }
-
-  const workspacePath = getAiVaultResumeWorkspacePath(state, targetWorktreeId)
-  return workspacePath && parseWslUncPath(workspacePath) ? 'linux' : CLIENT_PLATFORM
-}
diff --git a/src/renderer/src/lib/ai-vault-resume-platform.ts b/src/renderer/src/lib/ai-vault-resume-platform.ts
new file mode 100644
index 00000000000..b7024da9800
--- /dev/null
+++ b/src/renderer/src/lib/ai-vault-resume-platform.ts
@@ -0,0 +1,54 @@
+import type { AppState } from '@/store/types'
+import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context'
+import { CLIENT_PLATFORM } from '@/lib/new-workspace'
+import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner'
+import { getAiVaultResumeWorkspacePath } from '@/lib/ai-vault-resume-shell'
+import { parseExecutionHostId } from '../../../shared/execution-host'
+import { parseWslUncPath } from '../../../shared/wsl-paths'
+
+// Which platform's grammar an Agent Session History resume is written in: the target
+// workspace's host, or Linux when the agent runs over SSH, a paired runtime, or WSL.
+
+export function getAiVaultResumeCodexHome(
+  codexHome: string | null,
+  platform: NodeJS.Platform
+): string | null {
+  // Why: WSL UNC Codex homes must be POSIX when invoking Linux commands.
+  // Keep original paths unchanged for non-Linux targets.
+  if (!codexHome || platform !== 'linux') {
+    return codexHome
+  }
+  return parseWslUncPath(codexHome)?.linuxPath ?? codexHome
+}
+
+export function getAiVaultResumePlatform(
+  state: Pick<
+    AppState,
+    | 'activeRepoId'
+    | 'activeWorktreeId'
+    | 'folderWorkspaces'
+    | 'projectGroups'
+    | 'projects'
+    | 'repos'
+    | 'settings'
+    | 'worktreesByRepo'
+  >,
+  worktreeId?: string | null
+): NodeJS.Platform {
+  const targetWorktreeId = worktreeId ?? state.activeWorktreeId
+  const executionHost = parseExecutionHostId(getExecutionHostIdForWorktree(state, targetWorktreeId))
+  if (executionHost?.kind === 'ssh' || executionHost?.kind === 'runtime') {
+    return 'linux'
+  }
+
+  const projectRuntime = getLocalProjectExecutionRuntimeContext(state, worktreeId, CLIENT_PLATFORM)
+  if (projectRuntime?.status === 'repair-required') {
+    return projectRuntime.repair.preferredRuntime.kind === 'wsl' ? 'linux' : CLIENT_PLATFORM
+  }
+  if (projectRuntime?.status === 'resolved' && projectRuntime.runtime.kind === 'wsl') {
+    return 'linux'
+  }
+
+  const workspacePath = getAiVaultResumeWorkspacePath(state, targetWorktreeId)
+  return workspacePath && parseWslUncPath(workspacePath) ? 'linux' : CLIENT_PLATFORM
+}
diff --git a/src/renderer/src/lib/ai-vault-session-fork-startup.test.ts b/src/renderer/src/lib/ai-vault-session-fork-startup.test.ts
new file mode 100644
index 00000000000..14f21a2c857
--- /dev/null
+++ b/src/renderer/src/lib/ai-vault-session-fork-startup.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { AppState } from '@/store/types'
+import { buildAiVaultForkStartupForWorktree } from './ai-vault-session-fork-startup'
+
+vi.mock('@/lib/new-workspace', () => ({
+  CLIENT_PLATFORM: 'darwin'
+}))
+
+type ForkState = Pick<
+  AppState,
+  | 'activeRepoId'
+  | 'activeWorktreeId'
+  | 'folderWorkspaces'
+  | 'projectGroups'
+  | 'projects'
+  | 'repos'
+  | 'settings'
+  | 'worktreesByRepo'
+>
+
+function makeState(): ForkState {
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fork builder reads only these slices; the rest of AppState is never reached.
+  return {
+    activeRepoId: 'repo-1',
+    activeWorktreeId: 'repo-1::worktree-1',
+    folderWorkspaces: [],
+    projectGroups: [],
+    repos: [{ id: 'repo-1', path: '/Users/ada/repo' }],
+    projects: [{ id: 'repo-1', sourceRepoIds: ['repo-1'] }],
+    settings: {
+      agentDefaultArgs: { claude: '', codex: '' },
+      agentDefaultEnv: { claude: {}, codex: {} }
+    },
+    worktreesByRepo: {
+      'repo-1': [{ id: 'repo-1::worktree-1', repoId: 'repo-1', path: '/Users/ada/repo' }]
+    }
+  } as unknown as ForkState
+}
+
+const SESSION_ID = '019fd532-7c11-7a90-b6de-4e1a2c3d5f60'
+
+describe('AI Vault fork into the CLI', () => {
+  it('forks Claude in the recorded folder without claiming the chat-owned session', () => {
+    const startup = buildAiVaultForkStartupForWorktree({
+      state: makeState(),
+      worktreeId: 'repo-1::worktree-1',
+      session: { agent: 'claude', sessionId: SESSION_ID, cwd: '/Users/ada/repo', codexHome: null }
+    })
+
+    expect(startup).toMatchObject({
+      command: `claude '--resume' '${SESSION_ID}' '--fork-session'`,
+      cwd: '/Users/ada/repo'
+    })
+    // A cold restore of the tab must never re-enter the conversation the chat still owns.
+    expect(startup).not.toHaveProperty('providerSession')
+  })
+
+  it('forks Codex under the home the transcript was found in', () => {
+    const startup = buildAiVaultForkStartupForWorktree({
+      state: makeState(),
+      worktreeId: 'repo-1::worktree-1',
+      session: {
+        agent: 'codex',
+        sessionId: SESSION_ID,
+        cwd: '/Users/ada/repo',
+        codexHome: '/Users/ada/.orca/codex-accounts/a1/home'
+      }
+    })
+
+    expect(startup?.command).toBe(
+      `CODEX_HOME='/Users/ada/.orca/codex-accounts/a1/home' codex '-c' 'tui.resume_cwd=current' 'fork' '${SESSION_ID}'`
+    )
+    expect(startup).not.toHaveProperty('providerSession')
+  })
+
+  it('returns null for an agent that cannot fork instead of a plain resume', () => {
+    expect(
+      buildAiVaultForkStartupForWorktree({
+        state: makeState(),
+        worktreeId: 'repo-1::worktree-1',
+        session: { agent: 'gemini', sessionId: SESSION_ID, cwd: '/Users/ada/repo', codexHome: null }
+      })
+    ).toBeNull()
+  })
+})
diff --git a/src/renderer/src/lib/ai-vault-session-fork-startup.ts b/src/renderer/src/lib/ai-vault-session-fork-startup.ts
new file mode 100644
index 00000000000..3f572ee7e80
--- /dev/null
+++ b/src/renderer/src/lib/ai-vault-session-fork-startup.ts
@@ -0,0 +1,64 @@
+import { isResumableTuiAgent } from '../../../shared/agent-session-resume'
+import {
+  buildAiVaultResumeShellCommand,
+  realHomeCodexResumeEnvDeletion
+} from '../../../shared/ai-vault-resume-command'
+import {
+  resolveTuiAgentLaunchArgs,
+  resolveTuiAgentLaunchEnv
+} from '../../../shared/tui-agent-launch-defaults'
+import { buildAgentResumeStartupPlan } from '@/lib/tui-agent-startup'
+import {
+  getAiVaultAgentProviderSession,
+  resolveAiVaultResumeHost,
+  type AiVaultResumeStartup,
+  type AiVaultResumeWorktreeArgs
+} from '@/lib/ai-vault-resume-command'
+
+/**
+ * A terminal session that starts from a copy of a conversation a native chat owns.
+ *
+ * Null when the agent cannot fork: a plain resume in its place would make the terminal a second
+ * writer on the chat's conversation. No `providerSession` either: the copy gets its own id, and a
+ * cold restore of this tab must never re-enter the chat's conversation.
+ */
+export function buildAiVaultForkStartupForWorktree(
+  args: AiVaultResumeWorktreeArgs
+): AiVaultResumeStartup | null {
+  const { session, state } = args
+  const providerSession = getAiVaultAgentProviderSession(session)
+  if (!providerSession || !isResumableTuiAgent(session.agent)) {
+    return null
+  }
+  const { platform, codexHome, liveShell } = resolveAiVaultResumeHost(args)
+  const plan = buildAgentResumeStartupPlan({
+    agent: session.agent,
+    providerSession,
+    cmdOverrides: {
+      ...state.settings?.agentCmdOverrides,
+      ...(args.commandOverride?.trim() ? { [session.agent]: args.commandOverride } : {})
+    },
+    platform,
+    shell: liveShell,
+    agentArgs: resolveTuiAgentLaunchArgs(session.agent, state.settings?.agentDefaultArgs),
+    agentEnv: resolveTuiAgentLaunchEnv(session.agent, state.settings?.agentDefaultEnv),
+    resumeInLaunchCwd: true,
+    fork: true
+  })
+  if (!plan) {
+    return null
+  }
+  return {
+    command: buildAiVaultResumeShellCommand({
+      resumeCommand: plan.launchCommand,
+      cwd: null,
+      platform,
+      codexHome,
+      shell: liveShell
+    }),
+    ...(plan.env ? { env: plan.env } : {}),
+    ...realHomeCodexResumeEnvDeletion(session),
+    ...(session.cwd ? { cwd: session.cwd } : {}),
+    launchConfig: plan.launchConfig
+  }
+}
diff --git a/src/renderer/src/lib/ai-vault-session-resume-preparation.test.ts b/src/renderer/src/lib/ai-vault-session-resume-preparation.test.ts
index d3a9b9e5b6d..ebabe7c2244 100644
--- a/src/renderer/src/lib/ai-vault-session-resume-preparation.test.ts
+++ b/src/renderer/src/lib/ai-vault-session-resume-preparation.test.ts
@@ -2,6 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { AiVaultSession } from '../../../shared/ai-vault-types'
 import {
   dropDeletedSshResumeCwd,
+  prepareAiVaultSessionForFork,
   prepareAiVaultSessionForResume
 } from './ai-vault-session-resume-preparation'
 
@@ -98,6 +99,46 @@ describe('prepareAiVaultSessionForResume', () => {
   })
 })
 
+describe('prepareAiVaultSessionForFork', () => {
+  // A fork of a chat-owned conversation must run under the selected account, as a resume does.
+  it('repins a chat-owned per-account session, asking the host as a fork', async () => {
+    const prepareSessionResume = vi.fn().mockResolvedValue({
+      useRealCodexHome: false,
+      substituteCodexHome: '/tmp/orca/codex-accounts/account-2/home'
+    })
+    stubPreparation(prepareSessionResume)
+    const owned = session({
+      codexHome: '/tmp/orca/codex-accounts/account-1/home',
+      structuredSession: { sessionId: 'session-1', workspaceId: 'worktree-1' }
+    })
+
+    const prepared = await prepareAiVaultSessionForFork(owned)
+
+    expect(prepared.codexHome).toBe('/tmp/orca/codex-accounts/account-2/home')
+    expect(prepareSessionResume).toHaveBeenCalledWith({
+      agent: 'codex',
+      sessionId: owned.sessionId,
+      filePath: owned.filePath,
+      codexHome: owned.codexHome,
+      executionHostId: 'local',
+      fork: true
+    })
+  })
+
+  it('does not ask the host for a home that needs no preparation', async () => {
+    const prepareSessionResume = vi.fn()
+    stubPreparation(prepareSessionResume)
+    const owned = session({
+      agent: 'claude',
+      codexHome: null,
+      structuredSession: { sessionId: 'session-1', workspaceId: 'worktree-1' }
+    })
+
+    await expect(prepareAiVaultSessionForFork(owned)).resolves.toBe(owned)
+    expect(prepareSessionResume).not.toHaveBeenCalled()
+  })
+})
+
 describe('dropDeletedSshResumeCwd', () => {
   it('leaves a live SSH session alone, scanner command and all', async () => {
     const pathExists = vi.fn().mockResolvedValue(true)
diff --git a/src/renderer/src/lib/ai-vault-session-resume-preparation.ts b/src/renderer/src/lib/ai-vault-session-resume-preparation.ts
index 5ce4500ee5e..8740d7a7796 100644
--- a/src/renderer/src/lib/ai-vault-session-resume-preparation.ts
+++ b/src/renderer/src/lib/ai-vault-session-resume-preparation.ts
@@ -9,10 +9,22 @@ import {
 } from '../../../shared/execution-host'
 import type { AiVaultResumeCommandSession } from './ai-vault-resume-command'
 
-export async function prepareAiVaultSessionForResume(
-  session: AiVaultSession
+export function prepareAiVaultSessionForResume(session: AiVaultSession): Promise<AiVaultSession> {
+  return session.structuredSession
+    ? Promise.resolve(session)
+    : prepareAiVaultSessionHome(session, false)
+}
+
+/** Picks the Codex home a fork of `session` runs under, the same way a resume picks it. */
+export function prepareAiVaultSessionForFork(session: AiVaultSession): Promise<AiVaultSession> {
+  return prepareAiVaultSessionHome(session, true)
+}
+
+async function prepareAiVaultSessionHome(
+  session: AiVaultSession,
+  fork: boolean
 ): Promise<AiVaultSession> {
-  if (session.structuredSession || !aiVaultSessionNeedsResumePreparation(session)) {
+  if (!aiVaultSessionNeedsResumePreparation(session)) {
     return session
   }
   const result = await window.api.aiVault.prepareSessionResume({
@@ -20,7 +32,8 @@ export async function prepareAiVaultSessionForResume(
     sessionId: session.sessionId,
     filePath: session.filePath,
     codexHome: session.codexHome,
-    executionHostId: session.executionHostId
+    executionHostId: session.executionHostId,
+    ...(fork ? { fork: true } : {})
   })
   if (result.useRealCodexHome) {
     return { ...session, codexHome: null }
diff --git a/src/shared/agent-resume-argv.ts b/src/shared/agent-resume-argv.ts
index 79bbad55231..0adda53d295 100644
--- a/src/shared/agent-resume-argv.ts
+++ b/src/shared/agent-resume-argv.ts
@@ -78,3 +78,18 @@ export function getAgentResumeArgv(
       return providerSession.key === 'session_id' ? ['jcode', '--resume', id] : null
   }
 }
+
+/** Opens a copy of the conversation under a new id, leaving the original untouched. Only the two
+ *  agents native chat can own a conversation for, which is the only case that needs a fork. */
+export function getAgentForkArgv(
+  agent: ResumableTuiAgent,
+  providerSession: AgentProviderSessionMetadata
+): string[] | null {
+  if (providerSession.key !== 'session_id') {
+    return null
+  }
+  if (agent === 'claude') {
+    return ['claude', '--resume', providerSession.id, '--fork-session']
+  }
+  return agent === 'codex' ? ['codex', 'fork', providerSession.id] : null
+}
diff --git a/src/shared/agent-session-resume.ts b/src/shared/agent-session-resume.ts
index ba1f5574ab1..18f373dec46 100644
--- a/src/shared/agent-session-resume.ts
+++ b/src/shared/agent-session-resume.ts
@@ -286,4 +286,4 @@ export function extractAgentProviderSession(
 }
 
 // Re-exported so the 18 existing call sites keep one import path.
-export { getAgentResumeArgv } from './agent-resume-argv'
+export { getAgentForkArgv, getAgentResumeArgv } from './agent-resume-argv'
diff --git a/src/shared/ai-vault-resume-preparation.ts b/src/shared/ai-vault-resume-preparation.ts
index 64797710537..93e15accf08 100644
--- a/src/shared/ai-vault-resume-preparation.ts
+++ b/src/shared/ai-vault-resume-preparation.ts
@@ -4,7 +4,11 @@ export type AiVaultPrepareSessionResumeArgs = Pick<
   AiVaultSession,
   'agent' | 'filePath' | 'codexHome' | 'executionHostId'
 > &
-  Partial<Pick<AiVaultSession, 'sessionId'>>
+  Partial<Pick<AiVaultSession, 'sessionId'>> & {
+    /** A fork only reads the conversation, so a native chat that owns it does not refuse it.
+     *  Older hosts drop the field and refuse as for a resume. */
+    fork?: boolean
+  }
 
 export type AiVaultPrepareSessionResumeResult = {
   useRealCodexHome: boolean
diff --git a/src/shared/rpc-contract/ai-vault-params.ts b/src/shared/rpc-contract/ai-vault-params.ts
index f2f86da6a22..a6be64eb2ec 100644
--- a/src/shared/rpc-contract/ai-vault-params.ts
+++ b/src/shared/rpc-contract/ai-vault-params.ts
@@ -58,7 +58,8 @@ export const AiVaultPrepareSessionResumeParams = z.object({
   sessionId: z.string().min(1).max(512).optional(),
   filePath: z.string().min(1).max(AI_VAULT_SCOPE_PATH_MAX_LENGTH),
   codexHome: z.string().min(1).max(AI_VAULT_SCOPE_PATH_MAX_LENGTH).nullable(),
-  executionHostId: z.string().optional()
+  executionHostId: z.string().optional(),
+  fork: z.boolean().optional()
 })
 
 export const AiVaultSessionTitlesParams = z.object({
diff --git a/src/shared/tui-agent-fork-startup.test.ts b/src/shared/tui-agent-fork-startup.test.ts
new file mode 100644
index 00000000000..476644837cb
--- /dev/null
+++ b/src/shared/tui-agent-fork-startup.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import { getAgentForkArgv } from './agent-resume-argv'
+import { buildAgentResumeStartupPlan } from './tui-agent-startup'
+
+const SESSION = { key: 'session_id', id: 's1' } as const
+
+describe('agent fork startup', () => {
+  it('forks Claude and Codex and nothing else', () => {
+    expect(getAgentForkArgv('claude', SESSION)).toEqual([
+      'claude',
+      '--resume',
+      's1',
+      '--fork-session'
+    ])
+    expect(getAgentForkArgv('codex', SESSION)).toEqual(['codex', 'fork', 's1'])
+    expect(getAgentForkArgv('gemini', SESSION)).toBeNull()
+    expect(getAgentForkArgv('claude', { key: 'conversation_id', id: 's1' })).toBeNull()
+  })
+
+  it('builds a Claude fork plan that replaces a stored resume selector', () => {
+    const plan = buildAgentResumeStartupPlan({
+      agent: 'claude',
+      providerSession: SESSION,
+      cmdOverrides: { claude: 'claude --continue' },
+      platform: 'darwin',
+      fork: true
+    })
+
+    expect(plan?.launchCommand).toBe("claude '--resume' 's1' '--fork-session'")
+  })
+
+  it('builds a Codex fork plan that opens in the launch folder', () => {
+    const plan = buildAgentResumeStartupPlan({
+      agent: 'codex',
+      providerSession: SESSION,
+      cmdOverrides: {},
+      platform: 'darwin',
+      resumeInLaunchCwd: true,
+      fork: true
+    })
+
+    expect(plan?.launchCommand).toBe("codex '-c' 'tui.resume_cwd=current' 'fork' 's1'")
+  })
+
+  it('refuses a fork for an agent that cannot fork rather than resuming it', () => {
+    expect(
+      buildAgentResumeStartupPlan({
+        agent: 'gemini',
+        providerSession: SESSION,
+        cmdOverrides: {},
+        platform: 'darwin',
+        fork: true
+      })
+    ).toBeNull()
+  })
+})
diff --git a/src/shared/tui-agent-resume-startup.ts b/src/shared/tui-agent-resume-startup.ts
index 173aabf1aa7..9e01a438bd4 100644
--- a/src/shared/tui-agent-resume-startup.ts
+++ b/src/shared/tui-agent-resume-startup.ts
@@ -1,4 +1,5 @@
 import {
+  getAgentForkArgv,
   getAgentResumeArgv,
   type AgentProviderSessionMetadata,
   type ResumableTuiAgent
@@ -27,8 +28,12 @@ export function buildAgentResumeStartupPlan(args: {
   isRemote?: boolean
   /** The caller chose the terminal folder on purpose, so Codex must not ask for the recorded one. */
   resumeInLaunchCwd?: boolean
+  /** Open a copy of the conversation instead of re-entering it; null for agents that cannot. */
+  fork?: boolean
 }): AgentStartupPlan | null {
-  const resumeArgv = getAgentResumeArgv(args.agent, args.providerSession, args.ompResumeFilePath)
+  const resumeArgv = args.fork
+    ? getAgentForkArgv(args.agent, args.providerSession)
+    : getAgentResumeArgv(args.agent, args.providerSession, args.ompResumeFilePath)
   if (!resumeArgv) {
     return null
   }