From 1ae7aa8bb4fb725f20310cb9cfa3c3d9686e9dcb Mon Sep 17 00:00:00 2001 From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com> Date: Sun, 6 Sep 2026 23:24:21 -0700 Subject: [PATCH] feat(native-chat): resume an Agent Session History row into a new structured chat (#19176) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(native-chat): resume an Agent Session History row into a new structured chat A Claude or Codex row in Agent Session History gains "Resume in New Chat": it opens a new structured native-chat tab that continues that provider conversation, with the prior turns already in the journal. Until now those rows could only be resumed into a PTY terminal; the structured branch could reveal a chat Orca already owned but could not adopt one it had never held. Almost all of the machinery existed. Both lanes already resume from the record's provider handle chain, the journal already has a transcript importer, and the handle chain already models `adopted` as an origin. The gap was that a create always minted an empty chain, so the adapters started a fresh conversation. This seeds that chain. The client names only the conversation. `agentSession.create` is reachable by paired mobile clients, so the transcript path and the account home are derived by the executing host and validated against the account homes it recognises — a client-supplied path would choose which file the host imports and which credential directory the provider child launches against. Failure refuses rather than degrades. A transcript that cannot be found refuses before anything is created; one that fails or decodes empty *after* the provider has resumed fails the attach, tearing the child down and publishing no tab, because an empty journal beside a context-carrying agent claims a continuity the provider never gave. Codex can resume into any workspace since it is handed the rollout path; Claude resolves transcripts under a project key derived from the launch cwd, so it is offered only for the workspace the conversation was recorded in. * fix(native-chat): widen adopted-home discovery and keep ordinary launches untouched Three corrections from review of the first commit. The adoption's account-home candidates now include the extra Codex homes session discovery already scans. A row this host listed could otherwise refuse to resume, which reads as the feature being broken rather than as a scope. Ordinary launches call `createStructuredAgentSessionLaunchIntent` with two arguments again. Passing the resume source unconditionally appended a trailing `undefined` that four existing call-site assertions had to absorb; the churn was the caller's fault, not the tests'. The transactional adoption guard's comment claimed the self-exemption is what lets a committed create replay. It is not: replay is settled earlier by the operation ledger, and an adoption always arrives with a null expected fence, so a request naming an existing session id is refused a few lines below either way. The exemption is part of what "another record" means, and the comment now says that instead. * fix: preserve history adoption through create and retries * fix: replay committed history adoption from durable identity * fix: validate history before claiming adopted sessions * fix: extract AI vault resume domains * fix: recognize typed history resume refusals --------- Co-authored-by: Merge Sim --- src/main/ai-vault/cached-session-list.ts | 6 + .../journal-legacy-import.ts | 35 +-- ...tured-agent-session-adopted-import.test.ts | 250 ++++++++++++++++++ ...structured-agent-session-adopted-import.ts | 110 ++++++++ .../structured-agent-session-attach-flow.ts | 11 + .../structured-agent-session-attach.ts | 63 ++++- ...red-agent-session-history-adoption.test.ts | 235 ++++++++++++++++ ...ructured-agent-session-history-adoption.ts | 156 +++++++++++ ...gent-session-reservation-admission.test.ts | 199 ++++++++++++++ .../agent-session-reservation-admission.ts | 53 +++- ...lve-recovered-structured-tui-transcript.ts | 57 +++- ...ured-agent-session-adoption-replay.test.ts | 235 ++++++++++++++++ .../structured-agent-session-create.ts | 11 +- .../structured-agent-session-schemas.ts | 12 +- .../methods/structured-agent-session.test.ts | 40 ++- .../rpc/methods/structured-agent-session.ts | 13 +- ...tructured-agent-session-create-adoption.ts | 113 ++++++++ .../components/right-sidebar/AiVaultPanel.tsx | 20 ++ .../AiVaultSessionActionMenuItems.tsx | 12 + .../right-sidebar/AiVaultSessionDetails.tsx | 36 ++- .../right-sidebar/AiVaultSessionRow.tsx | 5 + .../AiVaultSessionVirtualList.tsx | 207 +-------------- .../right-sidebar/AiVaultVirtualRow.tsx | 212 +++++++++++++++ .../SessionRowTrailingActions.tsx | 4 + .../ai-vault-session-launch-actions.ts | 164 ++++++------ .../ai-vault-session-launch-target.ts | 87 ++++++ ...-vault-session-resume-in-chat-workspace.ts | 64 +++++ .../ai-vault-session-resume-in-chat.test.ts | 170 ++++++++++++ .../ai-vault-session-resume-in-chat.ts | 100 +++++++ .../ai-vault-session-resume.test.ts | 2 +- src/renderer/src/i18n/locales/en.json | 8 +- .../src/lib/agent-launch-routing.test.ts | 28 +- src/renderer/src/lib/agent-launch-routing.ts | 32 ++- .../lib/launch-structured-agent-session.ts | 7 +- ...structured-agent-session-launch-callers.ts | 4 + ...ent-session-launch-resume-identity.test.ts | 157 +++++++++++ .../lib/structured-agent-session-launch.ts | 38 ++- .../agent-session-provider-handle.test.ts | 91 +++++++ src/shared/protocol-version.ts | 7 + .../structured-agent-session-create.test.ts | 82 ++++++ src/shared/structured-agent-session-create.ts | 21 +- .../structured-agent-session-mutation.ts | 6 +- 42 files changed, 2827 insertions(+), 336 deletions(-) create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.test.ts create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.ts create mode 100644 src/main/native-chat/structured-agent-session-history-adoption.test.ts create mode 100644 src/main/native-chat/structured-agent-session-history-adoption.ts create mode 100644 src/main/runtime/agent-session-reservation-admission.test.ts create mode 100644 src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts create mode 100644 src/main/runtime/structured-agent-session-create-adoption.ts create mode 100644 src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx create mode 100644 src/renderer/src/components/right-sidebar/ai-vault-session-launch-target.ts create mode 100644 src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-workspace.ts create mode 100644 src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.test.ts create mode 100644 src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.ts create mode 100644 src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts create mode 100644 src/shared/structured-agent-session-create.test.ts diff --git a/src/main/ai-vault/cached-session-list.ts b/src/main/ai-vault/cached-session-list.ts index c8d04205091..c46e4bdd4a6 100644 --- a/src/main/ai-vault/cached-session-list.ts +++ b/src/main/ai-vault/cached-session-list.ts @@ -49,6 +49,12 @@ export function configureAiVaultSessionSources(next: AiVaultSessionSources): voi sources = next } +/** The extra Codex homes session discovery scans. Anything that decides what a listed row may be + * resumed from must read the same set, or a row can be listed and then refuse to resume. */ +export function configuredAdditionalCodexHomePaths(): readonly string[] { + return sources.getAdditionalCodexHomePaths?.() ?? [] +} + export async function listAiVaultSessions( args?: AiVaultListArgs, options: { signal?: AbortSignal } = {} diff --git a/src/main/native-chat/agent-session-journal/journal-legacy-import.ts b/src/main/native-chat/agent-session-journal/journal-legacy-import.ts index 6a2ff099dbc..0907ebd28f2 100644 --- a/src/main/native-chat/agent-session-journal/journal-legacy-import.ts +++ b/src/main/native-chat/agent-session-journal/journal-legacy-import.ts @@ -90,6 +90,24 @@ export async function importLegacyTranscriptIntoJournal(input: { fence: number options?: LegacyImportOptions }): Promise { + const prepared = await prepareLegacyTranscriptImport(input) + if (!prepared.ok) { + return prepared + } + // An empty import must preserve any existing repair anchor and disclosure. + if (prepared.items.length === 0) { + const current = input.journal.cursor() + return { ok: true, epoch: current.epoch, cursor: current, imported: 0, replaced: false } + } + const cursor = await input.journal.replaceEpochItems('legacy_import', input.fence, prepared.items) + return { ok: true, epoch: cursor.epoch, cursor, imported: prepared.items.length, replaced: true } +} + +export async function prepareLegacyTranscriptImport(input: { + agent: AgentType + sessionId: string + options?: LegacyImportOptions +}): Promise<{ ok: true; items: JournalReplacementItem[] } | { ok: false; error: string }> { const options = input.options ?? {} const limits = options.limits ?? DEFAULT_JOURNAL_PAYLOAD_LIMITS const transcriptAgent = resolveNativeChatTranscriptAgent(input.agent) @@ -145,22 +163,7 @@ export async function importLegacyTranscriptIntoJournal(input: { observedAt: message.timestamp ?? undefined }) } - // A transcript that decodes to nothing reconstructs nothing, and an empty - // replacement is not a harmless no-op: it would delete the repair's anchor and - // its disclosure, leaving nothing to ask for the history again. The epoch - // stands so a later read can still rebuild it. - if (replacement.length === 0) { - const current = input.journal.cursor() - return { ok: true, epoch: current.epoch, cursor: current, imported: 0, replaced: false } - } - const cursor = await input.journal.replaceEpochItems('legacy_import', input.fence, replacement) - return { - ok: true, - epoch: cursor.epoch, - cursor, - imported: decoded.messages.length, - replaced: true - } + return { ok: true, items: replacement } } const TRANSCRIPT_DECODERS = { diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.test.ts new file mode 100644 index 00000000000..0248799980a --- /dev/null +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.test.ts @@ -0,0 +1,250 @@ +// Source validation must finish before a new session claims the provider conversation. + +import { mkdtemp, rm, writeFile, truncate } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope' +import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store' +import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter' +import { + attachFingerprintFields, + type AgentSessionAttachParams +} from './structured-agent-session-attach' +import { performAttach, type AttachFlowInput } from './structured-agent-session-attach-flow' +import { AgentSessionJournal } from '../agent-session-journal/journal-store' +import { agentSessionJournalCloseRetries } from '../agent-session-journal/journal-close-retry' +import * as legacyImport from '../agent-session-journal/journal-legacy-import' + +const NOW = 1_800_000_000_000 +const SESSION = 'codex_adopting_session' +const THREAD = 'adopted-thread' +const OPERATION = `${NOW}-${'1'.padStart(32, '0')}` +let root: string | null = null +let store: AgentSessionRecordStore | null = null + +afterEach(async () => { + if (root) { + await rm(root, { recursive: true, force: true }) + } + root = null + store = null + vi.restoreAllMocks() +}) + +/** A minimal Codex rollout the legacy transcript decoder can read back. */ +async function writeCodexRollout(path: string, text: string): Promise { + const lines = [ + JSON.stringify({ + type: 'session_meta', + payload: { id: THREAD, timestamp: '2026-09-06T18:00:00.000Z', cwd: '/workspace' } + }), + JSON.stringify({ + type: 'response_item', + timestamp: '2026-09-06T18:00:01.000Z', + payload: { + type: 'message', + role: 'user', + content: text + } + }) + ] + await writeFile(path, `${lines.join('\n')}\n`, 'utf8') +} + +function attachParams(transcriptPath?: string): AgentSessionAttachParams { + const params: AgentSessionAttachParams = { + envelope: { + sessionId: SESSION, + clientOperationId: OPERATION, + expectedRuntimeFence: null, + payloadFingerprint: '' + }, + location: { + executionHostId: 'local', + wslDistro: null, + workspaceId: 'workspace-1', + workspaceKind: 'folder' + }, + provider: 'codex', + agent: 'codex', + accountHome: { variable: 'CODEX_HOME', path: '/home/dev/.codex' }, + runtimeKind: 'native', + adopt: { + providerHandle: { kind: 'codex', threadId: THREAD }, + ...(transcriptPath ? { transcriptPath } : {}) + } + } + return { + ...params, + envelope: { + ...params.envelope, + payloadFingerprint: computeAgentSessionPayloadFingerprint({ + method: 'agentSession.attach', + sessionId: SESSION, + fields: attachFingerprintFields(params) + }) + } + } +} + +function adapter(): StructuredAgentSessionAdapter { + return { + acquire: vi + .fn() + .mockImplementation(async ({ fence, spawnToken }) => ({ + process: { hostId: 'local', pid: 4242, processStartTimeMs: NOW, spawnToken }, + link: { + linkId: 'resumed-link', + handle: { provider: 'codex', threadId: THREAD }, + origin: 'resumed', + mintedAtFence: fence, + observedAt: NOW + } + })), + // Proven released, so the failure rethrows its own cause rather than an unproven-exit wrapper. + releaseAcquisition: vi.fn(async () => true), + dispatch: vi.fn(), + cancelTurn: vi.fn(), + answerPrompt: vi.fn(), + setOption: vi.fn() + } +} + +async function attach( + transcriptPath: string | undefined, + sessionAdapter: StructuredAgentSessionAdapter, + onAttached: AttachFlowInput['onAttached'] = () => {} +) { + store ??= await AgentSessionRecordStore.open({ directory: join(root!, 'store'), hostId: 'local' }) + return performAttach({ + store, + adapter: sessionAdapter, + journalRoot: root!, + authority: { + spawnToken: 'spawn-a', + claimKeyId: 'key-1', + handoffOperationId: OPERATION, + probe: { outcome: 'reservation-unused' } + }, + callerKey: 'client-1', + params: attachParams(transcriptPath), + now: () => NOW, + onAttached + }) +} + +describe('adopting a provider conversation on create', () => { + it('seeds the chain from the adopted handle and fills the journal from its transcript', async () => { + root = await mkdtemp(join(tmpdir(), 'orca-adopt-import-')) + const transcriptPath = join(root, 'rollout.jsonl') + await writeCodexRollout(transcriptPath, 'token ORCA-ADOPT-1') + const sessionAdapter = adapter() + + const result = await attach(transcriptPath, sessionAdapter) + + expect(result).toMatchObject({ ok: true }) + // The adapter was asked to resume, not to start: the seeded chain is what tells it which + // conversation this session owns. + const page = (result as { value: { page: { items: unknown[] } } }).value.page + expect(JSON.stringify(page.items)).toContain('ORCA-ADOPT-1') + }) + + it('replays create without replacing journal-only messages or rereading the source', async () => { + root = await mkdtemp(join(tmpdir(), 'orca-adopt-replay-')) + const transcriptPath = join(root, 'rollout.jsonl') + await writeCodexRollout(transcriptPath, 'original turn') + const sessionAdapter = adapter() + const first = await attach(transcriptPath, sessionAdapter, async ({ journal }) => { + await journal.appendItem( + { provider: 'legacy', agent: 'codex', sessionId: THREAD, recordId: 'journal-only' }, + { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'not yet in rollout' }] }, + { fence: 1 } + ) + await journal.close() + }) + expect(first.ok).toBe(true) + await rm(transcriptPath) + const replay = await attach(transcriptPath, sessionAdapter, async ({ journal }) => + journal.close() + ) + expect(replay).toMatchObject({ ok: true, replayed: true }) + if (!first.ok || !replay.ok) { + throw new Error('attach failed') + } + expect(replay.cursor.epoch).toBe(first.cursor.epoch) + expect(JSON.stringify(replay.value.page.items)).toContain('not yet in rollout') + expect(sessionAdapter.acquire).toHaveBeenCalledTimes(1) + }) + + it.each(['missing', 'oversized', 'empty', 'invalid', 'source-less'] as const)( + 'refuses %s source before claiming a conversation', + async (kind) => { + root = await mkdtemp(join(tmpdir(), 'orca-adopt-preflight-')) + const transcriptPath = join(root, 'rollout.jsonl') + if (kind === 'oversized') { + await writeCodexRollout(transcriptPath, 'original turn') + await truncate(transcriptPath, 16 * 1024 * 1024 + 1) + } else if (kind === 'empty' || kind === 'invalid') { + await writeFile(transcriptPath, kind === 'empty' ? '' : 'not json\n') + } + const sessionAdapter = adapter() + const onAttached = vi.fn() + const result = await attach( + kind === 'source-less' ? undefined : transcriptPath, + sessionAdapter, + onAttached + ) + expect(result).toMatchObject({ + ok: false, + refusal: { code: 'agent_session_identity_required' } + }) + expect(sessionAdapter.acquire).not.toHaveBeenCalled() + expect(sessionAdapter.releaseAcquisition).not.toHaveBeenCalled() + expect(onAttached).not.toHaveBeenCalled() + expect(store?.getRecord(SESSION)).toBeNull() + expect(store?.listOperationRows()).toEqual([]) + if (kind === 'oversized') { + expect(JSON.stringify(result)).toContain('import bound') + } + } + ) + + it('still releases acquisition and closes the provisional journal on an import write failure', async () => { + root = await mkdtemp(join(tmpdir(), 'orca-adopt-write-failure-')) + const transcriptPath = join(root, 'rollout.jsonl') + await writeCodexRollout(transcriptPath, 'valid source') + vi.spyOn(AgentSessionJournal.prototype, 'replaceEpochItems').mockRejectedValueOnce( + new Error('disk write failed') + ) + const close = vi.spyOn(agentSessionJournalCloseRetries, 'closeOrRetain') + const sessionAdapter = adapter() + await expect(attach(transcriptPath, sessionAdapter)).rejects.toThrow('disk write failed') + expect(sessionAdapter.acquire).toHaveBeenCalledTimes(1) + expect(sessionAdapter.releaseAcquisition).toHaveBeenCalledTimes(1) + expect(close).toHaveBeenCalledTimes(1) + }) + + it('prepares a valid source once before acquisition and imports those exact items', async () => { + root = await mkdtemp(join(tmpdir(), 'orca-adopt-once-')) + const transcriptPath = join(root, 'rollout.jsonl') + await writeCodexRollout(transcriptPath, 'prepared before acquiring') + const prepare = vi.spyOn(legacyImport, 'prepareLegacyTranscriptImport') + const sessionAdapter = adapter() + const acquire = sessionAdapter.acquire + sessionAdapter.acquire = vi.fn(async (input) => { + expect(prepare).toHaveBeenCalledTimes(1) + await rm(transcriptPath) + return acquire(input) + }) + const result = await attach(transcriptPath, sessionAdapter, async ({ journal }) => + journal.close() + ) + expect(result.ok).toBe(true) + if (!result.ok) { + throw new Error('attach failed') + } + expect(JSON.stringify(result.value.page.items)).toContain('prepared before acquiring') + expect(prepare).toHaveBeenCalledTimes(1) + }) +}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.ts new file mode 100644 index 00000000000..459d21b1f3b --- /dev/null +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adopted-import.ts @@ -0,0 +1,110 @@ +import type { AgentSessionWireRefusal } from '../../../shared/agent-session-wire' +import type { AgentSessionRecord } from '../../../shared/agent-session-record' +import type { AgentSessionAttachParams, AttachedJournal } from './structured-agent-session-attach' +import { agentSessionJournalCloseRetries } from '../agent-session-journal/journal-close-retry' +import type { JournalReplacementItem } from '../agent-session-journal/journal-epoch-replacement' +import { + importLegacyTranscriptIntoJournal, + prepareLegacyTranscriptImport +} from '../agent-session-journal/journal-legacy-import' + +export async function prepareAdoptedTranscript( + params: AgentSessionAttachParams +): Promise< + | { ok: true; items: JournalReplacementItem[] | null } + | { ok: false; refusal: AgentSessionWireRefusal } +> { + try { + return { ok: true, items: await readAdoptedTranscript(params) } + } catch (error) { + return { + ok: false, + refusal: { + code: 'agent_session_identity_required', + message: error instanceof Error ? error.message : String(error) + } + } + } +} + +// Validate source input before a new record can claim the provider conversation. +async function readAdoptedTranscript( + params: AgentSessionAttachParams +): Promise { + const adopt = params.adopt + if (!adopt) { + return null + } + if (!adopt.transcriptPath) { + throw new Error('agent_session_identity_required') + } + const prepared = await prepareLegacyTranscriptImport({ + agent: params.agent, + sessionId: + adopt.providerHandle.kind === 'claude' + ? adopt.providerHandle.sessionId + : adopt.providerHandle.threadId, + options: { filePath: adopt.transcriptPath } + }) + if (!prepared.ok) { + throw new Error(prepared.error) + } + if (prepared.items.length === 0) { + throw new Error('agent_session_identity_required') + } + return prepared.items +} + +// Import before publication so the first visible chat agrees with the provider's resumed context. +export async function importAdoptedTranscript( + params: AgentSessionAttachParams, + attached: AttachedJournal, + record: AgentSessionRecord, + prepared: JournalReplacementItem[] | null +): Promise { + try { + await applyAdoptedTranscript(params, attached, record, prepared) + } catch (error) { + // Publication has not taken ownership of this provisional journal yet. + await agentSessionJournalCloseRetries.closeOrRetain(attached.journal) + throw error + } +} + +async function applyAdoptedTranscript( + params: AgentSessionAttachParams, + attached: AttachedJournal, + record: AgentSessionRecord, + prepared: JournalReplacementItem[] | null +): Promise { + const adopt = params.adopt + // A new journal contains only its epoch row; replay must preserve subsequent durable writes. + if (!adopt || attached.journal.cursor().sequence > 1) { + return + } + if (prepared) { + await attached.journal.replaceEpochItems('legacy_import', record.lease.runtimeFence, prepared) + return + } + if (!adopt.transcriptPath) { + throw new Error('agent_session_identity_required') + } + const imported = await importLegacyTranscriptIntoJournal({ + journal: attached.journal, + agent: params.agent, + sessionId: + adopt.providerHandle.kind === 'claude' + ? adopt.providerHandle.sessionId + : adopt.providerHandle.threadId, + fence: record.lease.runtimeFence, + options: { filePath: adopt.transcriptPath } + }) + if (!imported.ok) { + throw new Error(imported.error) + } + // `replaced: false` means the transcript decoded to nothing. The row promised a conversation and + // the provider resumed one, so an empty journal here is a disagreement, not an empty chat. + if (!imported.replaced) { + throw new Error('agent_session_identity_required') + } +} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts index b08a56ea4d9..8697e76ba3b 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts @@ -36,6 +36,10 @@ import type { StructuredAgentSessionEventSink } from './structured-agent-session import { readNativeSessionOptions } from './structured-agent-session-option-restoration' import { resolveAgentSessionReplayOutcome } from './structured-agent-session-replay-outcome' import { readAgentSessionHydrationPage } from './agent-session-history-page' +import { + importAdoptedTranscript, + prepareAdoptedTranscript +} from './structured-agent-session-adopted-import' export type AttachFlowInput = { store: AgentSessionRecordStore @@ -78,6 +82,12 @@ export async function performAttach( let acquisitionGeneration: string | null = null let reservedRecord: AgentSessionRecord | null = null let replayed = false + const preparedTranscript = store.getRecord(sessionId) + ? { ok: true as const, items: null } + : await prepareAdoptedTranscript(params) + if (!preparedTranscript.ok) { + return preparedTranscript + } try { const reserved = await store.reserveOwner( reserveRequestFor({ @@ -181,6 +191,7 @@ export async function performAttach( journalRoot: input.journalRoot, adapter: input.adapter }) + await importAdoptedTranscript(params, attached, record, preparedTranscript.items) await input.onAttached(attached, acquisitionGeneration) await store.recordOperationOutcome({ callerKey: input.callerKey, diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach.ts index 25bd808fd8b..38b626b2123 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach.ts @@ -10,7 +10,12 @@ import type { AgentSessionProviderHandle } from '../../../shared/agent-session-journal-types' import type { AgentSessionOwnerProbe } from '../../../shared/agent-session-lease-adjudication' -import type { AgentSessionHandleProvider } from '../../../shared/agent-session-provider-handle' +import type { + AgentSessionHandleProvider, + AgentSessionProviderHandleLink +} from '../../../shared/agent-session-provider-handle' +import { claudeProviderHandleLink } from '../../claude/claude-structured-owner-identity' +import { codexProviderHandleLink } from '../../codex/codex-structured-owner-identity' import type { AgentSessionAccountHome, AgentSessionExecutionLocation, @@ -59,6 +64,19 @@ export type AgentSessionAttachParams = { launchArgs?: string[] /** Omitted only for create-by-intent; the adapter proves the durable handle. */ providerHandle?: Exclude + /** + * Host-resolved only. Present when this create adopts an existing provider conversation rather + * than starting one: it seeds the handle chain so the adapter resumes instead of creating, and + * names the transcript to import so the journal shows the conversation so far. + * + * Deliberately separate from `providerHandle`, which `agentSession.ensure` already supplies + * without adopting — presence of a handle must never be what triggers a resume. + */ + adopt?: { + providerHandle: Exclude + /** Omitted only when the exact committed operation replays an already-imported journal. */ + transcriptPath?: string + } } /** Host-supplied half of the reservation. */ @@ -85,6 +103,10 @@ export function attachFingerprintFields(params: AgentSessionAttachParams): Recor accountHome: params.accountHome, runtimeKind: params.runtimeKind, providerHandle: params.providerHandle, + // Which conversation this attaches to, so an adopting create and a blank one never share an + // identity. The transcript path is excluded: it is where the host found that conversation this + // time, not part of what the caller asked for. + adoptedProviderHandle: params.adopt?.providerHandle, expectedRuntimeFence: params.envelope.expectedRuntimeFence } } @@ -183,6 +205,38 @@ export async function attachJournal(input: { } } +/** + * The first link of an adopting session's chain. + * + * `adopted` is the only origin besides `created` a chain will accept at its head, and it is the + * honest one here: this session did not create the conversation. The adapter appends its own + * `resumed` link once the provider proves the same identity root — or, when it proves the identical + * handle at the same fence, the validator elides that as a retry and this link stays the head. + */ +const ADOPTED_HANDLE_FENCE = 1 + +function adoptedProviderHandleLink( + handle: Exclude, + observedAt: number +): AgentSessionProviderHandleLink { + return handle.kind === 'claude' + ? claudeProviderHandleLink({ + sessionId: handle.sessionId, + leafUuid: handle.leafUuid, + resumed: false, + origin: 'adopted', + fence: ADOPTED_HANDLE_FENCE, + observedAt + }) + : codexProviderHandleLink({ + threadId: handle.threadId, + resumed: false, + origin: 'adopted', + fence: ADOPTED_HANDLE_FENCE, + observedAt + }) +} + export function reserveRequestFor(input: { sessionId: string params: AgentSessionAttachParams @@ -201,6 +255,13 @@ export function reserveRequestFor(input: { ...(authority.launchArgs ? { launchArgs: authority.launchArgs } : {}), ...(authority.launchEnv ? { launchEnv: authority.launchEnv } : {}), runtimeKind: params.runtimeKind, + ...(params.adopt + ? { + // Fence 1 is a new record's first, and the owner probe requires the head link to carry + // the record's current fence. + adoptedHandleLink: adoptedProviderHandleLink(params.adopt.providerHandle, input.now) + } + : {}), expectedFence: params.envelope.expectedRuntimeFence, spawnToken: authority.spawnToken, claimKeyId: authority.claimKeyId, diff --git a/src/main/native-chat/structured-agent-session-history-adoption.test.ts b/src/main/native-chat/structured-agent-session-history-adoption.test.ts new file mode 100644 index 00000000000..581bb29c364 --- /dev/null +++ b/src/main/native-chat/structured-agent-session-history-adoption.test.ts @@ -0,0 +1,235 @@ +import { describe, expect, it, vi } from 'vitest' +import { + agentSessionLeaseFixture, + agentSessionRecordFixture +} from '../../shared/agent-session-record.test-fixture' +import { + findCommittedStructuredAgentSessionAdoptionReplay, + findConflictingStructuredAdoption, + resolveStructuredAgentSessionAdoption, + structuredAdoptionConflictError, + type StructuredAgentSessionAdoptionOwnership +} from './structured-agent-session-history-adoption' + +const OPERATION = '1800000000000-00000000000000000000000000000001' + +function committedReplay(overrides: { callerKey?: string; operationId?: string } = {}) { + const lease = agentSessionLeaseFixture({ sessionId: 'codex_adopted' }) + return findCommittedStructuredAgentSessionAdoptionReplay({ + agent: 'codex', + providerSessionId: 'thread-1', + selfSessionId: 'codex_adopted', + callerKey: overrides.callerKey ?? 'client-1', + operationId: overrides.operationId ?? OPERATION, + record: { + ...agentSessionRecordFixture(lease), + provider: 'codex', + providerHandleChain: [ + { + linkId: 'codex-1-thread-1', + origin: 'adopted', + mintedAtFence: 1, + observedAt: 1_800_000_000_000, + handle: { provider: 'codex', threadId: 'thread-1' } + } + ], + accountHome: { variable: 'CODEX_HOME', path: '/home/dev/.codex-original' } + }, + operations: [ + { + callerKey: 'client-1', + operationId: OPERATION, + fingerprint: 'fingerprint-1', + operationTimestamp: 1_800_000_000_000, + recordedAt: 1_800_000_000_000, + expiresAt: 1_900_000_000_000, + outcome: { status: 'succeeded', sessionId: 'codex_adopted' } + } + ] + }) +} + +function ownership( + overrides: Partial = {} +): StructuredAgentSessionAdoptionOwnership { + return { + sessionId: 'codex_owner', + provider: 'codex', + providerSessionId: 'thread-1', + lease: agentSessionLeaseFixture(), + ...overrides + } +} + +describe('findConflictingStructuredAdoption', () => { + it('names the session that already holds the conversation', () => { + const owner = ownership() + + expect( + findConflictingStructuredAdoption({ + agent: 'codex', + providerSessionId: 'thread-1', + selfSessionId: 'codex_new', + ownership: [ownership({ sessionId: 'other', providerSessionId: 'thread-2' }), owner] + }) + ).toBe(owner) + }) + + it('exempts the requesting session, so a committed create replays instead of refusing', () => { + expect( + findConflictingStructuredAdoption({ + agent: 'codex', + providerSessionId: 'thread-1', + selfSessionId: 'codex_new', + ownership: [ownership({ sessionId: 'codex_new' })] + }) + ).toBeNull() + }) + + it('ignores an identical id held under the other provider', () => { + expect( + findConflictingStructuredAdoption({ + agent: 'claude', + providerSessionId: 'thread-1', + selfSessionId: 'claude_new', + ownership: [ownership({ provider: 'codex' })] + }) + ).toBeNull() + }) + + it('finds nothing when no session holds the conversation', () => { + expect( + findConflictingStructuredAdoption({ + agent: 'codex', + providerSessionId: 'thread-unheld', + selfSessionId: 'codex_new', + ownership: [ownership()] + }) + ).toBeNull() + }) +}) + +describe('findCommittedStructuredAgentSessionAdoptionReplay', () => { + it('returns the record-pinned account and adopted handle for the exact committed operation', () => { + expect(committedReplay()).toMatchObject({ + record: { accountHome: { path: '/home/dev/.codex-original' } }, + providerHandle: { kind: 'codex', threadId: 'thread-1' } + }) + }) + + it('does not cross caller or operation namespaces', () => { + expect(committedReplay({ callerKey: 'client-2' })).toBeNull() + expect(committedReplay({ operationId: `${OPERATION}-other` })).toBeNull() + }) + + it('preserves the adopted Claude leaf that participated in the attach fingerprint', () => { + const lease = agentSessionLeaseFixture({ sessionId: 'claude_adopted' }) + const record = agentSessionRecordFixture(lease) + record.providerHandleChain[0] = { + ...record.providerHandleChain[0]!, + origin: 'adopted', + handle: { + provider: 'claude', + sessionId: 'provider-session-alpha-1', + leafUuid: 'leaf-1' + } + } + + expect( + findCommittedStructuredAgentSessionAdoptionReplay({ + agent: 'claude', + providerSessionId: 'provider-session-alpha-1', + selfSessionId: 'claude_adopted', + callerKey: 'client-1', + operationId: OPERATION, + record, + operations: [ + { + callerKey: 'client-1', + operationId: OPERATION, + fingerprint: 'fingerprint-1', + operationTimestamp: 1_800_000_000_000, + recordedAt: 1_800_000_000_000, + expiresAt: 1_900_000_000_000, + outcome: { status: 'succeeded', sessionId: 'claude_adopted' } + } + ] + }) + ).toMatchObject({ + providerHandle: { + kind: 'claude', + sessionId: 'provider-session-alpha-1', + leafUuid: 'leaf-1' + } + }) + }) +}) + +describe('structuredAdoptionConflictError', () => { + it('calls a conversation with an admitted writer a conflict', () => { + expect(structuredAdoptionConflictError(ownership()).message).toBe('agent_session_conflict') + }) + + it.each([ + ['a reservation with no process yet', { ownerProcess: null, claimStatus: 'reserved' as const }], + ['a lease mid-handoff', { handoffStage: 'new-owner-proving' as const }], + ['an unreconciled lease', { unreconciled: true }] + ])('calls %s an unknown owner rather than a conflict', (_label, leaseOverrides) => { + // Neither verdict admits a second writer; they differ only in what the user is told. + expect( + structuredAdoptionConflictError( + ownership({ lease: agentSessionLeaseFixture(leaseOverrides) }) + ).message + ).toBe('agent_session_ownership_unknown') + }) +}) + +describe('resolveStructuredAgentSessionAdoption', () => { + it('takes the first candidate home that holds the transcript and probes no further', async () => { + const resolveTranscript = vi + .fn() + .mockResolvedValueOnce(null) + .mockResolvedValueOnce('/home/dev/.codex/sessions/thread-1.jsonl') + + await expect( + resolveStructuredAgentSessionAdoption({ + agent: 'codex', + providerSessionId: 'thread-1', + candidateAccountHomes: ['/home/dev/.orca-codex', '/home/dev/.codex', '/never/probed'], + resolveTranscript + }) + ).resolves.toEqual({ + accountHomePath: '/home/dev/.codex', + transcriptPath: '/home/dev/.codex/sessions/thread-1.jsonl' + }) + expect(resolveTranscript).toHaveBeenCalledTimes(2) + }) + + it('skips blank and repeated candidates instead of probing them again', async () => { + const resolveTranscript = vi.fn().mockResolvedValue(null) + + await expect( + resolveStructuredAgentSessionAdoption({ + agent: 'claude', + providerSessionId: 'session-1', + candidateAccountHomes: ['', ' ', '/home/dev/.claude', ' /home/dev/.claude ', ''], + resolveTranscript + }) + ).rejects.toThrow('agent_session_identity_required') + expect(resolveTranscript.mock.calls.map(([args]) => args.accountHomePath)).toEqual([ + '/home/dev/.claude' + ]) + }) + + it('refuses rather than falling back to a home that does not hold the conversation', async () => { + // A resume under the wrong home lands in a blank chat wearing the old chat's name. + await expect( + resolveStructuredAgentSessionAdoption({ + agent: 'claude', + providerSessionId: 'session-1', + candidateAccountHomes: ['/home/dev/.claude-work', '/home/dev/.claude'], + resolveTranscript: async () => null + }) + ).rejects.toThrow('agent_session_identity_required') + }) +}) diff --git a/src/main/native-chat/structured-agent-session-history-adoption.ts b/src/main/native-chat/structured-agent-session-history-adoption.ts new file mode 100644 index 00000000000..d470735b032 --- /dev/null +++ b/src/main/native-chat/structured-agent-session-history-adoption.ts @@ -0,0 +1,156 @@ +// Adopting an Agent Session History row into a brand-new structured chat. +// +// Kept out of the runtime class files because those are `@ts-nocheck`: this decides which +// credential directory a provider child will launch against and which file gets imported into a +// journal, and a call site written there would compile however wrong it was. The runtime hands over +// the facts it owns — the account homes it recognises, the records it holds — and this decides. + +import type { AgentSessionOperationRow } from '../../shared/agent-session-operation-ledger' +import type { AgentSessionProviderHandle } from '../../shared/agent-session-journal-types' +import type { AgentSessionLease, AgentSessionRecord } from '../../shared/agent-session-record' +import { agentSessionLeaseAdmitsWriter } from '../../shared/agent-session-lease-adjudication' + +export type StructuredAgentSessionAdoptionOwnership = { + sessionId: string + provider: 'claude' | 'codex' + providerSessionId: string + lease: AgentSessionLease +} + +export type StructuredAgentSessionAdoption = { + /** The account home the transcript was actually found under — never a client-supplied path. */ + accountHomePath: string + transcriptPath: string +} + +export type CommittedStructuredAgentSessionAdoptionReplay = { + record: AgentSessionRecord + providerHandle: Exclude +} + +/** Exact committed-operation identity; attach still validates its fingerprint. */ +export function findCommittedStructuredAgentSessionAdoptionReplay(input: { + agent: 'claude' | 'codex' + providerSessionId: string + selfSessionId: string + callerKey: string + operationId: string + record: AgentSessionRecord | null + operations: readonly AgentSessionOperationRow[] +}): CommittedStructuredAgentSessionAdoptionReplay | null { + const operation = input.operations.find( + (row) => row.callerKey === input.callerKey && row.operationId === input.operationId + ) + if ( + operation?.outcome.status !== 'succeeded' || + operation.outcome.sessionId !== input.selfSessionId + ) { + return null + } + const record = input.record + const adopted = record?.providerHandleChain[0] + if ( + !record || + record.sessionId !== input.selfSessionId || + record.provider !== input.agent || + adopted?.origin !== 'adopted' + ) { + return null + } + const providerSessionId = + adopted.handle.provider === 'codex' ? adopted.handle.threadId : adopted.handle.sessionId + if (providerSessionId !== input.providerSessionId) { + return null + } + return { + record, + providerHandle: + adopted.handle.provider === 'codex' + ? { kind: 'codex', threadId: adopted.handle.threadId } + : { + kind: 'claude', + sessionId: adopted.handle.sessionId, + leafUuid: adopted.handle.leafUuid + } + } +} + +/** + * A conversation has exactly one writer. Codex takes no lock of its own: a second app-server holding + * the same thread never errors, it loads history once and then diverges, and the rollout ends up + * recording a conversation that never happened. So the refusal is the correctness guard, and it has + * to be able to tell "someone else owns this" from "this very operation owns it". + * + * @param selfSessionId the structured session this create is reserving. A retry of a committed + * create re-runs every pre-commit check, and by then the record it created is itself in the + * ownership index — without this exemption the replay refuses instead of replaying. + */ +export function findConflictingStructuredAdoption(input: { + agent: 'claude' | 'codex' + providerSessionId: string + selfSessionId: string + ownership: readonly StructuredAgentSessionAdoptionOwnership[] +}): StructuredAgentSessionAdoptionOwnership | null { + return ( + input.ownership.find( + (owner) => + owner.sessionId !== input.selfSessionId && + owner.provider === input.agent && + owner.providerSessionId === input.providerSessionId + ) ?? null + ) +} + +/** Mirrors the legacy PTY resume's refusal vocabulary: a conversation with an admitted writer is a + * conflict, one without is an unknown owner. Neither ever admits a second writer. */ +export function structuredAdoptionConflictError( + ownership: StructuredAgentSessionAdoptionOwnership +): Error { + return new Error( + agentSessionLeaseAdmitsWriter(ownership.lease) + ? 'agent_session_conflict' + : 'agent_session_ownership_unknown' + ) +} + +/** + * Resolve which recognised account home holds this conversation, by finding its transcript. + * + * The client names only the conversation. Everything else is derived here: `agentSession.create` is + * reachable by paired mobile clients, so a client-supplied account home would choose the credential + * directory the provider child launches against, and a client-supplied transcript path would choose + * which file this host reads into a journal. + * + * Candidates are tried in order and the FIRST hit wins, so the caller must order them by preference + * (selected account before the system default). + */ +export async function resolveStructuredAgentSessionAdoption(input: { + agent: 'claude' | 'codex' + providerSessionId: string + candidateAccountHomes: readonly string[] + resolveTranscript: (args: { + agent: 'claude' | 'codex' + providerSessionId: string + accountHomePath: string + }) => Promise +}): Promise { + const seen = new Set() + for (const accountHomePath of input.candidateAccountHomes) { + const trimmed = accountHomePath.trim() + if (!trimmed || seen.has(trimmed)) { + continue + } + seen.add(trimmed) + const transcriptPath = await input.resolveTranscript({ + agent: input.agent, + providerSessionId: input.providerSessionId, + accountHomePath: trimmed + }) + if (transcriptPath) { + return { accountHomePath: trimmed, transcriptPath } + } + } + // Refuse rather than fall back to the default home. Resuming under a home that does not hold the + // conversation is how a "resume" silently becomes a blank chat wearing the old chat's name. + throw new Error('agent_session_identity_required') +} diff --git a/src/main/runtime/agent-session-reservation-admission.test.ts b/src/main/runtime/agent-session-reservation-admission.test.ts new file mode 100644 index 00000000000..80bcb77cfa5 --- /dev/null +++ b/src/main/runtime/agent-session-reservation-admission.test.ts @@ -0,0 +1,199 @@ +// Adoption admission inside the reservation transaction: which conversation a new record may claim. + +import { describe, expect, it } from 'vitest' +import { + agentSessionLeaseFixture, + agentSessionRecordFixture +} from '../../shared/agent-session-record.test-fixture' +import type { + AgentSessionExecutionLocation, + AgentSessionRecord +} from '../../shared/agent-session-record' +import type { AgentSessionOwnerProbe } from '../../shared/agent-session-lease-adjudication' +import type { AgentSessionProviderHandleLink } from '../../shared/agent-session-provider-handle' +import { + applyAgentSessionReservation, + type AgentSessionReserveRequest +} from './agent-session-reservation-admission' +import type { AgentSessionStoreState } from './agent-session-record-store-file' + +const NOW = 1_800_000_000_000 +const LEASE_TTL_MS = 60_000 + +const LOCATION: AgentSessionExecutionLocation = { + executionHostId: 'local', + wslDistro: null, + workspaceId: 'workspace-1', + workspaceKind: 'git-worktree' +} +const INDETERMINATE: AgentSessionOwnerProbe = { outcome: 'indeterminate', reason: 'no answer' } + +/** The link an adopting create seeds: fence 1, because that is a new record's first. */ +function adoptedLink( + overrides: Partial = {} +): AgentSessionProviderHandleLink { + return { + linkId: 'claude-1-provider-session-alpha-1-empty', + handle: { provider: 'claude', sessionId: 'provider-session-alpha-1', leafUuid: null }, + origin: 'adopted', + mintedAtFence: 1, + observedAt: NOW, + ...overrides + } +} + +function reserveRequest( + overrides: Partial = {} +): AgentSessionReserveRequest { + return { + sessionId: 'session-adopting', + location: LOCATION, + provider: 'claude', + accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: '/home/dev/.claude' }, + runtimeKind: 'native', + expectedFence: null, + spawnToken: 'spawn-a', + claimKeyId: 'key-1', + handoffOperationId: null, + probe: INDETERMINATE, + operation: { callerKey: 'client-1', operationId: 'op-1', fingerprint: 'fp-1' }, + now: NOW, + ...overrides + } +} + +function storeState(records: readonly AgentSessionRecord[] = []): AgentSessionStoreState { + return { + schemaVersion: 2, + hostId: 'local', + records: new Map(records.map((record) => [record.sessionId, record])), + operations: new Map(), + retiredClaimKeys: [], + unreadableRecords: new Map(), + visibleSessionIds: new Set(), + visibleSessionIdsIndexPresent: true + } +} + +describe('adopted handle chain seeding', () => { + it('seeds a new record with the adopted link alone, at the first fence of the record', () => { + const link = adoptedLink() + const { record, disposition } = applyAgentSessionReservation( + storeState(), + reserveRequest({ adoptedHandleLink: link }), + LEASE_TTL_MS + ) + + expect(disposition).toBe('created') + expect(record.providerHandleChain).toEqual([link]) + // The owner probe requires the head link to carry the record's current fence. + expect(record.providerHandleChain[0]?.mintedAtFence).toBe(record.lease.runtimeFence) + }) + + it('leaves a blank create with no chain, so the adapter starts a conversation', () => { + const { record } = applyAgentSessionReservation(storeState(), reserveRequest(), LEASE_TTL_MS) + + expect(record.providerHandleChain).toEqual([]) + }) +}) + +describe('adopted conversation ownership', () => { + it('refuses when another record already holds the same conversation root', () => { + // The held link names a leaf; the adoption names none. Same root is the whole test: keying on + // the exact handle would let two writers onto one conversation on different branches. + const holder = agentSessionRecordFixture() + + expect(() => + applyAgentSessionReservation( + storeState([holder]), + reserveRequest({ adoptedHandleLink: adoptedLink() }), + LEASE_TTL_MS + ) + ).toThrow('agent_session_conflict') + }) + + it('admits an adoption of a conversation no record holds', () => { + const holder = agentSessionRecordFixture() + + expect(() => + applyAgentSessionReservation( + storeState([holder]), + reserveRequest({ + adoptedHandleLink: adoptedLink({ + handle: { provider: 'claude', sessionId: 'provider-session-other', leafUuid: null } + }) + }), + LEASE_TTL_MS + ) + ).not.toThrow() + }) + + it('exempts the requesting session so a committed create can be re-run', () => { + // Pins the guard's own contract. No wire shape reaches it today: `adopt` is accepted only on + // create-by-intent, which always carries a null expected fence, and an existing record with a + // null expected fence is refused a few lines below anyway. + const link = adoptedLink() + const committed: AgentSessionRecord = { + ...agentSessionRecordFixture( + agentSessionLeaseFixture({ + sessionId: 'session-adopting', + runtimeFence: 1, + handoffStage: 'new-owner-proving', + claimStatus: 'reserved', + ownerProcess: null, + provenHandleLinkId: null, + handoffOperationId: 'handoff-1' + }) + ), + location: LOCATION, + accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: '/home/dev/.claude' }, + providerHandleChain: [link] + } + + const { record, disposition } = applyAgentSessionReservation( + storeState([committed]), + reserveRequest({ + adoptedHandleLink: link, + expectedFence: 1, + handoffOperationId: 'handoff-1' + }), + LEASE_TTL_MS + ) + + expect(disposition).toBe('retry-reservation') + expect(record.providerHandleChain).toEqual([link]) + }) + + it('refuses a Codex adoption another record already holds', () => { + const holder: AgentSessionRecord = { + ...agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId: 'session-codex' })), + provider: 'codex', + accountHome: { variable: 'CODEX_HOME', path: '/home/dev/.codex' }, + providerHandleChain: [ + { + linkId: 'codex-1-thread-1', + handle: { provider: 'codex', threadId: 'thread-1' }, + origin: 'created', + mintedAtFence: 7, + observedAt: NOW + } + ] + } + + expect(() => + applyAgentSessionReservation( + storeState([holder]), + reserveRequest({ + sessionId: 'session-codex-adopting', + provider: 'codex', + accountHome: { variable: 'CODEX_HOME', path: '/home/dev/.codex' }, + adoptedHandleLink: adoptedLink({ + linkId: 'codex-1-thread-1-adopted', + handle: { provider: 'codex', threadId: 'thread-1' } + }) + }), + LEASE_TTL_MS + ) + ).toThrow('agent_session_conflict') + }) +}) diff --git a/src/main/runtime/agent-session-reservation-admission.ts b/src/main/runtime/agent-session-reservation-admission.ts index f1be94a2c0e..82176a05297 100644 --- a/src/main/runtime/agent-session-reservation-admission.ts +++ b/src/main/runtime/agent-session-reservation-admission.ts @@ -28,7 +28,11 @@ import { type AgentSessionLaunchEnv, type AgentSessionRecord } from '../../shared/agent-session-record' -import type { AgentSessionHandleProvider } from '../../shared/agent-session-provider-handle' +import { + agentSessionProviderHandleRoot, + type AgentSessionHandleProvider, + type AgentSessionProviderHandleLink +} from '../../shared/agent-session-provider-handle' import { reserveAgentSessionOwner, type AgentSessionReservation @@ -46,6 +50,9 @@ export type AgentSessionReserveRequest = { launchEnv?: AgentSessionLaunchEnv /** Initial provider options persisted before the first process is acquired. */ options?: Readonly> + /** Set only when this create adopts an existing provider conversation. Seeds the handle chain so + * the adapter resumes; without it a new record has never proved a thread and starts a fresh one. */ + adoptedHandleLink?: AgentSessionProviderHandleLink runtimeKind: AgentSessionReservation['runtimeKind'] /** Null when the session does not exist yet; otherwise the fence the caller last observed. */ expectedFence: number | null @@ -146,6 +153,11 @@ export function applyAgentSessionReservation( leaseTtlMs: request.leaseTtlMs ?? leaseTtlMs, now: request.now } + // Inside the transaction, not only in the RPC resolver: two concurrent adoptions of one + // conversation mint different session ids, so the compare-and-swap never collides and a + // pre-commit check passes for both. Codex would then hold one thread from two app-servers, which + // it permits silently and which corrupts the conversation rather than erroring. + assertAdoptedConversationUnowned(state, request) const existing = state.records.get(request.sessionId) if (!existing) { if (state.unreadableRecords.has(request.sessionId)) { @@ -181,6 +193,41 @@ export function applyAgentSessionReservation( }) } +/** + * Refuse an adoption whose conversation ANOTHER record already holds. + * + * The self-exemption is part of that definition, not a replay mechanism: replay is settled earlier + * by the operation ledger, and an adoption always arrives with a null expected fence, so a request + * naming an existing session id is refused a few lines below regardless. Keeping the scan scoped to + * other records is what makes this guard mean what its name says. + * + * It runs inside the store transaction because the pre-commit check in the RPC resolver cannot be + * the guard: two concurrent adoptions of one conversation mint different session ids, so the + * compare-and-swap never collides and both would pass. Codex permits two app-servers on one thread + * silently, so the cost of missing this is a corrupted conversation rather than an error. + */ +function assertAdoptedConversationUnowned( + state: AgentSessionStoreState, + request: AgentSessionReserveRequest +): void { + const adopted = request.adoptedHandleLink + if (!adopted) { + return + } + const root = agentSessionProviderHandleRoot(adopted.handle) + for (const record of state.records.values()) { + if (record.sessionId === request.sessionId) { + continue + } + const holdsSameConversation = record.providerHandleChain.some( + (link) => agentSessionProviderHandleRoot(link.handle) === root + ) + if (holdsSameConversation) { + throw new Error('agent_session_conflict') + } + } +} + function createAgentSessionRecord( request: AgentSessionReserveRequest, reservation: AgentSessionReservation @@ -190,7 +237,9 @@ function createAgentSessionRecord( sessionId: request.sessionId, location: request.location, provider: request.provider, - providerHandleChain: [], + // Fence 1 below is this record's first, and the owner probe requires the head link to carry the + // record's current fence — so an adopted link must be minted at that same fence. + providerHandleChain: request.adoptedHandleLink ? [request.adoptedHandleLink] : [], accountHome: request.accountHome, ...(request.options ? { options: { ...request.options } } : {}), ...(request.launchArgs ? { launchArgs: [...request.launchArgs] } : {}), diff --git a/src/main/runtime/orca-runtime-resolve-recovered-structured-tui-transcript.ts b/src/main/runtime/orca-runtime-resolve-recovered-structured-tui-transcript.ts index 497d5b381e7..37752d207e6 100644 --- a/src/main/runtime/orca-runtime-resolve-recovered-structured-tui-transcript.ts +++ b/src/main/runtime/orca-runtime-resolve-recovered-structured-tui-transcript.ts @@ -7,6 +7,10 @@ import { supportsCodexStructuredLocation } from '../codex/codex-structured-locat import { supportsClaudeStructuredLocation } from '../claude/claude-structured-location-support' import { getStructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-registry' import { resolveStructuredAgentSessionCreateSupport } from '../native-chat/structured-agent-session-create-support' +import { + resolveCommittedStructuredAgentSessionAdoptionIntent, + resolveStructuredAgentSessionAdoptionForCreate +} from './structured-agent-session-create-adoption' import { LOCAL_EXECUTION_HOST_ID } from '../../shared/execution-host' import type { AgentStatusIpcPayload } from '../../shared/agent-status-types' import { getLocalProjectWorktreeGitOptions } from '../project-runtime-git-options' @@ -111,6 +115,8 @@ export class OrcaRuntimeWithResolveRecoveredStructuredTuiTranscript extends Orca envelope: { sessionId: string; clientOperationId: string } worktree: string agent: 'claude' | 'codex' + callerKey?: string + resumeFrom?: { providerSessionId: string } }): Promise { if (input.agent === 'claude') { return this.resolveStructuredAgentSessionIntent(input, async ({ launchEnv, location }) => { @@ -144,6 +150,8 @@ export class OrcaRuntimeWithResolveRecoveredStructuredTuiTranscript extends Orca envelope: { sessionId: string; clientOperationId: string } worktree: string agent: 'claude' | 'codex' + callerKey?: string + resumeFrom?: { providerSessionId: string } }, resolveAccountHomePath: (context: { workspacePath: string @@ -168,6 +176,35 @@ export class OrcaRuntimeWithResolveRecoveredStructuredTuiTranscript extends Orca ) const location = await this.resolveStructuredAgentSessionLocation(input.worktree) const workspacePath = (await this.resolveRuntimeFileTarget(input.worktree)).worktree.path + const host = getStructuredAgentSessionHost() + const committedReplay = resolveCommittedStructuredAgentSessionAdoptionIntent({ + host, + ...input, + location, + ...(options ? { options } : {}) + }) + if (committedReplay) { + return committedReplay + } + const selectedAccountHomePath = await resolveAccountHomePath({ + workspacePath, + launchEnv, + location + }) + // Adopting pins the account home to wherever the conversation actually lives, which is not + // necessarily the one a fresh create would pick: Codex resolves its rollout under + // `accountHome.path`, and Claude reads its transcript under `/projects`. Resuming under + // the wrong home finds nothing and lands the user in a blank chat wearing the old chat's name. + const adoption = input.resumeFrom + ? await resolveStructuredAgentSessionAdoptionForCreate({ + host, + settings, + agent: input.agent, + providerSessionId: input.resumeFrom.providerSessionId, + selfSessionId: input.envelope.sessionId, + selectedAccountHomePath + }) + : null return { envelope: { sessionId: input.envelope.sessionId, @@ -180,9 +217,27 @@ export class OrcaRuntimeWithResolveRecoveredStructuredTuiTranscript extends Orca agent: input.agent, accountHome: { variable: input.agent === 'claude' ? 'CLAUDE_CONFIG_DIR' : 'CODEX_HOME', - path: await resolveAccountHomePath({ workspacePath, launchEnv, location }) + path: adoption ? adoption.accountHomePath : selectedAccountHomePath }, ...(options ? { options } : {}), + ...(input.resumeFrom && adoption + ? { + // `adopt` is what makes the reservation seed the handle chain. Presence of + // `providerHandle` alone must not: `agentSession.ensure` already passes one today + // without adopting anything. + adopt: { + providerHandle: + input.agent === 'claude' + ? { + kind: 'claude' as const, + sessionId: input.resumeFrom.providerSessionId, + leafUuid: null + } + : { kind: 'codex' as const, threadId: input.resumeFrom.providerSessionId }, + transcriptPath: adoption.transcriptPath + } + } + : {}), runtimeKind: 'native' } } diff --git a/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts new file mode 100644 index 00000000000..42fdbc772a0 --- /dev/null +++ b/src/main/runtime/rpc/methods/structured-agent-session-adoption-replay.test.ts @@ -0,0 +1,235 @@ +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { computeAgentSessionPayloadFingerprint } from '../../../../shared/agent-session-mutation-envelope' +import { STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version' +import { AgentSessionRecordStore } from '../../agent-session-record-store' +import type { StructuredAgentSessionAdapter } from '../../../native-chat/agent-session-wire/structured-agent-session-adapter' +import { StructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/structured-agent-session-host' +import { setStructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/structured-agent-session-registry' +import { OrcaRuntimeService } from '../../orca-runtime' +import type { RpcRequest, RpcResponse } from '../core' +import { RpcDispatcher } from '../dispatcher' +import { STRUCTURED_AGENT_SESSION_METHODS } from './structured-agent-session' + +const SESSION = 'session-adoption-replay' +const THREAD = 'thread-adoption-replay' +const WORKSPACE = 'workspace-1' +const OPERATION = `${Date.now()}-00000000000000000000000000000001` +const CLIENT = { + clientId: 'device-a', + clientKind: 'runtime' as const, + clientCapabilities: [STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY] +} + +let root: string +let host: StructuredAgentSessionHost + +function adapter(): StructuredAgentSessionAdapter { + return { + supportsCreate: () => true, + acquire: vi + .fn() + .mockImplementation(async ({ fence, spawnToken }) => ({ + process: { + hostId: 'local', + pid: 4242, + processStartTimeMs: 1_800_000_000_000, + spawnToken + }, + link: { + linkId: `codex-${fence}-${THREAD}`, + handle: { provider: 'codex', threadId: THREAD }, + origin: 'resumed', + mintedAtFence: fence, + observedAt: 1_800_000_000_000 + } + })), + releaseAcquisition: vi.fn(async () => true), + dispatch: vi.fn(), + cancelTurn: vi.fn(), + answerPrompt: vi.fn(), + setOption: vi.fn() + } +} + +function createParams(operationId = OPERATION) { + const fields = { + worktree: `id:${WORKSPACE}`, + agent: 'codex' as const, + resumeFrom: { providerSessionId: THREAD } + } + return { + envelope: { + sessionId: SESSION, + clientOperationId: operationId, + expectedRuntimeFence: null, + payloadFingerprint: computeAgentSessionPayloadFingerprint({ + method: 'agentSession.create', + sessionId: SESSION, + fields + }) + }, + ...fields + } +} + +async function call(dispatcher: RpcDispatcher, params: unknown, client = CLIENT) { + const replies: RpcResponse[] = [] + const request: RpcRequest = { + id: `request-${replies.length + 1}`, + authToken: 'token', + method: 'agentSession.create', + params + } + await dispatcher.dispatchStreaming( + request, + (raw) => replies.push(JSON.parse(raw) as RpcResponse), + client + ) + return replies[0] +} + +beforeEach(async () => { + root = await mkdtemp(join(tmpdir(), 'orca-adoption-rpc-replay-')) +}) + +afterEach(async () => { + setStructuredAgentSessionHost(null) + await host?.flushAllStreamedEvents() + await host?.close(SESSION) + await rm(root, { recursive: true, force: true }) + vi.restoreAllMocks() +}) + +describe('committed adopting create RPC replay', () => { + it('republishes from durable identity after the source disappears and account selection drifts', async () => { + const originalHome = join(root, 'account-original') + const driftedHome = join(root, 'account-drifted') + const transcriptPath = join( + originalHome, + 'sessions', + '2026', + '09', + '06', + `rollout-2026-09-06T18-00-00-${THREAD}.jsonl` + ) + await mkdir(dirname(transcriptPath), { recursive: true }) + await writeFile( + transcriptPath, + `${JSON.stringify({ + type: 'session_meta', + payload: { id: THREAD, timestamp: '2026-09-06T18:00:00.000Z', cwd: '/workspace' } + })}\n${JSON.stringify({ + type: 'response_item', + timestamp: '2026-09-06T18:00:01.000Z', + payload: { type: 'message', role: 'user', content: 'durable adopted history' } + })}\n`, + 'utf8' + ) + + let selectedHome = originalHome + const selectAccountHome = vi.fn(() => selectedHome) + const runtime = new OrcaRuntimeService( + { + getSettings: () => ({ agentDefaultEnv: { codex: {} } }) + } as never, + undefined, + { prepareCodexStructuredLaunch: selectAccountHome } + ) + vi.spyOn(runtime, 'getStructuredAgentSessionCreateSupport').mockResolvedValue({ + supported: true + }) + const internal = runtime as unknown as { + resolveStructuredAgentSessionLocation: () => Promise<{ + executionHostId: 'local' + wslDistro: null + workspaceId: string + workspaceKind: 'git-worktree' + }> + resolveRuntimeFileTarget: () => Promise<{ worktree: { path: string } }> + ensureStructuredAgentSessionHost: () => Promise + publishStructuredAgentSessionTab: () => Promise + } + internal.resolveStructuredAgentSessionLocation = vi.fn(async () => ({ + executionHostId: 'local' as const, + wslDistro: null, + workspaceId: WORKSPACE, + workspaceKind: 'git-worktree' as const + })) + internal.resolveRuntimeFileTarget = vi.fn(async () => ({ + worktree: { path: '/repos/workspace-1' } + })) + internal.ensureStructuredAgentSessionHost = vi.fn(async () => undefined) + internal.publishStructuredAgentSessionTab = vi + .fn<() => Promise>() + .mockRejectedValueOnce(new Error('simulated lost tab publication')) + .mockResolvedValue(undefined) + + const store = await AgentSessionRecordStore.open({ + directory: join(root, 'store'), + hostId: 'local' + }) + const sessionAdapter = adapter() + host = new StructuredAgentSessionHost({ + store, + adapter: sessionAdapter, + journalRoot: root, + claimKeyId: 'key-1' + }) + setStructuredAgentSessionHost(host) + const dispatcher = new RpcDispatcher({ + runtime, + methods: STRUCTURED_AGENT_SESSION_METHODS + }) + const params = createParams() + + expect(await call(dispatcher, params)).toMatchObject({ + ok: true, + result: { ok: false, refusal: { code: 'agent_session_operation_unknown' } } + }) + await rm(transcriptPath) + selectedHome = driftedHome + setStructuredAgentSessionHost(null) + internal.ensureStructuredAgentSessionHost = vi.fn(async () => { + setStructuredAgentSessionHost(host) + }) + + expect(await call(dispatcher, params)).toMatchObject({ + ok: true, + result: { + ok: true, + replayed: true, + value: { + page: { + items: expect.arrayContaining([ + expect.objectContaining({ + body: expect.objectContaining({ + blocks: expect.arrayContaining([ + expect.objectContaining({ text: 'durable adopted history' }) + ]) + }) + }) + ]) + } + } + } + }) + expect(sessionAdapter.acquire).toHaveBeenCalledTimes(1) + expect(internal.publishStructuredAgentSessionTab).toHaveBeenCalledTimes(2) + expect(selectAccountHome).toHaveBeenCalledTimes(1) + + const otherOperation = createParams(`${Date.now()}-00000000000000000000000000000002`) + expect(await call(dispatcher, otherOperation)).toMatchObject({ + ok: true, + result: { ok: false, refusal: { code: 'agent_session_identity_required' } } + }) + expect(await call(dispatcher, params, { ...CLIENT, clientId: 'device-b' })).toMatchObject({ + ok: true, + result: { ok: false, refusal: { code: 'agent_session_identity_required' } } + }) + expect(sessionAdapter.acquire).toHaveBeenCalledTimes(1) + expect(internal.publishStructuredAgentSessionTab).toHaveBeenCalledTimes(2) + }) +}) diff --git a/src/main/runtime/rpc/methods/structured-agent-session-create.ts b/src/main/runtime/rpc/methods/structured-agent-session-create.ts index 75a13ba6af9..b0ce4666861 100644 --- a/src/main/runtime/rpc/methods/structured-agent-session-create.ts +++ b/src/main/runtime/rpc/methods/structured-agent-session-create.ts @@ -24,6 +24,7 @@ import { } from '../../../native-chat/agent-session-wire/structured-agent-session-attach' import type { StructuredAgentSessionHost } from '../../../native-chat/agent-session-wire/structured-agent-session-host' import type { StructuredAgentSessionCaller } from '../../../native-chat/agent-session-wire/structured-agent-session-host-types' +import type { StructuredAgentSessionResumeSource } from '../../../../shared/structured-agent-session-create' import type { OrcaRuntimeService } from '../../orca-runtime' import { resolveUncommittedStructuredCreate, @@ -46,18 +47,24 @@ export async function prepareStructuredAgentSessionCreateForWorktree(args: { envelope: AgentSessionMutationEnvelope worktree: string agent: 'claude' | 'codex' + caller: StructuredAgentSessionCaller + resumeFrom?: StructuredAgentSessionResumeSource }): Promise { + // Adoption replay may need the record loaded from disk before source discovery can be skipped. + let host = args.resumeFrom ? await args.ensureHost() : null const resolved = await args.runtime.resolveStructuredAgentSessionCreateIntent({ envelope: args.envelope, worktree: args.worktree, - agent: args.agent + agent: args.agent, + callerKey: args.caller.callerKey, + ...(args.resumeFrom ? { resumeFrom: args.resumeFrom } : {}) }) const hostFingerprint = computeAgentSessionPayloadFingerprint({ method: 'agentSession.attach', sessionId: args.envelope.sessionId, fields: attachFingerprintFields({ ...resolved, envelope: args.envelope }) }) - const host = await args.ensureHost() + host ??= await args.ensureHost() const { agent: _resolvedAgent, provider: _resolvedProvider, ...resolvedAttach } = resolved return { host, diff --git a/src/main/runtime/rpc/methods/structured-agent-session-schemas.ts b/src/main/runtime/rpc/methods/structured-agent-session-schemas.ts index 05a066ab184..5ec7a31d80d 100644 --- a/src/main/runtime/rpc/methods/structured-agent-session-schemas.ts +++ b/src/main/runtime/rpc/methods/structured-agent-session-schemas.ts @@ -96,11 +96,21 @@ export const AttachParams = z }) .strict() +/** An identity, and nothing the host would otherwise read off disk. A transcript path or account + * home here would let a client choose which file this host imports and which credential directory + * the provider child launches against; both are derived host-side from this id instead. */ +const ResumeSource = z + .object({ + providerSessionId: Identifier('Invalid provider session id') + }) + .strict() + export const CreateIntentParams = z .object({ envelope: MutationEnvelope, worktree: Identifier('Invalid worktree selector'), - agent: z.enum(['claude', 'codex']) + agent: z.enum(['claude', 'codex']), + resumeFrom: ResumeSource.optional() }) .strict() diff --git a/src/main/runtime/rpc/methods/structured-agent-session.test.ts b/src/main/runtime/rpc/methods/structured-agent-session.test.ts index 82f4cf9041f..5a38ae4ce2d 100644 --- a/src/main/runtime/rpc/methods/structured-agent-session.test.ts +++ b/src/main/runtime/rpc/methods/structured-agent-session.test.ts @@ -483,7 +483,10 @@ describe('method routing', () => { } const created = await call('agentSession.create', params, STRUCTURED_CLIENT) expect(created).toMatchObject({ ok: true, result: { ok: true } }) - expect(runtimeCalls.resolveStructuredAgentSessionCreateIntent).toHaveBeenCalledWith(params) + expect(runtimeCalls.resolveStructuredAgentSessionCreateIntent).toHaveBeenCalledWith({ + ...params, + callerKey: 'trusted-local:runtime' + }) expect(hostCalls.attach).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ @@ -497,6 +500,36 @@ describe('method routing', () => { ) }) + it.each(['claude', 'codex'])( + 'forwards a %s history resume through create preparation', + async (agent) => { + const fields = { + worktree: 'id:workspace-1', + agent, + resumeFrom: { providerSessionId: 'prior-session' } + } + const params = { + envelope: envelope({ + expectedRuntimeFence: null, + payloadFingerprint: computeAgentSessionPayloadFingerprint({ + method: 'agentSession.create', + sessionId: SESSION, + fields + }) + }), + ...fields + } + expect(await call('agentSession.create', params, STRUCTURED_CLIENT)).toMatchObject({ + ok: true, + result: { ok: true } + }) + expect(runtimeCalls.resolveStructuredAgentSessionCreateIntent).toHaveBeenCalledWith({ + ...params, + callerKey: 'trusted-local:runtime' + }) + } + ) + it('routes Claude create support and create through the provider-aware runtime', async () => { const worktree = 'id:workspace-1' const support = await call( @@ -524,7 +557,10 @@ describe('method routing', () => { } const created = await call('agentSession.create', params, STRUCTURED_CLIENT) expect(created).toMatchObject({ ok: true, result: { ok: true } }) - expect(runtimeCalls.resolveStructuredAgentSessionCreateIntent).toHaveBeenCalledWith(params) + expect(runtimeCalls.resolveStructuredAgentSessionCreateIntent).toHaveBeenCalledWith({ + ...params, + callerKey: 'trusted-local:runtime' + }) expect(hostCalls.attach).toHaveBeenCalledWith( expect.anything(), expect.objectContaining({ diff --git a/src/main/runtime/rpc/methods/structured-agent-session.ts b/src/main/runtime/rpc/methods/structured-agent-session.ts index 60d02006d3a..f086fa7ed66 100644 --- a/src/main/runtime/rpc/methods/structured-agent-session.ts +++ b/src/main/runtime/rpc/methods/structured-agent-session.ts @@ -127,7 +127,14 @@ export const STRUCTURED_AGENT_SESSION_METHODS: RpcAnyMethod[] = [ const intentFingerprint = computeAgentSessionPayloadFingerprint({ method: 'agentSession.create', sessionId: params.envelope.sessionId, - fields: { worktree: params.worktree, agent: params.agent } + // `resumeFrom` is part of the intent, not a detail of it: without it here, a retry of + // "adopt this conversation" would replay as, or conflict with, a blank create. The + // canonicalizer drops `undefined`, so plain creates keep the digest they always had. + fields: { + worktree: params.worktree, + agent: params.agent, + resumeFrom: params.resumeFrom + } }) const conflict = agentSessionFingerprintConflict(params.envelope, intentFingerprint) if (conflict) { @@ -141,7 +148,9 @@ export const STRUCTURED_AGENT_SESSION_METHODS: RpcAnyMethod[] = [ }, envelope: params.envelope, worktree: params.worktree, - agent: params.agent as 'claude' | 'codex' + agent: params.agent as 'claude' | 'codex', + caller: callerFor(ctx), + ...(params.resumeFrom ? { resumeFrom: params.resumeFrom } : {}) }) } const { host, attachParams } = await resolveClientSuppliedAttach(params, ctx) diff --git a/src/main/runtime/structured-agent-session-create-adoption.ts b/src/main/runtime/structured-agent-session-create-adoption.ts new file mode 100644 index 00000000000..8bdac82abbe --- /dev/null +++ b/src/main/runtime/structured-agent-session-create-adoption.ts @@ -0,0 +1,113 @@ +import { homedir } from 'node:os' +import { join } from 'node:path' +import type { AgentSessionExecutionLocation } from '../../shared/agent-session-record' +import { agentSessionExecutionLocationsEqual } from '../../shared/agent-session-record' +import type { AgentSessionAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-attach' +import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host' +import { listStructuredProviderSessionOwnership } from '../native-chat/agent-session-wire/structured-provider-session-ownership' +import { + findCommittedStructuredAgentSessionAdoptionReplay, + findConflictingStructuredAdoption, + resolveStructuredAgentSessionAdoption, + structuredAdoptionConflictError +} from '../native-chat/structured-agent-session-history-adoption' +import { resolveSessionFilePath } from '../native-chat/session-file-resolver' +import { configuredAdditionalCodexHomePaths } from '../ai-vault/cached-session-list' +import { getOrcaManagedCodexHomePath, getSystemCodexHomePath } from '../codex/codex-home-paths' + +type AdoptionSettings = { + codexManagedAccounts?: readonly { managedHomePath: string }[] +} + +export function resolveCommittedStructuredAgentSessionAdoptionIntent(input: { + host: StructuredAgentSessionHost | null + envelope: { sessionId: string; clientOperationId: string } + agent: 'claude' | 'codex' + callerKey?: string + resumeFrom?: { providerSessionId: string } + location: AgentSessionExecutionLocation + options?: Readonly> +}): AgentSessionAttachParams | null { + const replay = + input.resumeFrom && input.callerKey && input.host + ? findCommittedStructuredAgentSessionAdoptionReplay({ + agent: input.agent, + providerSessionId: input.resumeFrom.providerSessionId, + selfSessionId: input.envelope.sessionId, + callerKey: input.callerKey, + operationId: input.envelope.clientOperationId, + record: input.host.deps.store.getRecord(input.envelope.sessionId), + operations: input.host.deps.store.listOperationRows() + }) + : null + if (!replay || !agentSessionExecutionLocationsEqual(replay.record.location, input.location)) { + return null + } + return { + envelope: { + sessionId: input.envelope.sessionId, + clientOperationId: input.envelope.clientOperationId, + expectedRuntimeFence: null, + payloadFingerprint: '' + }, + location: input.location, + provider: input.agent, + agent: input.agent, + accountHome: replay.record.accountHome, + ...(input.options ? { options: input.options } : {}), + adopt: { providerHandle: replay.providerHandle }, + runtimeKind: replay.record.lease.runtimeKind + } +} + +export async function resolveStructuredAgentSessionAdoptionForCreate(input: { + host: StructuredAgentSessionHost | null + settings: AdoptionSettings + agent: 'claude' | 'codex' + providerSessionId: string + selfSessionId: string + selectedAccountHomePath: string +}) { + const conflict = input.host + ? findConflictingStructuredAdoption({ + agent: input.agent, + providerSessionId: input.providerSessionId, + selfSessionId: input.selfSessionId, + ownership: listStructuredProviderSessionOwnership(input.host.deps.store.listRecords()) + }) + : null + if (conflict) { + throw structuredAdoptionConflictError(conflict) + } + return resolveStructuredAgentSessionAdoption({ + agent: input.agent, + providerSessionId: input.providerSessionId, + candidateAccountHomes: structuredAdoptionAccountHomeCandidates(input), + resolveTranscript: async ({ agent, providerSessionId, accountHomePath }) => + resolveSessionFilePath( + agent, + providerSessionId, + agent === 'claude' + ? { claudeProjectsDir: join(accountHomePath, 'projects') } + : { codexSessionsDirs: [join(accountHomePath, 'sessions')] } + ) + }) +} + +/** Recognised adoption homes, most-preferred first. */ +function structuredAdoptionAccountHomeCandidates(input: { + settings: AdoptionSettings + agent: 'claude' | 'codex' + selectedAccountHomePath: string +}): string[] { + if (input.agent === 'claude') { + return [input.selectedAccountHomePath, join(homedir(), '.claude')] + } + return [ + input.selectedAccountHomePath, + ...(input.settings.codexManagedAccounts ?? []).map((account) => account.managedHomePath), + ...configuredAdditionalCodexHomePaths(), + getOrcaManagedCodexHomePath(), + getSystemCodexHomePath() + ] +} diff --git a/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx b/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx index e5a18bc3014..0e0fe1d7a78 100644 --- a/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx +++ b/src/renderer/src/components/right-sidebar/AiVaultPanel.tsx @@ -30,6 +30,8 @@ import { resolveAiVaultSessionResumeState } from './ai-vault-session-resume' import { useAiVaultSessionLaunchActions } from './ai-vault-session-launch-actions' +import type { AiVaultResumeInChatEligibility } from './ai-vault-session-resume-in-chat' +import { resolveAiVaultSessionResumeInChatForWorkspace } from './ai-vault-session-resume-in-chat-workspace' import { useAiVaultSessionWorktreeMap, withAiVaultCurrentWorktreeStatus @@ -287,6 +289,22 @@ export default function AiVaultPanel(): React.JSX.Element { [allWorktrees, effectiveActiveWorktreeId, getSessionWorktreeInfo, repos, resumeTargetState] ) + // Resuming into a chat asks a different question from resuming into a terminal: not "can this + // workspace host a PTY" but "will the provider still find this conversation from the workspace we + // would run it in". The workspace it targets is the session's own when that is open, because + // Claude looks its transcript up under a directory derived from the launch cwd. + const getSessionResumeInChat = useCallback( + (session: AiVaultSession): AiVaultResumeInChatEligibility => + resolveAiVaultSessionResumeInChatForWorkspace({ + session, + resumeState: getSessionResumeState(session), + activeWorkspaceId: effectiveActiveWorktreeId, + targetState: resumeTargetState, + settings + }), + [effectiveActiveWorktreeId, getSessionResumeState, resumeTargetState, settings] + ) + const handleScopeChange = useCallback((nextScope: AiVaultScope) => { preferredScopeRef.current = nextScope userChangedScopeRef.current = nextScope !== DEFAULT_AI_VAULT_SCOPE @@ -366,7 +384,9 @@ export default function AiVaultPanel(): React.JSX.Element { onJumpToOriginalPane={jumpToOriginalPane} onJumpToWorktree={jumpToWorktree} onResume={launchActions.handleResume} + getSessionResumeInChat={getSessionResumeInChat} onContinueInNewSession={launchActions.handleContinueInNewSession} + onResumeInNewChat={launchActions.handleResumeInNewChat} 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 f63aa018f31..00f8da07d35 100644 --- a/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx +++ b/src/renderer/src/components/right-sidebar/AiVaultSessionActionMenuItems.tsx @@ -4,6 +4,7 @@ import { FolderOpen, LocateFixed, MessageSquarePlus, + MessagesSquare, PanelTopOpen, Play, Trash2 @@ -19,6 +20,7 @@ export function SessionActionMenuItems({ resumeLabel, onResume, onContinueInNewSession, + onResumeInNewChat, onJumpToOriginalPane, showJumpToWorktree, onJumpToWorktree, @@ -36,6 +38,7 @@ export function SessionActionMenuItems({ resumeLabel: string onResume: () => void onContinueInNewSession?: () => void + onResumeInNewChat?: () => void onJumpToOriginalPane?: () => void showJumpToWorktree: boolean onJumpToWorktree?: () => void @@ -93,6 +96,15 @@ export function SessionActionMenuItems({ {resumeLabel} + {onResumeInNewChat ? ( + + + {translate( + 'auto.components.right.sidebar.AiVaultSessionRow.resumeInNewChat', + 'Resume in New Chat' + )} + + ) : null} {onContinueInNewSession ? ( diff --git a/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx b/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx index b3907d68323..aa4f2e1430e 100644 --- a/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx +++ b/src/renderer/src/components/right-sidebar/AiVaultSessionDetails.tsx @@ -1,5 +1,12 @@ import type React from 'react' -import { FileJson, FolderGit2, MessageSquare, MessageSquarePlus, Play } from 'lucide-react' +import { + FileJson, + FolderGit2, + MessageSquare, + MessageSquarePlus, + MessagesSquare, + Play +} from 'lucide-react' import { Button } from '@/components/ui/button' import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip' import { cn } from '@/lib/utils' @@ -30,6 +37,7 @@ export function SessionInlineDetails({ onResumeInWorktree, onResumeInNewTab, onContinueInNewSession, + onResumeInNewChat, onOpenLog }: { id: string @@ -43,6 +51,7 @@ export function SessionInlineDetails({ onResumeInWorktree: () => void onResumeInNewTab: () => void onContinueInNewSession?: () => void + onResumeInNewChat?: () => void onOpenLog?: () => void }): React.JSX.Element { // A zero-turn transcript would resume into an empty conversation, so the plain @@ -68,7 +77,11 @@ export function SessionInlineDetails({ event.stopPropagation() }} > - {showResumeInWorktree || showResumeInNewTab || onContinueInNewSession || onOpenLog ? ( + {showResumeInWorktree || + showResumeInNewTab || + onContinueInNewSession || + onResumeInNewChat || + onOpenLog ? (
{showResumeInWorktree ? ( + ) : null} {onContinueInNewSession ? (
) } - -function AiVaultVirtualRow({ - row, - index, - start, - activeStickyHeaderIndex, - measureElement, - collapsedGroups, - expandedSessionIds, - vaultScope, - buildResumeStartup, - getOriginalPaneTarget, - getSessionLiveState, - getWorktreeInfo, - getSessionResumeState, - getSessionResumeActions, - onToggleGroup, - onToggleSessionDetails, - onJumpToOriginalPane, - onJumpToWorktree, - onResume, - onContinueInNewSession, - onCopyResume, - onCopyId, - onCopyPath, - onOpenLog, - onRevealLog, - onOpenCwd, - onRequestDelete -}: { - row: AiVaultListRow | undefined - index: number - start: number - activeStickyHeaderIndex: number | null - measureElement: (node: Element | null) => void - collapsedGroups: ReadonlySet - expandedSessionIds: ReadonlySet - vaultScope: AiVaultScope - buildResumeStartup: (session: AiVaultSession, worktreeId?: string | null) => AiVaultResumeStartup - getOriginalPaneTarget: (session: AiVaultSession) => AiVaultOriginalPaneTarget | null - getSessionLiveState: (session: AiVaultSession) => AgentStatusState | null - getWorktreeInfo: (session: AiVaultSession) => AiVaultSessionWorktreeInfo | null - getSessionResumeState: (session: AiVaultSession) => AiVaultSessionResumeState - getSessionResumeActions: (session: AiVaultSession) => AiVaultSessionResumeActions - onToggleGroup: (key: string) => void - onToggleSessionDetails: (sessionId: string) => void - onJumpToOriginalPane: (session: AiVaultSession) => void - onJumpToWorktree: (worktreeId: string) => void - onResume: (session: AiVaultSession, worktreeId: string) => void - onContinueInNewSession: (session: AiVaultSession, worktreeId: string) => void - onCopyResume: (session: AiVaultSession, worktreeId?: string | null) => void - onCopyId: (session: AiVaultSession) => void - onCopyPath: (session: AiVaultSession) => void - onOpenLog: (session: AiVaultSession) => void - onRevealLog: (session: AiVaultSession) => void - onOpenCwd: (session: AiVaultSession) => void - onRequestDelete: (session: AiVaultSession) => void -}): React.JSX.Element | null { - if (!row) { - return null - } - - const isActiveStickyHeader = row.type === 'group' && activeStickyHeaderIndex === index - const originalPaneTarget = row.type === 'session' ? getOriginalPaneTarget(row.session) : null - const worktreeInfo = row.type === 'session' ? getWorktreeInfo(row.session) : null - // Why: omit the jump affordance when the session already lives in the - // worktree on screen — jumping there is a no-op. - const showJumpToWorktree = !isAiVaultSessionInCurrentWorktree(worktreeInfo) - const worktreeJumpId = - showJumpToWorktree && canJumpToAiVaultSessionWorktree(worktreeInfo) - ? worktreeInfo?.worktreeId - : null - const resumeState = row.type === 'session' ? getSessionResumeState(row.session) : null - const resumeActions = row.type === 'session' ? getSessionResumeActions(row.session) : null - const continuationWorktreeId = - row.type === 'session' && - canContinueAiVaultSessionInNewSession(row.session, resumeState?.worktreeId) - ? resumeState?.worktreeId - : null - // Gate resume on real content: a zero-turn transcript would resume into an - // empty conversation, so it is never offered as normally resumable. - const resumeGating = - row.type === 'session' - ? aiVaultSessionRowResumeGating(row.session, resumeState) - : { resumeDisabled: true, canCopyResumeCommand: false } - const resumeLabel = resumeState ? aiVaultSessionResumeLabel(resumeState) : '' - const canOpenLocalSessionPaths = - row.type === 'session' && canUseLocalAiVaultSessionPathActions(row.session.executionHostId) - // Why: in-Orca View Log additionally withholds synthetic (SQLite/OpenCode) - // identities that have no single file to open, while Reveal/CWD stay on the - // existing local-path gate. - const canOpenLogInOrca = row.type === 'session' && canOpenAiVaultSessionLogInOrca(row.session) - - return ( -
- {row.type === 'group' ? ( - onToggleGroup(row.group.key)} - /> - ) : ( - onToggleSessionDetails(row.session.id)} - onJumpToOriginalPane={ - originalPaneTarget ? () => onJumpToOriginalPane(row.session) : undefined - } - showJumpToWorktree={showJumpToWorktree} - onJumpToWorktree={worktreeJumpId ? () => onJumpToWorktree(worktreeJumpId) : undefined} - onResume={() => { - if (resumeState?.worktreeId) { - onResume(row.session, resumeState.worktreeId) - } - }} - onContinueInNewSession={ - continuationWorktreeId - ? () => onContinueInNewSession(row.session, continuationWorktreeId) - : undefined - } - onResumeInWorktree={() => { - if (resumeActions?.worktree.worktreeId) { - onResume(row.session, resumeActions.worktree.worktreeId) - } - }} - onResumeInNewTab={() => { - if (resumeActions?.newTab.worktreeId) { - onResume(row.session, resumeActions.newTab.worktreeId) - } - }} - onCopyResume={ - resumeGating.canCopyResumeCommand - ? () => onCopyResume(row.session, resumeState?.worktreeId) - : undefined - } - onCopyId={() => onCopyId(row.session)} - onCopyPath={() => onCopyPath(row.session)} - onOpenLog={canOpenLogInOrca ? () => onOpenLog(row.session) : undefined} - onRevealLog={canOpenLocalSessionPaths ? () => onRevealLog(row.session) : undefined} - onOpenCwd={ - canOpenLocalSessionPaths && row.session.cwd ? () => onOpenCwd(row.session) : undefined - } - onRequestDelete={onRequestDelete} - /> - )} -
- ) -} diff --git a/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx new file mode 100644 index 00000000000..1c7192654d7 --- /dev/null +++ b/src/renderer/src/components/right-sidebar/AiVaultVirtualRow.tsx @@ -0,0 +1,212 @@ +import type { AgentStatusState } from '../../../../shared/agent-status-types' +import type { AiVaultScope, AiVaultSession } from '../../../../shared/ai-vault-types' +import type { AiVaultResumeStartup } from '@/lib/ai-vault-resume-command' +import { cn } from '@/lib/utils' +import { VaultGroupHeader } from './AiVaultPanelControls' +import { VaultSessionRow } from './AiVaultSessionRow' +import type { AiVaultSessionGroup } from './ai-vault-session-filters' +import type { AiVaultOriginalPaneTarget } from './ai-vault-original-pane' +import { + aiVaultSessionResumeLabel, + aiVaultSessionRowResumeGating, + type AiVaultSessionResumeActions, + type AiVaultSessionResumeState +} from './ai-vault-session-resume' +import { + canJumpToAiVaultSessionWorktree, + isAiVaultSessionInCurrentWorktree, + type AiVaultSessionWorktreeInfo +} from './ai-vault-session-worktree' +import { + canOpenAiVaultSessionLogInOrca, + canUseLocalAiVaultSessionPathActions +} from './ai-vault-session-path-actions' +import { canContinueAiVaultSessionInNewSession } from './ai-vault-session-continuation' +import type { AiVaultResumeInChatEligibility } from './ai-vault-session-resume-in-chat' + +export type AiVaultListRow = + | { type: 'group'; group: AiVaultSessionGroup } + | { type: 'session'; groupKey: string; session: AiVaultSession } + +export function AiVaultVirtualRow({ + row, + index, + start, + activeStickyHeaderIndex, + measureElement, + collapsedGroups, + expandedSessionIds, + vaultScope, + buildResumeStartup, + getOriginalPaneTarget, + getSessionLiveState, + getWorktreeInfo, + getSessionResumeState, + getSessionResumeActions, + getSessionResumeInChat, + onToggleGroup, + onToggleSessionDetails, + onJumpToOriginalPane, + onJumpToWorktree, + onResume, + onContinueInNewSession, + onResumeInNewChat, + onCopyResume, + onCopyId, + onCopyPath, + onOpenLog, + onRevealLog, + onOpenCwd, + onRequestDelete +}: { + row: AiVaultListRow | undefined + index: number + start: number + activeStickyHeaderIndex: number | null + measureElement: (node: Element | null) => void + collapsedGroups: ReadonlySet + expandedSessionIds: ReadonlySet + vaultScope: AiVaultScope + buildResumeStartup: (session: AiVaultSession, worktreeId?: string | null) => AiVaultResumeStartup + getOriginalPaneTarget: (session: AiVaultSession) => AiVaultOriginalPaneTarget | null + getSessionLiveState: (session: AiVaultSession) => AgentStatusState | null + getWorktreeInfo: (session: AiVaultSession) => AiVaultSessionWorktreeInfo | null + getSessionResumeState: (session: AiVaultSession) => AiVaultSessionResumeState + getSessionResumeActions: (session: AiVaultSession) => AiVaultSessionResumeActions + getSessionResumeInChat: (session: AiVaultSession) => AiVaultResumeInChatEligibility + onToggleGroup: (key: string) => void + onToggleSessionDetails: (sessionId: string) => void + onJumpToOriginalPane: (session: AiVaultSession) => void + onJumpToWorktree: (worktreeId: string) => void + onResume: (session: AiVaultSession, worktreeId: string) => void + onContinueInNewSession: (session: AiVaultSession, worktreeId: string) => void + onResumeInNewChat: (session: AiVaultSession, worktreeId: string) => void + onCopyResume: (session: AiVaultSession, worktreeId?: string | null) => void + onCopyId: (session: AiVaultSession) => void + onCopyPath: (session: AiVaultSession) => void + onOpenLog: (session: AiVaultSession) => void + onRevealLog: (session: AiVaultSession) => void + onOpenCwd: (session: AiVaultSession) => void + onRequestDelete: (session: AiVaultSession) => void +}): React.JSX.Element | null { + if (!row) { + return null + } + + const isActiveStickyHeader = row.type === 'group' && activeStickyHeaderIndex === index + const originalPaneTarget = row.type === 'session' ? getOriginalPaneTarget(row.session) : null + const worktreeInfo = row.type === 'session' ? getWorktreeInfo(row.session) : null + // Why: omit the jump affordance when the session already lives in the + // worktree on screen — jumping there is a no-op. + const showJumpToWorktree = !isAiVaultSessionInCurrentWorktree(worktreeInfo) + const worktreeJumpId = + showJumpToWorktree && canJumpToAiVaultSessionWorktree(worktreeInfo) + ? worktreeInfo?.worktreeId + : null + const resumeState = row.type === 'session' ? getSessionResumeState(row.session) : null + const resumeActions = row.type === 'session' ? getSessionResumeActions(row.session) : null + const resumeInChat = row.type === 'session' ? getSessionResumeInChat(row.session) : null + const continuationWorktreeId = + row.type === 'session' && + canContinueAiVaultSessionInNewSession(row.session, resumeState?.worktreeId) + ? resumeState?.worktreeId + : null + // Gate resume on real content: a zero-turn transcript would resume into an + // empty conversation, so it is never offered as normally resumable. + const resumeGating = + row.type === 'session' + ? aiVaultSessionRowResumeGating(row.session, resumeState) + : { resumeDisabled: true, canCopyResumeCommand: false } + const resumeLabel = resumeState ? aiVaultSessionResumeLabel(resumeState) : '' + const canOpenLocalSessionPaths = + row.type === 'session' && canUseLocalAiVaultSessionPathActions(row.session.executionHostId) + // Why: in-Orca View Log additionally withholds synthetic (SQLite/OpenCode) + // identities that have no single file to open, while Reveal/CWD stay on the + // existing local-path gate. + const canOpenLogInOrca = row.type === 'session' && canOpenAiVaultSessionLogInOrca(row.session) + + return ( +
+ {row.type === 'group' ? ( + onToggleGroup(row.group.key)} + /> + ) : ( + onToggleSessionDetails(row.session.id)} + onJumpToOriginalPane={ + originalPaneTarget ? () => onJumpToOriginalPane(row.session) : undefined + } + showJumpToWorktree={showJumpToWorktree} + onJumpToWorktree={worktreeJumpId ? () => onJumpToWorktree(worktreeJumpId) : undefined} + onResume={() => { + if (resumeState?.worktreeId) { + onResume(row.session, resumeState.worktreeId) + } + }} + onContinueInNewSession={ + continuationWorktreeId + ? () => onContinueInNewSession(row.session, continuationWorktreeId) + : undefined + } + onResumeInNewChat={ + resumeInChat?.available + ? () => onResumeInNewChat(row.session, resumeInChat.workspaceId) + : undefined + } + onResumeInWorktree={() => { + if (resumeActions?.worktree.worktreeId) { + onResume(row.session, resumeActions.worktree.worktreeId) + } + }} + onResumeInNewTab={() => { + if (resumeActions?.newTab.worktreeId) { + onResume(row.session, resumeActions.newTab.worktreeId) + } + }} + onCopyResume={ + resumeGating.canCopyResumeCommand + ? () => onCopyResume(row.session, resumeState?.worktreeId) + : undefined + } + onCopyId={() => onCopyId(row.session)} + onCopyPath={() => onCopyPath(row.session)} + onOpenLog={canOpenLogInOrca ? () => onOpenLog(row.session) : undefined} + onRevealLog={canOpenLocalSessionPaths ? () => onRevealLog(row.session) : undefined} + onOpenCwd={ + canOpenLocalSessionPaths && row.session.cwd ? () => onOpenCwd(row.session) : undefined + } + onRequestDelete={onRequestDelete} + /> + )} +
+ ) +} diff --git a/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx b/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx index c41c89ef966..262d736661e 100644 --- a/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx +++ b/src/renderer/src/components/right-sidebar/SessionRowTrailingActions.tsx @@ -53,6 +53,7 @@ export function SessionRowTrailingActions({ onJumpToWorktree, onResume, onContinueInNewSession, + onResumeInNewChat, onCopyResume, onCopyId, onCopyPath, @@ -75,6 +76,8 @@ export function SessionRowTrailingActions({ onJumpToWorktree?: () => void onResume: () => void onContinueInNewSession?: () => void + /** Passed through to the overflow menu only; the resting row keeps its two-icon budget. */ + onResumeInNewChat?: () => void onCopyResume?: () => void onCopyId: () => void onCopyPath: () => void @@ -256,6 +259,7 @@ export function SessionRowTrailingActions({ resumeLabel={resumeLabel} onResume={onResume} onContinueInNewSession={onContinueInNewSession} + onResumeInNewChat={onResumeInNewChat} onJumpToOriginalPane={onJumpToOriginalPane} showJumpToWorktree={showJumpToWorktree} onJumpToWorktree={onJumpToWorktree} 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 fbc14e6a19f..ce1ed671e7e 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 @@ -10,25 +10,24 @@ import { activateAndRevealWorktree } from '@/lib/worktree-activation' import { useAppStore } from '@/store' -import { - canResumeAiVaultSessionOnTarget, - getAiVaultResumeWorkspaceExecutionHostId, - getAiVaultResumeWorkspaceTargetStatus -} from '@/lib/ai-vault-resume-target' import type { AiVaultAgent, AiVaultSession } from '../../../../shared/ai-vault-types' import { 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 { parseWorkspaceKey } from '../../../../shared/workspace-scope' -import { - isKnownAiVaultResumeWorkspaceTarget, - type AiVaultSessionResumeTargetState -} from './ai-vault-session-resume' +import type { AiVaultSessionResumeTargetState } from './ai-vault-session-resume' import { prepareAiVaultSessionContinuation } from './ai-vault-session-continuation' import type { AgentSessionContinuationRequest } from '@/lib/agent-session-continuation' -import { findWorktreeById } from '@/store/slices/worktree-helpers' import { activateAiVaultStructuredSession } from '@/lib/activate-ai-vault-structured-session' +import { startStructuredAgentLaunch } from '@/lib/structured-agent-session-launch' +import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle' +import { hasRuntimeRpcErrorCode } from '../../../../shared/runtime-rpc-error-code' +import { + aiVaultResumeUnsupportedMessage, + resolveAiVaultSessionLaunchTarget, + resolveAiVaultTargetWorkspacePath +} from './ai-vault-session-launch-target' export function useAiVaultSessionLaunchActions({ activeWorktree, @@ -147,6 +146,44 @@ export function useAiVaultSessionLaunchActions({ [activeWorktree?.id, activeWorktreeId, buildResumeStartup, targetState] ) + const handleResumeInNewChat = useCallback( + (session: AiVaultSession, targetWorktreeId?: string): void => { + if (!isAgentSessionHandleProvider(session.agent)) { + return + } + const worktreeId = targetWorktreeId ?? activeWorktreeId ?? activeWorktree?.id ?? null + if (!worktreeId) { + toast.error( + translate( + 'auto.components.right.sidebar.AiVaultPanel.openWorkspaceBeforeResuming', + 'Open a workspace before resuming a session.' + ) + ) + return + } + // Codex rows can live under a shared legacy home; the same preparation the terminal resume + // runs re-pins them, and its result is what names the conversation the host will look for. + void prepareAiVaultSessionForResume(session) + .then((preparedSession) => { + const launch = startStructuredAgentLaunch( + worktreeId, + session.agent as 'claude' | 'codex', + { + resumeFrom: { providerSessionId: preparedSession.sessionId } + } + ) + return launch.launchResult + }) + .then(() => { + if (useAppStore.getState().activeWorktreeId !== worktreeId) { + activateAiVaultResumeWorkspace(worktreeId) + } + }) + .catch(notifyAiVaultSessionResumeInChatFailure) + }, + [activeWorktree?.id, activeWorktreeId] + ) + const handleContinueInNewSession = useCallback( (session: AiVaultSession, targetWorktreeId: string): void => { const targetId = resolveAiVaultSessionLaunchTargetOrNotify({ @@ -194,12 +231,43 @@ export function useAiVaultSessionLaunchActions({ buildResumeStartup, copyResumeCommand, handleResume, + handleResumeInNewChat, handleContinueInNewSession, continuationRequest, handleContinuationDialogOpenChange } } +/** The host refuses an adoption whose conversation another chat already holds, and refuses one it + * cannot find under any account home it recognises. Both are actionable, and neither is the + * generic "could not prepare" the terminal resume reports. */ +function notifyAiVaultSessionResumeInChatFailure(error: unknown): void { + if (hasRuntimeRpcErrorCode(error, 'agent_session_conflict')) { + toast.error( + translate( + 'auto.components.right.sidebar.AiVaultPanel.resumeInChatConflict', + 'Another chat is already holding this conversation.' + ) + ) + return + } + if (hasRuntimeRpcErrorCode(error, 'agent_session_identity_required')) { + toast.error( + translate( + 'auto.components.right.sidebar.AiVaultPanel.resumeInChatTranscriptMissing', + "This conversation's history could not be loaded, so it cannot be resumed in chat." + ) + ) + return + } + toast.error( + translate( + 'auto.components.right.sidebar.AiVaultPanel.resumeInChatFailed', + 'Could not resume this session in a new chat.' + ) + ) +} + function notifyAiVaultSessionPreparationFailure(error: unknown): void { toast.error( error instanceof Error @@ -211,66 +279,9 @@ function notifyAiVaultSessionPreparationFailure(error: unknown): void { ) } -function resolveAiVaultTargetWorkspacePath( - state: AiVaultSessionResumeTargetState, - workspaceId: string -): string | null { - const scope = parseWorkspaceKey(workspaceId) - if (scope?.type === 'folder') { - return ( - state.folderWorkspaces.find((workspace) => workspace.id === scope.folderWorkspaceId) - ?.folderPath ?? null - ) - } - const worktreeId = scope?.type === 'worktree' ? scope.worktreeId : workspaceId - return findWorktreeById(state.worktreesByRepo, worktreeId)?.path ?? null -} - -export type AiVaultSessionLaunchTarget = - | { status: 'missing' } - | { - status: 'unsupported' - targetStatus: ReturnType - } - | { status: 'ready'; worktreeId: string } - -export function resolveAiVaultSessionLaunchTarget(args: { - sessionFilePath: string | null - sessionExecutionHostId?: AiVaultSession['executionHostId'] | null - activeWorktreeId: string | null - targetWorktreeId?: string - targetState: AiVaultSessionResumeTargetState -}): AiVaultSessionLaunchTarget { - const targetWorktreeId = args.targetWorktreeId ?? args.activeWorktreeId - if ( - !targetWorktreeId || - !isKnownAiVaultResumeWorkspaceTarget(args.targetState, targetWorktreeId) - ) { - return { status: 'missing' } - } - - const targetStatus = getAiVaultResumeWorkspaceTargetStatus(args.targetState, targetWorktreeId) - const targetExecutionHostId = getAiVaultResumeWorkspaceExecutionHostId( - args.targetState, - targetWorktreeId - ) - if ( - !canResumeAiVaultSessionOnTarget({ - sessionFilePath: args.sessionFilePath, - sessionExecutionHostId: args.sessionExecutionHostId, - targetStatus, - targetExecutionHostId - }) - ) { - return { status: 'unsupported', targetStatus } - } - - return { status: 'ready', worktreeId: targetWorktreeId } -} - function resolveAiVaultSessionLaunchTargetOrNotify( args: Parameters[0] -): Extract | null { +): Extract, { status: 'ready' }> | null { const target = resolveAiVaultSessionLaunchTarget(args) if (target.status === 'missing') { toast.error( @@ -288,23 +299,6 @@ function resolveAiVaultSessionLaunchTargetOrNotify( return target } -function aiVaultResumeUnsupportedMessage( - targetStatus: ReturnType -): string { - // Why: local and SSH targets can both be valid generally; this branch means - // the session's recorded host does not match the selected workspace. - if (targetStatus === 'ssh' || targetStatus === 'local' || targetStatus === 'runtime') { - return translate( - 'auto.components.right.sidebar.AiVaultPanel.sessionHostMismatchUnsupported', - 'This session belongs to a different host. Open a workspace on the same host to resume it.' - ) - } - return translate( - 'auto.components.right.sidebar.AiVaultPanel.openSupportedWorkspace', - 'Open a workspace before resuming a session.' - ) -} - function activateAiVaultResumeWorkspace(workspaceId: string): void { const workspaceScope = parseWorkspaceKey(workspaceId) if (workspaceScope?.type === 'folder') { diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-launch-target.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-target.ts new file mode 100644 index 00000000000..98e136931d5 --- /dev/null +++ b/src/renderer/src/components/right-sidebar/ai-vault-session-launch-target.ts @@ -0,0 +1,87 @@ +import { + canResumeAiVaultSessionOnTarget, + getAiVaultResumeWorkspaceExecutionHostId, + getAiVaultResumeWorkspaceTargetStatus +} from '@/lib/ai-vault-resume-target' +import { translate } from '@/i18n/i18n' +import { findWorktreeById } from '@/store/slices/worktree-helpers' +import type { AiVaultSession } from '../../../../shared/ai-vault-types' +import { parseWorkspaceKey } from '../../../../shared/workspace-scope' +import { + isKnownAiVaultResumeWorkspaceTarget, + type AiVaultSessionResumeTargetState +} from './ai-vault-session-resume' + +export function resolveAiVaultTargetWorkspacePath( + state: AiVaultSessionResumeTargetState, + workspaceId: string +): string | null { + const scope = parseWorkspaceKey(workspaceId) + if (scope?.type === 'folder') { + return ( + state.folderWorkspaces.find((workspace) => workspace.id === scope.folderWorkspaceId) + ?.folderPath ?? null + ) + } + const worktreeId = scope?.type === 'worktree' ? scope.worktreeId : workspaceId + return findWorktreeById(state.worktreesByRepo, worktreeId)?.path ?? null +} + +export type AiVaultSessionLaunchTarget = + | { status: 'missing' } + | { + status: 'unsupported' + targetStatus: ReturnType + } + | { status: 'ready'; worktreeId: string } + +export function resolveAiVaultSessionLaunchTarget(args: { + sessionFilePath: string | null + sessionExecutionHostId?: AiVaultSession['executionHostId'] | null + activeWorktreeId: string | null + targetWorktreeId?: string + targetState: AiVaultSessionResumeTargetState +}): AiVaultSessionLaunchTarget { + const targetWorktreeId = args.targetWorktreeId ?? args.activeWorktreeId + if ( + !targetWorktreeId || + !isKnownAiVaultResumeWorkspaceTarget(args.targetState, targetWorktreeId) + ) { + return { status: 'missing' } + } + + const targetStatus = getAiVaultResumeWorkspaceTargetStatus(args.targetState, targetWorktreeId) + const targetExecutionHostId = getAiVaultResumeWorkspaceExecutionHostId( + args.targetState, + targetWorktreeId + ) + if ( + !canResumeAiVaultSessionOnTarget({ + sessionFilePath: args.sessionFilePath, + sessionExecutionHostId: args.sessionExecutionHostId, + targetStatus, + targetExecutionHostId + }) + ) { + return { status: 'unsupported', targetStatus } + } + + return { status: 'ready', worktreeId: targetWorktreeId } +} + +export function aiVaultResumeUnsupportedMessage( + targetStatus: ReturnType +): string { + // Why: local and SSH targets can both be valid generally; this branch means + // the session's recorded host does not match the selected workspace. + if (targetStatus === 'ssh' || targetStatus === 'local' || targetStatus === 'runtime') { + return translate( + 'auto.components.right.sidebar.AiVaultPanel.sessionHostMismatchUnsupported', + 'This session belongs to a different host. Open a workspace on the same host to resume it.' + ) + } + return translate( + 'auto.components.right.sidebar.AiVaultPanel.openSupportedWorkspace', + 'Open a workspace before resuming a session.' + ) +} diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-workspace.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-workspace.ts new file mode 100644 index 00000000000..adedc94b22a --- /dev/null +++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat-workspace.ts @@ -0,0 +1,64 @@ +import { + structuredAgentLaunchSupported, + type AgentLaunchRoutingInput +} from '@/lib/agent-launch-routing' +import { getLocalProjectExecutionRuntimeContext } from '@/lib/local-preflight-context' +import { CLIENT_PLATFORM } from '@/lib/new-workspace' +import { getExecutionHostIdForWorktree } from '@/lib/worktree-runtime-owner' +import { readLocalRuntimeCapabilities } from '@/runtime/local-runtime-capabilities' +import { useAppStore } from '@/store' +import type { AiVaultSession } from '../../../../shared/ai-vault-types' +import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle' +import { STRUCTURED_AGENT_SESSION_RESUME_HISTORY_RUNTIME_CAPABILITY } from '../../../../shared/protocol-version' +import { resolveAiVaultTargetWorkspacePath } from './ai-vault-session-launch-target' +import { + resolveAiVaultSessionResumeInChatEligibility, + type AiVaultResumeInChatEligibility +} from './ai-vault-session-resume-in-chat' +import type { + AiVaultSessionResumeState, + AiVaultSessionResumeTargetState +} from './ai-vault-session-resume' + +export function resolveAiVaultSessionResumeInChatForWorkspace(args: { + session: AiVaultSession + resumeState: AiVaultSessionResumeState + activeWorkspaceId: string | null + targetState: AiVaultSessionResumeTargetState + settings: AgentLaunchRoutingInput['settings'] +}): AiVaultResumeInChatEligibility { + const targetWorkspaceId = args.resumeState.usesSessionWorktree + ? args.resumeState.worktreeId + : (args.resumeState.worktreeId ?? args.activeWorkspaceId) + const targetWorkspacePath = targetWorkspaceId + ? resolveAiVaultTargetWorkspacePath(args.targetState, targetWorkspaceId) + : null + return resolveAiVaultSessionResumeInChatEligibility({ + session: args.session, + targetWorkspaceId, + targetWorkspacePath, + structuredRouteAvailable: + isAgentSessionHandleProvider(args.session.agent) && + Boolean(targetWorkspaceId) && + structuredAgentLaunchSupported({ + agent: args.session.agent, + settings: args.settings, + executionHostId: getExecutionHostIdForWorktree( + useAppStore.getState(), + targetWorkspaceId as string + ), + platform: CLIENT_PLATFORM, + hostCapabilities: readLocalRuntimeCapabilities(), + workspaceKind: (targetWorkspaceId as string).startsWith('folder:') + ? 'folder' + : 'git-worktree', + projectRuntime: getLocalProjectExecutionRuntimeContext( + useAppStore.getState(), + targetWorkspaceId as string + ) + }) && + readLocalRuntimeCapabilities().includes( + STRUCTURED_AGENT_SESSION_RESUME_HISTORY_RUNTIME_CAPABILITY + ) + }) +} diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.test.ts new file mode 100644 index 00000000000..f945cdaa95a --- /dev/null +++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.test.ts @@ -0,0 +1,170 @@ +import { describe, expect, it } from 'vitest' +import type { AiVaultSession } from '../../../../shared/ai-vault-types' +import { + aiVaultSessionCwdMatchesWorkspace, + resolveAiVaultSessionResumeInChatEligibility +} from './ai-vault-session-resume-in-chat' + +type ResumeInChatSession = Parameters< + typeof resolveAiVaultSessionResumeInChatEligibility +>[0]['session'] + +const WORKSPACE_PATH = '/repo/orca' + +function session(overrides: Partial = {}): ResumeInChatSession { + return { + agent: 'claude', + cwd: WORKSPACE_PATH, + filePath: '/home/dev/.claude/projects/-repo-orca/session-1.jsonl', + executionHostId: 'local', + messageCount: 12, + previewMessages: [], + ...overrides + } +} + +function eligibility( + overrides: Partial[0]> = {} +) { + return resolveAiVaultSessionResumeInChatEligibility({ + session: session(), + targetWorkspaceId: 'repo-1::/repo/orca', + targetWorkspacePath: WORKSPACE_PATH, + structuredRouteAvailable: true, + ...overrides + }) +} + +describe('resolveAiVaultSessionResumeInChatEligibility', () => { + it('offers the chat for a local Claude row in its own workspace', () => { + expect(eligibility()).toEqual({ available: true, workspaceId: 'repo-1::/repo/orca' }) + }) + + it.each(['hermes', 'grok', 'opencode'] as AiVaultSession['agent'][])( + 'refuses %s, which has no structured lane', + (agent) => { + expect(eligibility({ session: session({ agent }) })).toEqual({ + available: false, + reason: 'agent' + }) + } + ) + + it('refuses a row already adopted into a chat before any other check', () => { + // That row reopens its own chat; a second adoption is a conflict the host would refuse. + expect( + eligibility({ + session: { + ...session(), + structuredSession: { sessionId: 'claude_1', workspaceId: 'repo-1::/repo/orca' } + } + }) + ).toEqual({ available: false, reason: 'already-structured' }) + }) + + it('refuses a row recorded on a remote host', () => { + expect(eligibility({ session: session({ executionHostId: 'ssh:build-box' }) })).toEqual({ + available: false, + reason: 'remote' + }) + }) + + it('refuses a row whose transcript is stored inside WSL', () => { + expect( + eligibility({ + session: session({ + filePath: '//wsl.localhost/Ubuntu-22.04/home/dev/.claude/projects/p/session-1.jsonl' + }) + }) + ).toEqual({ available: false, reason: 'remote' }) + }) + + it('refuses a transcript that holds no conversation', () => { + expect(eligibility({ session: session({ messageCount: 0, previewMessages: [] }) })).toEqual({ + available: false, + reason: 'empty' + }) + }) + + it('offers a zero-count row whose preview proves the turns exist', () => { + // Some parsers only learn the turn count from metadata that may be absent. + expect( + eligibility({ + session: session({ + messageCount: 0, + previewMessages: [{ role: 'user', text: 'hello', timestamp: null }] + }) + }) + ).toMatchObject({ available: true }) + }) + + it('refuses when the same pair could not take the structured route for a fresh chat', () => { + expect(eligibility({ structuredRouteAvailable: false })).toEqual({ + available: false, + reason: 'workspace' + }) + }) + + it('refuses when there is no target workspace at all', () => { + expect(eligibility({ targetWorkspaceId: null })).toEqual({ + available: false, + reason: 'workspace' + }) + }) +}) + +describe('workspace matching, which only Claude is bound by', () => { + it('refuses a Claude row whose conversation was recorded in another workspace', () => { + // Claude's SDK keys transcripts by launch cwd, so resuming elsewhere silently finds nothing. + expect( + eligibility({ + session: session({ cwd: '/repo/other' }), + targetWorkspacePath: WORKSPACE_PATH + }) + ).toEqual({ available: false, reason: 'workspace' }) + }) + + it('refuses a Claude row that recorded no cwd', () => { + expect(eligibility({ session: session({ cwd: null }) })).toEqual({ + available: false, + reason: 'workspace' + }) + }) + + it('keeps Codex available in a different workspace, and with no recorded cwd', () => { + // Codex is handed the rollout file and a cwd, so it resumes anywhere. + expect(eligibility({ session: session({ agent: 'codex', cwd: '/repo/other' }) })).toMatchObject( + { available: true } + ) + expect(eligibility({ session: session({ agent: 'codex', cwd: null }) })).toMatchObject({ + available: true + }) + }) + + it('treats Windows spellings of one directory as the same workspace', () => { + expect( + eligibility({ + session: session({ cwd: 'C:\\Users\\Dev\\repo\\Orca\\' }), + targetWorkspacePath: 'c:/users/dev/repo/orca' + }) + ).toMatchObject({ available: true }) + }) +}) + +describe('aiVaultSessionCwdMatchesWorkspace', () => { + it('ignores separator, case, and a trailing slash', () => { + expect(aiVaultSessionCwdMatchesWorkspace('C:\\repo\\Orca', 'c:/repo/orca')).toBe(true) + expect(aiVaultSessionCwdMatchesWorkspace('/repo/orca/', '/repo/orca')).toBe(true) + expect(aiVaultSessionCwdMatchesWorkspace(' /repo/orca ', '/repo/orca')).toBe(true) + }) + + it('never calls a missing path a match', () => { + expect(aiVaultSessionCwdMatchesWorkspace(null, '/repo/orca')).toBe(false) + expect(aiVaultSessionCwdMatchesWorkspace('/repo/orca', null)).toBe(false) + expect(aiVaultSessionCwdMatchesWorkspace('', '')).toBe(false) + }) + + it('does not treat a sibling directory as the same workspace', () => { + expect(aiVaultSessionCwdMatchesWorkspace('/repo/orca-2', '/repo/orca')).toBe(false) + }) +}) diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.ts new file mode 100644 index 00000000000..92817807f77 --- /dev/null +++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume-in-chat.ts @@ -0,0 +1,100 @@ +// Whether an Agent Session History row can be resumed into a structured native chat, and where. +// +// Separate from `ai-vault-session-resume.ts` because the answer is not the same question: the +// terminal resume asks whether a workspace can host a PTY, this asks whether a provider will still +// find the conversation from the workspace we would run it in. + +import { isWslStoredAiVaultSessionFile } from '@/lib/ai-vault-resume-target' +import { normalizeRuntimePathForComparison } from '../../../../shared/cross-platform-path' +import { LOCAL_EXECUTION_HOST_ID } from '../../../../shared/execution-host' +import { isAgentSessionHandleProvider } from '../../../../shared/agent-session-provider-handle' +import { + isAiVaultSessionResumableContent, + type AiVaultSession +} from '../../../../shared/ai-vault-types' + +export type AiVaultResumeInChatBlockedReason = + | 'agent' + | 'remote' + | 'empty' + | 'already-structured' + | 'workspace' + +export type AiVaultResumeInChatEligibility = + | { available: true; workspaceId: string } + | { available: false; reason: AiVaultResumeInChatBlockedReason } + +/** + * Claude and Codex do not have the same freedom about *where* a conversation may be resumed. + * + * Codex is handed the rollout file and a cwd, so it can resume into any workspace. Claude's SDK + * stores transcripts under a project key derived from the launch cwd, so resuming from a workspace + * other than the one the conversation was recorded in looks in a directory the transcript is not in. + * That is a resume that silently yields nothing, which is worse than a disabled affordance. + */ +export function aiVaultSessionResumeInChatWorkspaceMatters( + agent: AiVaultSession['agent'] +): boolean { + return agent === 'claude' +} + +/** + * Does the row's recorded directory name the same place as the target workspace? + * + * Uses the shared runtime-path comparison rather than a local normalizer, which also keeps POSIX + * paths case-SENSITIVE — folding their case would call two genuinely different directories the same. + */ +export function aiVaultSessionCwdMatchesWorkspace( + cwd: string | null | undefined, + workspacePath: string | null | undefined +): boolean { + if (!cwd || !workspacePath) { + return false + } + return ( + normalizeRuntimePathForComparison(cwd.trim()) === + normalizeRuntimePathForComparison(workspacePath.trim()) + ) +} + +export function resolveAiVaultSessionResumeInChatEligibility(args: { + session: Pick< + AiVaultSession, + 'agent' | 'cwd' | 'filePath' | 'executionHostId' | 'messageCount' | 'previewMessages' + > & { structuredSession?: AiVaultSession['structuredSession'] } + targetWorkspaceId: string | null + targetWorkspacePath: string | null + /** The route the same (workspace, agent) pair would take for a fresh chat. Reused rather than + * re-derived: it already encodes the settings flag, host capability, platform refusals and the + * WSL/repair refusal, and a second copy of those conditions would drift from it. */ + structuredRouteAvailable: boolean +}): AiVaultResumeInChatEligibility { + const { session } = args + if (!isAgentSessionHandleProvider(session.agent)) { + return { available: false, reason: 'agent' } + } + // An already-adopted row reopens its own chat instead; offering a second resume of it would ask + // for a conflict the host would rightly refuse. + if (session.structuredSession) { + return { available: false, reason: 'already-structured' } + } + if ( + session.executionHostId !== LOCAL_EXECUTION_HOST_ID || + isWslStoredAiVaultSessionFile(session.filePath) + ) { + return { available: false, reason: 'remote' } + } + if (!isAiVaultSessionResumableContent(session)) { + return { available: false, reason: 'empty' } + } + if (!args.targetWorkspaceId || !args.structuredRouteAvailable) { + return { available: false, reason: 'workspace' } + } + if ( + aiVaultSessionResumeInChatWorkspaceMatters(session.agent) && + !aiVaultSessionCwdMatchesWorkspace(session.cwd, args.targetWorkspacePath) + ) { + return { available: false, reason: 'workspace' } + } + return { available: true, workspaceId: args.targetWorkspaceId } +} diff --git a/src/renderer/src/components/right-sidebar/ai-vault-session-resume.test.ts b/src/renderer/src/components/right-sidebar/ai-vault-session-resume.test.ts index 583e668cd2a..b5d3fe53c72 100644 --- a/src/renderer/src/components/right-sidebar/ai-vault-session-resume.test.ts +++ b/src/renderer/src/components/right-sidebar/ai-vault-session-resume.test.ts @@ -3,7 +3,7 @@ import type { Repo } from '../../../../shared/repo-types' import type { Worktree } from '../../../../shared/worktree/types' import type { AiVaultSessionWorktreeInfo } from './ai-vault-session-worktree' import { folderWorkspaceKey } from '../../../../shared/workspace-scope' -import { resolveAiVaultSessionLaunchTarget } from './ai-vault-session-launch-actions' +import { resolveAiVaultSessionLaunchTarget } from './ai-vault-session-launch-target' import { aiVaultSessionResumeLabel, aiVaultSessionRowResumeGating, diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json index ca33b766622..cf00f09b861 100644 --- a/src/renderer/src/i18n/locales/en.json +++ b/src/renderer/src/i18n/locales/en.json @@ -13006,7 +13006,10 @@ "localSessionSshWorkspaceUnsupported": "This session's history is stored on this machine, so it can't resume in an SSH workspace. Open a local workspace instead.", "prepareSessionResumeFailed": "Could not prepare this session for resume.", "sessionDeleted": "Session deleted", - "sessionDeleteFailed": "Couldn't delete the session" + "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." }, "AiVaultPanelControls": { "scanningSessions": "Scanning sessions", @@ -13142,7 +13145,8 @@ "delete": "Delete", "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." + "deleteReasonUnsupportedAgent": "{{value0}} sessions can't be deleted from Orca.", + "resumeInNewChat": "Resume in New Chat" }, "AiVaultSessionDeleteDialog": { "title": "Delete this session?", diff --git a/src/renderer/src/lib/agent-launch-routing.test.ts b/src/renderer/src/lib/agent-launch-routing.test.ts index 45c86bb1517..af219bab633 100644 --- a/src/renderer/src/lib/agent-launch-routing.test.ts +++ b/src/renderer/src/lib/agent-launch-routing.test.ts @@ -4,7 +4,8 @@ import { hasExplicitTuiAgentArgs, hasExplicitTuiLaunchCustomization, hasSemanticallyNonEmptyAgentArgs, - resolveAgentLaunchRoute + resolveAgentLaunchRoute, + structuredAgentLaunchSupported } from './agent-launch-routing' const settings = { @@ -190,3 +191,28 @@ describe('resolveAgentLaunchRoute', () => { expect(hasExplicitTuiAgentArgs('codex', '--model gpt-5.6-sol')).toBe(true) }) }) + +describe('explicit structured chat requests', () => { + it.each(['claude', 'codex'] as const)( + 'supports %s history resume when new tabs default to terminal', + (agent) => { + const input = { + agent, + settings: { ...settings, openAgentTabsInChatByDefault: false }, + executionHostId: 'local', + platform: 'darwin' as const, + hostCapabilities: [STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY], + workspaceKind: 'folder' as const + } + expect(resolveAgentLaunchRoute(input)).toBe('terminal-tui') + expect(structuredAgentLaunchSupported(input)).toBe(true) + expect(structuredAgentLaunchSupported({ ...input, hostCapabilities: [] })).toBe(false) + expect( + structuredAgentLaunchSupported({ + ...input, + settings: { ...input.settings, experimentalStructuredNativeChat: false } + }) + ).toBe(false) + } + ) +}) diff --git a/src/renderer/src/lib/agent-launch-routing.ts b/src/renderer/src/lib/agent-launch-routing.ts index 17cb95a43d0..2bca72ba3ae 100644 --- a/src/renderer/src/lib/agent-launch-routing.ts +++ b/src/renderer/src/lib/agent-launch-routing.ts @@ -56,16 +56,24 @@ export function resolveAgentLaunchRoute(input: AgentLaunchRoutingInput): AgentLa if (!prefersStructuredNativeChatByDefault(input.settings)) { return 'legacy-native-chat' } - return resolveStructuredNativeChatSupport({ - agent: input.agent, - executionHostId: input.executionHostId, - platform: input.platform, - hostCapabilities: input.hostCapabilities, - workspaceKind: input.workspaceKind, - projectRuntime: input.projectRuntime, - isDraftPrompt: input.promptDelivery === 'draft', - requiresTuiLaunchCustomization: input.requiresTuiLaunchCustomization - }).supported - ? 'structured-native-chat' - : 'legacy-native-chat' + return structuredAgentLaunchSupported(input) ? 'structured-native-chat' : 'legacy-native-chat' +} + +// Explicit chat requests do not depend on the default view mode for new tabs. +export function structuredAgentLaunchSupported( + input: Omit +): boolean { + return ( + input.settings?.experimentalStructuredNativeChat === true && + resolveStructuredNativeChatSupport({ + agent: input.agent, + executionHostId: input.executionHostId, + platform: input.platform, + hostCapabilities: input.hostCapabilities, + workspaceKind: input.workspaceKind, + projectRuntime: input.projectRuntime, + isDraftPrompt: input.promptDelivery === 'draft', + requiresTuiLaunchCustomization: input.requiresTuiLaunchCustomization + }).supported + ) } diff --git a/src/renderer/src/lib/launch-structured-agent-session.ts b/src/renderer/src/lib/launch-structured-agent-session.ts index ae85117b7e6..503ae771419 100644 --- a/src/renderer/src/lib/launch-structured-agent-session.ts +++ b/src/renderer/src/lib/launch-structured-agent-session.ts @@ -6,7 +6,8 @@ import type { import { createStructuredAgentSessionId, structuredAgentSessionCreateParams, - type StructuredAgentSessionCreateParams + type StructuredAgentSessionCreateParams, + type StructuredAgentSessionResumeSource } from '../../../shared/structured-agent-session-create' import { hasRuntimeRpcErrorCode } from '../../../shared/runtime-rpc-error-code' import { isDefinitiveAgentSessionCreateRefusal } from '../../../shared/agent-session-definitive-refusal' @@ -88,7 +89,8 @@ export function isDefinitiveStructuredAgentSessionCreateError(error: unknown): b export function createStructuredAgentSessionLaunchIntent( worktreeId: string, - agent: AgentSessionHandleProvider + agent: AgentSessionHandleProvider, + resumeFrom?: StructuredAgentSessionResumeSource ): StructuredAgentSessionLaunchIntent { const sessionId = createStructuredAgentSessionId(agent, () => crypto.randomUUID()) const state = useAppStore.getState() @@ -107,6 +109,7 @@ export function createStructuredAgentSessionLaunchIntent( sessionId, worktree: toRuntimeWorktreeSelector(worktreeId), agent, + ...(resumeFrom ? { resumeFrom } : {}), randomUuid: () => crypto.randomUUID() }) } diff --git a/src/renderer/src/lib/structured-agent-session-launch-callers.ts b/src/renderer/src/lib/structured-agent-session-launch-callers.ts index db9715c0c1a..18e14c006c0 100644 --- a/src/renderer/src/lib/structured-agent-session-launch-callers.ts +++ b/src/renderer/src/lib/structured-agent-session-launch-callers.ts @@ -4,6 +4,7 @@ import { type StructuredPromptDeliveryResult } from '@/lib/structured-agent-session-launch-prompt' import type { StructuredAgentSessionOutboxEntry } from '../../../shared/structured-agent-session-outbox' +import type { StructuredAgentSessionResumeSource } from '../../../shared/structured-agent-session-create' export type StructuredRefusalFallback = () => | void @@ -14,6 +15,9 @@ export type StructuredAgentLaunchOptions = { prompt?: string promptDelivery?: 'auto-submit' | 'submit-after-ready' onPromptDelivered?: () => void + /** Adopt an existing provider conversation instead of starting a fresh one. Part of the launch's + * identity, not a preference — see `launchIdentity`. */ + resumeFrom?: StructuredAgentSessionResumeSource } export type StructuredLaunchCaller = { diff --git a/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts b/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts new file mode 100644 index 00000000000..7e99ff73fe6 --- /dev/null +++ b/src/renderer/src/lib/structured-agent-session-launch-resume-identity.test.ts @@ -0,0 +1,157 @@ +// @vitest-environment happy-dom + +// Launch coalescing when a launch adopts a conversation. Drives the real intent builder, because +// the identity under test is derived there — mocking it out would assert only the mock's shape. + +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { StructuredAgentSessionCreateParams } from '../../../shared/structured-agent-session-create' + +const mocks = vi.hoisted(() => ({ + call: vi.fn(), + refresh: vi.fn() +})) + +vi.mock('sonner', () => ({ + toast: { error: vi.fn(), message: vi.fn() } +})) + +vi.mock('@/i18n/i18n', () => ({ + translate: (_key: string, fallback: string) => fallback +})) + +vi.mock('@/lib/agent-catalog', () => ({ + getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }] +})) + +vi.mock('@/runtime/structured-agent-session-client', () => ({ + callStructuredAgentSession: mocks.call +})) + +vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({ + LOCAL_STRUCTURED_SESSION_OWNER: 'local', + refreshLocalStructuredSessionTabs: mocks.refresh +})) + +vi.mock('@/store', () => ({ + useAppStore: { + getState: () => ({ unifiedTabsByWorktree: {} }), + subscribe: () => () => {} + } +})) + +import { + getStructuredAgentLaunchStatus, + startStructuredAgentLaunch +} from './structured-agent-session-launch' + +/** The create is dispatched off a microtask, so every assertion on it has to drain them first. */ +async function flushLaunchDispatch(): Promise { + for (let i = 0; i < 20; i += 1) { + await Promise.resolve() + } +} + +/** Every create is left in flight, so each launch is still pending when the next one arrives. */ +function createParams(): StructuredAgentSessionCreateParams[] { + return mocks.call.mock.calls + .filter(([, method]) => method === 'agentSession.create') + .map(([, , params]) => params as StructuredAgentSessionCreateParams) +} + +describe('a launch that adopts a conversation is its own identity', () => { + beforeEach(() => { + vi.clearAllMocks() + localStorage.clear() + mocks.refresh.mockResolvedValue([]) + mocks.call.mockImplementation(async (_target: unknown, method: string) => + method === 'agentSession.create' + ? new Promise(() => {}) + : { ok: true, value: { submission: { dispatchState: 'accepted' } } } + ) + }) + + it('does not hand a resume the blank launch already pending for the same worktree', async () => { + // A joining caller is handed the EXISTING intent and contributes only its prompt, so joining + // here would silently drop the adoption and open a blank chat instead. + const worktreeId = 'wt-resume-vs-blank' + const blank = startStructuredAgentLaunch(worktreeId, 'codex') + const resume = startStructuredAgentLaunch(worktreeId, 'codex', { + resumeFrom: { providerSessionId: 'thread-1' } + }) + + await flushLaunchDispatch() + + expect(resume.sessionId).not.toBe(blank.sessionId) + expect(createParams()).toEqual([ + expect.not.objectContaining({ resumeFrom: expect.anything() }), + expect.objectContaining({ resumeFrom: { providerSessionId: 'thread-1' } }) + ]) + }) + + it('does not hand a blank launch the resume already pending for the same worktree', async () => { + const worktreeId = 'wt-blank-vs-resume' + const resume = startStructuredAgentLaunch(worktreeId, 'codex', { + resumeFrom: { providerSessionId: 'thread-1' } + }) + const blank = startStructuredAgentLaunch(worktreeId, 'codex') + + await flushLaunchDispatch() + + expect(blank.sessionId).not.toBe(resume.sessionId) + expect(createParams()).toHaveLength(2) + }) + + it('keeps two resumes of different rows apart', async () => { + const worktreeId = 'wt-two-rows' + const first = startStructuredAgentLaunch(worktreeId, 'codex', { + resumeFrom: { providerSessionId: 'thread-1' } + }) + const second = startStructuredAgentLaunch(worktreeId, 'codex', { + resumeFrom: { providerSessionId: 'thread-2' } + }) + + await flushLaunchDispatch() + + expect(second.sessionId).not.toBe(first.sessionId) + expect(createParams().map((params) => params.resumeFrom?.providerSessionId)).toEqual([ + 'thread-1', + 'thread-2' + ]) + }) + + it('coalesces a duplicate click on the same row', async () => { + const worktreeId = 'wt-same-row-twice' + const resumeFrom = { providerSessionId: 'thread-1' } + const first = startStructuredAgentLaunch(worktreeId, 'codex', { resumeFrom }) + const second = startStructuredAgentLaunch(worktreeId, 'codex', { resumeFrom }) + + await flushLaunchDispatch() + + expect(second.sessionId).toBe(first.sessionId) + expect(createParams()).toHaveLength(1) + }) + + it('keeps the same row apart across worktrees and agents', async () => { + const resumeFrom = { providerSessionId: 'thread-1' } + const here = startStructuredAgentLaunch('wt-here', 'codex', { resumeFrom }) + const there = startStructuredAgentLaunch('wt-there', 'codex', { resumeFrom }) + + await flushLaunchDispatch() + + expect(there.sessionId).not.toBe(here.sessionId) + expect(createParams()).toHaveLength(2) + }) + + it('reports a pending resume as a launch in flight for the worktree', () => { + // "Is a chat starting here" means any launch for the pair, not only the blank one. + const worktreeId = 'wt-resume-status' + expect(getStructuredAgentLaunchStatus(worktreeId, 'codex')).toBe('idle') + + startStructuredAgentLaunch(worktreeId, 'codex', { + resumeFrom: { providerSessionId: 'thread-1' } + }) + + expect(getStructuredAgentLaunchStatus(worktreeId, 'codex')).toBe('pending') + expect(getStructuredAgentLaunchStatus(worktreeId, 'claude')).toBe('idle') + }) +}) diff --git a/src/renderer/src/lib/structured-agent-session-launch.ts b/src/renderer/src/lib/structured-agent-session-launch.ts index 2a97f6acb36..7543c176180 100644 --- a/src/renderer/src/lib/structured-agent-session-launch.ts +++ b/src/renderer/src/lib/structured-agent-session-launch.ts @@ -33,6 +33,7 @@ import { type StructuredLaunchCallerGroup, type StructuredRefusalFallback } from '@/lib/structured-agent-session-launch-callers' +import type { StructuredAgentSessionResumeSource } from '../../../shared/structured-agent-session-create' export type { StructuredAgentLaunchOptions, StructuredAgentLaunchReceipt } @@ -79,11 +80,18 @@ export function getStructuredAgentLaunchStatus( worktreeId: string, agent: AgentSessionHandleProvider ): StructuredAgentLaunchStatus { - const state = pendingStructuredLaunchesByIdentity.get(launchIdentity(worktreeId, agent)) - if (!state) { + // Any launch for this pair, not just the blank one: adopting launches carry the conversation in + // their identity, and a caller asking "is a chat starting here" means all of them. + const states = [ + pendingStructuredLaunchesByIdentity.get(launchIdentity(worktreeId, agent)), + ...[...pendingStructuredLaunchesByIdentity.entries()] + .filter(([identity]) => identity.startsWith(`${agent}:${worktreeId}:resume:`)) + .map(([, state]) => state) + ].filter((state): state is StructuredLaunchState => Boolean(state)) + if (states.length === 0) { return 'idle' } - return state.visibilityUnknown ? 'unknown' : 'pending' + return states.some((state) => state.visibilityUnknown) ? 'unknown' : 'pending' } export function useStructuredAgentLaunchStatus( @@ -99,8 +107,19 @@ export function useStructuredAgentLaunchStatus( // Why keyed by agent too: one worktree can hold a Claude and a Codex launch at once, and a shared // key would hand the second caller the first agent's intent. -function launchIdentity(worktreeId: string, agent: AgentSessionHandleProvider): string { - return `${agent}:${worktreeId}` +// +// Why keyed by the adopted conversation as well: a joining caller is handed the EXISTING intent and +// contributes only its prompt, so without this a resume that arrives while a blank launch is pending +// would be silently dropped — the user would get a blank chat, or another row's conversation, with +// no error. A launch that adopts a conversation is a different launch. +function launchIdentity( + worktreeId: string, + agent: AgentSessionHandleProvider, + resumeFrom?: StructuredAgentSessionResumeSource +): string { + return resumeFrom + ? `${agent}:${worktreeId}:resume:${resumeFrom.providerSessionId}` + : `${agent}:${worktreeId}` } function cleanupLaunchState(state: StructuredLaunchState): void { @@ -207,7 +226,7 @@ function structuredAgentLaunchState( agent: AgentSessionHandleProvider, options: StructuredAgentLaunchOptions ): StructuredLaunchStateResult { - const identity = launchIdentity(worktreeId, agent) + const identity = launchIdentity(worktreeId, agent, options.resumeFrom) const existing = pendingStructuredLaunchesByIdentity.get(identity) if (existing) { if (existing.visibilityUnknown) { @@ -233,7 +252,12 @@ function structuredAgentLaunchState( } } - const intent = createStructuredAgentSessionLaunchIntent(worktreeId, agent) + // Only pass the third argument when adopting: every ordinary launch keeps the two-argument call + // it has always made, so this change adds no trailing `undefined` for call-site assertions to + // absorb. + const intent = options.resumeFrom + ? createStructuredAgentSessionLaunchIntent(worktreeId, agent, options.resumeFrom) + : createStructuredAgentSessionLaunchIntent(worktreeId, agent) const text = options.prompt?.trim() ?? '' const stagedPrompt = text ? enqueueStructuredAgentSessionLaunchPrompt(intent.sessionId, text) diff --git a/src/shared/agent-session-provider-handle.test.ts b/src/shared/agent-session-provider-handle.test.ts index 538ff638983..e2830c01029 100644 --- a/src/shared/agent-session-provider-handle.test.ts +++ b/src/shared/agent-session-provider-handle.test.ts @@ -300,3 +300,94 @@ describe('chain lookup and validation', () => { ).toBe(false) }) }) + +describe('adopted chain heads', () => { + // What a resume-from-history builds: the create seeds an `adopted` head, then the provider's own + // proof lands on top of it. + const adopted = (overrides: Partial = {}) => + link({ + linkId: 'claude-1-sess-1-empty', + origin: 'adopted', + handle: { ...CLAUDE, leafUuid: null }, + ...overrides + }) + + it('appends a Claude resume that lands on the adopted root with a leaf', () => { + // The adopted head names no leaf; the provider answers with one. Same root, so it is a resume. + const resumed = link({ + linkId: 'claude-1-sess-1-leaf-1', + origin: 'resumed', + handle: CLAUDE, + mintedAtFence: 1 + }) + const chain = appendAgentSessionProviderHandleLink([adopted()], resumed) + + expect(chain.map((entry) => entry.origin)).toEqual(['adopted', 'resumed']) + expect(agentSessionProviderHandleChainHead(chain)).toBe(resumed) + }) + + it('elides a Claude re-proof of the identical adopted handle at the same fence', () => { + const chain = [adopted()] + const elided = appendAgentSessionProviderHandleLink( + chain, + link({ + linkId: 'claude-1-sess-1-empty-retry', + origin: 'resumed', + handle: { ...CLAUDE, leafUuid: null }, + mintedAtFence: 1 + }) + ) + + expect(elided).toEqual(chain) + }) + + it('appends a Codex resume only once the fence has moved', () => { + const codexAdopted = link({ + linkId: 'codex-1-thread-1', + origin: 'adopted', + handle: { provider: 'codex', threadId: 'thread-1' } + }) + const reproved = link({ + linkId: 'codex-1-thread-1-retry', + origin: 'resumed', + handle: { provider: 'codex', threadId: 'thread-1' }, + mintedAtFence: 1 + }) + + // Codex's thread id is the whole key, so a same-fence re-proof can only ever be a retry. + expect(appendAgentSessionProviderHandleLink([codexAdopted], reproved)).toEqual([codexAdopted]) + expect( + appendAgentSessionProviderHandleLink([codexAdopted], { ...reproved, mintedAtFence: 2 }) + ).toHaveLength(2) + }) + + it('refuses a second origin link on top of an adopted head', () => { + // Nothing re-origins a chain: a create landing here would erase where the conversation came from. + for (const origin of ['created', 'adopted'] as const) { + expect(() => + appendAgentSessionProviderHandleLink( + [adopted()], + link({ linkId: 'claude-2-sess-1-leaf-1', origin, handle: CLAUDE, mintedAtFence: 2 }) + ) + ).toThrow('agent_session_provider_handle_invalid') + } + }) + + it('refuses a resume that landed on another conversation entirely', () => { + expect(() => + appendAgentSessionProviderHandleLink( + [adopted()], + link({ + linkId: 'claude-1-sess-9-leaf-9', + origin: 'resumed', + handle: { provider: 'claude', sessionId: 'sess-9', leafUuid: 'leaf-9' }, + mintedAtFence: 1 + }) + ) + ).toThrow('agent_session_provider_handle_forked') + }) + + it('accepts an adopted head as a persisted chain', () => { + expect(isAgentSessionProviderHandleChain([adopted()])).toBe(true) + }) +}) diff --git a/src/shared/protocol-version.ts b/src/shared/protocol-version.ts index ef342d55d6a..e6de276133e 100644 --- a/src/shared/protocol-version.ts +++ b/src/shared/protocol-version.ts @@ -146,6 +146,12 @@ export const STRUCTURED_AGENT_SESSION_HOLD_RUNTIME_CAPABILITY = // negotiation rather than by calling and reading a refusal it cannot distinguish from a real one. export const STRUCTURED_AGENT_SESSION_REVEAL_RUNTIME_CAPABILITY = 'agent-session.structured.reveal.v1' as const +// Why: `agentSession.create` gains an optional `resumeFrom`, and its params are a STRICT union — an +// older host rejects the unknown key as a schema error, which a client cannot tell from a real +// refusal. Worse, without probing, a client cannot know whether a host that accepted the call +// adopted the conversation or quietly started a blank one. Negotiate before offering the action. +export const STRUCTURED_AGENT_SESSION_RESUME_HISTORY_RUNTIME_CAPABILITY = + 'agent-session.structured.resume-history.v1' as const // Why: agentSession.subscribeStatus is additive to a surface that already shipped, so a host // advertising agent-session.structured.v1 may still answer it with method_not_found. Clients must // probe before subscribing or they reconnect forever and never show any status at all. @@ -251,6 +257,7 @@ export const RUNTIME_CAPABILITIES = [ STRUCTURED_AGENT_SESSION_RUNTIME_CAPABILITY, STRUCTURED_AGENT_SESSION_HOLD_RUNTIME_CAPABILITY, STRUCTURED_AGENT_SESSION_REVEAL_RUNTIME_CAPABILITY, + STRUCTURED_AGENT_SESSION_RESUME_HISTORY_RUNTIME_CAPABILITY, AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY, AGENT_SESSION_KIMI_RESUME_RUNTIME_CAPABILITY, FILE_MUTATION_OWNERSHIP_RUNTIME_CAPABILITY, diff --git a/src/shared/structured-agent-session-create.test.ts b/src/shared/structured-agent-session-create.test.ts new file mode 100644 index 00000000000..d3aabf357f9 --- /dev/null +++ b/src/shared/structured-agent-session-create.test.ts @@ -0,0 +1,82 @@ +import { describe, expect, it } from 'vitest' +import { structuredAgentSessionCreateParams } from './structured-agent-session-create' +import { + structuredAgentSessionCreateFingerprint, + structuredAgentSessionPayloadFingerprint +} from './structured-agent-session-mutation' + +const SESSION_ID = 'codex_11111111_2222_3333_4444_555555555555' +const RESUME = { providerSessionId: 'thread-abc' } + +/** Distinct per call so two envelopes never share an operation id by accident. */ +let uuidCounter = 0 +function nextUuid(): string { + uuidCounter += 1 + return `00000000-0000-4000-8000-${String(uuidCounter).padStart(12, '0')}` +} + +function createParams(overrides: { resumeFrom?: { providerSessionId: string } } = {}) { + return structuredAgentSessionCreateParams({ + sessionId: SESSION_ID, + worktree: 'id:repo-1::/repo/orca', + agent: 'codex', + ...overrides, + randomUuid: nextUuid, + now: 1_800_000_000_000 + }) +} + +describe('structured agent session create params', () => { + it('carries resumeFrom only when the create adopts a conversation', () => { + expect(createParams()).not.toHaveProperty('resumeFrom') + expect(createParams({ resumeFrom: RESUME })).toMatchObject({ resumeFrom: RESUME }) + }) + + it('declares a fingerprint the host can recompute from the same fields', () => { + const params = createParams({ resumeFrom: RESUME }) + + expect(params.envelope.payloadFingerprint).toBe( + structuredAgentSessionCreateFingerprint({ + sessionId: SESSION_ID, + worktree: 'id:repo-1::/repo/orca', + agent: 'codex', + resumeFrom: RESUME + }) + ) + }) + + it('separates an adopting create from a blank one and from another row', () => { + const blank = createParams().envelope.payloadFingerprint + const adopted = createParams({ resumeFrom: RESUME }).envelope.payloadFingerprint + const otherRow = createParams({ + resumeFrom: { providerSessionId: 'thread-other' } + }).envelope.payloadFingerprint + + expect(adopted).not.toBe(blank) + expect(otherRow).not.toBe(adopted) + }) + + it('gives a replay of the same adoption the same digest under a new operation id', () => { + const first = createParams({ resumeFrom: RESUME }) + const second = createParams({ resumeFrom: RESUME }) + + expect(second.envelope.clientOperationId).not.toBe(first.envelope.clientOperationId) + expect(second.envelope.payloadFingerprint).toBe(first.envelope.payloadFingerprint) + }) + + it('leaves a blank create byte-identical to the pre-resume digest', () => { + // Pinned literal: a create with no `resumeFrom` must keep the digest older clients and hosts + // already compute, so adding a field to the create fingerprint fails here rather than in the + // field on a mixed-version pair. + expect(createParams().envelope.payloadFingerprint).toBe( + structuredAgentSessionPayloadFingerprint({ + method: 'agentSession.create', + sessionId: SESSION_ID, + fields: { worktree: 'id:repo-1::/repo/orca', agent: 'codex' } + }) + ) + expect(createParams().envelope.payloadFingerprint).toBe( + '56cb15e22414c0f62fd89d77d00d2d6a0a422f16e95edee154fb8b5bf53fbbc3' + ) + }) +}) diff --git a/src/shared/structured-agent-session-create.ts b/src/shared/structured-agent-session-create.ts index 13c7b4fe29a..a467db550a4 100644 --- a/src/shared/structured-agent-session-create.ts +++ b/src/shared/structured-agent-session-create.ts @@ -5,10 +5,24 @@ import { structuredAgentSessionCreateFingerprint } from './structured-agent-session-mutation' +/** + * The conversation a create adopts instead of starting a fresh one. + * + * Deliberately carries an identity and nothing else. The transcript file and the account home it + * lives under are derived by the executing host, never sent: `agentSession.create` is reachable by + * paired mobile clients, and a client-supplied path would let one choose which file the host reads + * into a journal and which credential directory the provider child launches against. + */ +export type StructuredAgentSessionResumeSource = { + /** claude: the session id. codex: the thread id. */ + providerSessionId: string +} + export type StructuredAgentSessionCreateParams = { envelope: AgentSessionMutationEnvelope worktree: string agent: AgentSessionHandleProvider + resumeFrom?: StructuredAgentSessionResumeSource } /** Provider-prefixed so a session id names its lane on sight, and underscore-only @@ -29,10 +43,15 @@ export function structuredAgentSessionCreateParams(args: { sessionId: string worktree: string agent: AgentSessionHandleProvider + resumeFrom?: StructuredAgentSessionResumeSource randomUuid: () => string now?: number }): StructuredAgentSessionCreateParams { - const fields = { worktree: args.worktree, agent: args.agent } + const fields = { + worktree: args.worktree, + agent: args.agent, + ...(args.resumeFrom ? { resumeFrom: args.resumeFrom } : {}) + } return { envelope: { sessionId: args.sessionId, diff --git a/src/shared/structured-agent-session-mutation.ts b/src/shared/structured-agent-session-mutation.ts index 79c82095f29..1f3400b5e85 100644 --- a/src/shared/structured-agent-session-mutation.ts +++ b/src/shared/structured-agent-session-mutation.ts @@ -30,13 +30,17 @@ export function structuredAgentSessionCreateFingerprint(input: { sessionId: string worktree: string agent: 'claude' | 'codex' + resumeFrom?: { providerSessionId: string } }): string { return structuredAgentSessionPayloadFingerprint({ method: 'agentSession.create', sessionId: input.sessionId, fields: { worktree: input.worktree, - agent: input.agent + agent: input.agent, + // `canonicalize` drops undefined, so a plain create keeps the digest it has always had. + // Adopting a conversation is a different intent and must not replay as a blank create. + resumeFrom: input.resumeFrom } }) }