diff --git a/src/main/claude-accounts/claude-account-folder.ts b/src/main/claude-accounts/claude-account-folder.ts index 0da1f25efb3..b227ad312be 100644 --- a/src/main/claude-accounts/claude-account-folder.ts +++ b/src/main/claude-accounts/claude-account-folder.ts @@ -33,15 +33,30 @@ const oauthAccount = z.object({ organizationName: text }) -export function claudeStateFile(configDir: string | undefined, userHome = homedir()): string { +export function claudeStateFile( + configDir: string | undefined, + userHome = homedir(), + exists: (path: string) => boolean = existsSync +): string { return resolveClaudeGlobalConfigFile({ env: { CLAUDE_CONFIG_DIR: configDir }, homeDir: userHome, style: process.platform === 'win32' ? 'win32' : 'posix', - exists: existsSync + exists }) } +/** Same file as claudeStateFile, without blocking main on the legacy-file check. */ +export async function claudeStateFileAsync( + configDir: string | undefined, + userHome = homedir() +): Promise { + const legacy = claudeStateFile(configDir, userHome, () => true) + return (await stat(legacy).catch(() => null)) + ? legacy + : claudeStateFile(configDir, userHome, () => false) +} + // Cache large, frequently rewritten state files across account-list refreshes. const logins = new Map< string, @@ -96,6 +111,12 @@ export function readClaudeFolderLogin(stateFile: string, maxAgeMs = 0): ClaudeFo return login } +// Concurrent chat reads of one state-file revision share a single read and parse. +const pendingLogins = new Map< + string, + { mtimeMs: number; size: number; login: Promise } +>() + /** Avoid blocking main on state files across WSL shares. */ export async function readClaudeFolderLoginAsync( stateFile: string @@ -103,28 +124,38 @@ export async function readClaudeFolderLoginAsync( const current = await stat(stateFile).catch(() => null) if (!current) { logins.delete(stateFile) + pendingLogins.delete(stateFile) return null } const recent = logins.get(stateFile) if (recent?.mtimeMs === current.mtimeMs && recent.size === current.size) { return recent.login } - let login: ClaudeFolderLogin | null = null + const pending = pendingLogins.get(stateFile) + if (pending?.mtimeMs === current.mtimeMs && pending.size === current.size) { + return pending.login + } + const read = { mtimeMs: current.mtimeMs, size: current.size, login: readStateLogin(stateFile) } + pendingLogins.set(stateFile, read) + const login = await read.login + // A read superseded by a newer revision (or a deleted file) must not repopulate the cache. + if (pendingLogins.get(stateFile) === read) { + pendingLogins.delete(stateFile) + logins.set(stateFile, { mtimeMs: read.mtimeMs, size: read.size, readAt: Date.now(), login }) + } + return login +} + +async function readStateLogin(stateFile: string): Promise { try { const state: unknown = JSON.parse(await readFile(stateFile, 'utf8')) if (state && typeof state === 'object' && !Array.isArray(state)) { - login = claudeStateLogin(Object.fromEntries(Object.entries(state))) + return claudeStateLogin(Object.fromEntries(Object.entries(state))) } } catch { // Treat unreadable state as signed out. } - logins.set(stateFile, { - mtimeMs: current.mtimeMs, - size: current.size, - readAt: Date.now(), - login - }) - return login + return null } /** Removes current profiles only; legacy `claude-accounts/` folders stay untouched. */ diff --git a/src/main/claude-accounts/claude-launch-routing.test.ts b/src/main/claude-accounts/claude-launch-routing.test.ts index dcc12a6bcd5..b428f3af44a 100644 --- a/src/main/claude-accounts/claude-launch-routing.test.ts +++ b/src/main/claude-accounts/claude-launch-routing.test.ts @@ -74,7 +74,7 @@ async function launchHomes(f: ReturnType) { .CLAUDE_CONFIG_DIR, chat: await resolveClaudeStructuredLaunchHome(f.router, chatEnv, '/recorded'), chatEnv: chatEnv.CLAUDE_CONFIG_DIR, - chatRecord: resolveStructuredClaudeAccountHomePath({ + chatRecord: await resolveStructuredClaudeAccountHomePath({ launchEnv: {}, wslDistro: null, getClaudeConfigDirectory: () => f.router.systemDefaultHome() diff --git a/src/main/claude-accounts/claude-profile-routed-home.ts b/src/main/claude-accounts/claude-profile-routed-home.ts new file mode 100644 index 00000000000..6855109f731 --- /dev/null +++ b/src/main/claude-accounts/claude-profile-routed-home.ts @@ -0,0 +1,36 @@ +import { lstat } from 'node:fs/promises' +import type { ClaudeProfileRouter } from './claude-profile-router' +import { + claudeStateFileAsync, + isSameClaudeLogin, + readClaudeFolderLoginAsync +} from './claude-account-folder' +import { claudeProfileMissing } from './claude-profile-launch-errors' + +/** `routedHome` without blocking main: chat reads run once per options read and send. */ +export async function claudeRoutedHomeAsync( + router: Pick< + ClaudeProfileRouter, + 'selectedProfile' | 'savedAccount' | 'userConfigDir' | 'userHome' + >, + availability: 'checked' | 'identity' = 'checked' +): Promise { + const profile = router.selectedProfile() + if (!profile) { + return null + } + const login = (configDir: string | undefined) => + claudeStateFileAsync(configDir, router.userHome).then(readClaudeFolderLoginAsync) + if (!(await login(profile.home))) { + // Reuse a matching System default login until the account signs in separately. + const saved = router.savedAccount(profile.accountId) + const systemDefault = await login(router.userConfigDir()) + if (saved && systemDefault && isSameClaudeLogin(saved, systemDefault)) { + return null + } + } + if (availability === 'checked' && !(await lstat(profile.home).catch(() => null))?.isDirectory()) { + throw claudeProfileMissing() + } + return profile.home +} diff --git a/src/main/claude-accounts/claude-profile-router.test.ts b/src/main/claude-accounts/claude-profile-router.test.ts index 4750520de49..bbcc29d9043 100644 --- a/src/main/claude-accounts/claude-profile-router.test.ts +++ b/src/main/claude-accounts/claude-profile-router.test.ts @@ -36,6 +36,7 @@ import { installClaudeProfileRouter } from './claude-profile-installed-router' import { ClaudeObservedConfigDirs } from './claude-observed-config-dirs' +import { claudeRoutedHomeAsync } from './claude-profile-routed-home' vi.mock('@orca/process-host', () => ({ runProcess: vi.fn() })) const command = vi.hoisted(() => ({ path: '/unused-claude' })) @@ -218,6 +219,7 @@ describe('ClaudeProfileRouter', () => { expect(f.router.terminalEnv()).toEqual({ ORCA_CLAUDE_PROFILE_POINTER: f.router.pointerPath }) expect(f.router.routedHome()).toBeNull() expect(f.router.routedHome('identity')).toBeNull() + await expect(claudeRoutedHomeAsync(f.router)).resolves.toBeNull() expect(readFileSync(f.router.pointerPath, 'utf8')).toBe('') expect(f.router.coveredBySystemDefault('a')).toBe(true) @@ -231,6 +233,7 @@ describe('ClaudeProfileRouter', () => { expect(f.router.coveredBySystemDefault('a')).toBe(false) expect(f.router.routedHome()).toBe(f.home('a')) expect(f.router.routedHome('identity')).toBe(f.home('a')) + await expect(claudeRoutedHomeAsync(f.router)).resolves.toBe(f.home('a')) }) it('tells whether a terminal opened before routing runs another account than the selected one', () => { @@ -425,6 +428,8 @@ describe('ClaudeProfileRouter', () => { expect(() => f.router.preparation()).toThrow(CLAUDE_PROFILE_MISSING_MESSAGE) expect(() => f.router.routedHome()).toThrow(CLAUDE_PROFILE_MISSING_MESSAGE) expect(f.router.routedHome('identity')).toBe(f.home('b')) + await expect(claudeRoutedHomeAsync(f.router)).rejects.toThrow(CLAUDE_PROFILE_MISSING_MESSAGE) + await expect(claudeRoutedHomeAsync(f.router, 'identity')).resolves.toBe(f.home('b')) expect(f.router.terminalEnv()).toEqual({ ORCA_CLAUDE_PROFILE_POINTER: f.router.pointerPath }) f.router.publish() expect(readFileSync(f.router.pointerPath, 'utf8')).toBe(f.home('b')) diff --git a/src/main/claude-accounts/claude-profile-router.ts b/src/main/claude-accounts/claude-profile-router.ts index 57c579dec28..7f591615d73 100644 --- a/src/main/claude-accounts/claude-profile-router.ts +++ b/src/main/claude-accounts/claude-profile-router.ts @@ -14,6 +14,7 @@ import { } from '../../shared/claude-profile-routing' import { claudeProfileMissing } from './claude-profile-launch-errors' import type { GlobalSettings } from '../../shared/global-settings-types' +import type { ClaudeManagedAccount } from '../../shared/managed-account-types' import { probeRecentClaudeCliVersion } from '../claude/claude-hook-event-versions' import { writeFileAtomically } from '../codex-accounts/fs-utils' import { resolveClaudeCommand } from '../codex-cli/command' @@ -88,11 +89,11 @@ export class ClaudeProfileRouter { }) } - private get userHome(): string { + get userHome(): string { return this.args.userHome ?? homedir() } - private selectedProfile(): ClaudeProfileDescriptor | null { + selectedProfile(): ClaudeProfileDescriptor | null { const id = getSelectedClaudeAccountIdForTarget(this.args.getSettings(), { runtime: 'host' }) return id ? this.describe(id) : null } @@ -115,11 +116,15 @@ export class ClaudeProfileRouter { if (this.accountLogin(accountId)) { return false } - const saved = findClaudeAccount(this.args.getSettings(), accountId) + const saved = this.savedAccount(accountId) const systemDefault = this.systemDefaultLogin() return Boolean(saved && systemDefault && isSameClaudeLogin(saved, systemDefault)) } + savedAccount(accountId: string): ClaudeManagedAccount | undefined { + return findClaudeAccount(this.args.getSettings(), accountId) + } + systemDefaultHome(): string { return resolveClaudeDefaultHome(this.userHome, this.userConfigDir()) } @@ -187,17 +192,6 @@ export class ClaudeProfileRouter { return this.preparation() } - /** Prepare an observed receiving route without mutating selection or adopting a System-default alias. */ - async prepareReceivingAccount(accountId: string): Promise { - const profile = this.describe(accountId) - await prepareClaudeProfileForLaunch( - profile, - (value) => this.setUp(value), - this.args.refreshWaitMs - ) - return profile.home - } - accountHome(accountId: string): string { return this.describe(accountId).home } diff --git a/src/main/claude/claude-receiving-account.ts b/src/main/claude/claude-launch-account.ts similarity index 54% rename from src/main/claude/claude-receiving-account.ts rename to src/main/claude/claude-launch-account.ts index a34254b7a26..55d0c060692 100644 --- a/src/main/claude/claude-receiving-account.ts +++ b/src/main/claude/claude-launch-account.ts @@ -1,40 +1,21 @@ -import { CLAUDE_INJECTED_CONFIG_DIR_ENV } from '../../shared/claude-profile-routing' import type { ClaudeAccountRecipe } from '../../shared/agent-session-acquired-account' import type { ClaudeProfileRouter } from '../claude-accounts/claude-profile-router' -import { claudeProfileMissing } from '../claude-accounts/claude-profile-launch-errors' import { applyClaudeEnvPatch } from '../claude-accounts/environment' import { resolveStructuredClaudeAccountHomePath } from '../runtime/structured-agent-account-home' -/** Only actual preparation produces a receipt; selection is never backfilled as acquisition. */ -export async function prepareClaudeReceivingAccount( +/** The account a launch runs under is the current selection; the receipt records what it used. */ +export async function prepareClaudeLaunchAccount( router: ClaudeProfileRouter | undefined, env: Record, - recordHome: string, - receiving?: ClaudeAccountRecipe + recordHome: string ): Promise { - if (receiving?.route === 'managed') { - if (!router) { - throw claudeProfileMissing() - } - const home = await router.prepareReceivingAccount(receiving.accountId) - applyClaudeEnvPatch(env, { CLAUDE_CONFIG_DIR: home, [CLAUDE_INJECTED_CONFIG_DIR_ENV]: home }) - return { ...receiving, home } - } - if (receiving) { - if (receiving.configDir === null) { - delete env.CLAUDE_CONFIG_DIR - } else { - env.CLAUDE_CONFIG_DIR = receiving.configDir - } - return receiving - } if (!router) { return { route: 'system', home: recordHome, configDir: env.CLAUDE_CONFIG_DIR ?? null } } const preparation = await router.prepareLaunch() const home = preparation.provenance === 'system' - ? resolveStructuredClaudeAccountHomePath({ + ? await resolveStructuredClaudeAccountHomePath({ launchEnv: env, wslDistro: null, getClaudeConfigDirectory: () => router.systemDefaultHome() diff --git a/src/main/claude/structured/launch/claude-structured-acquisition-launch.ts b/src/main/claude/structured/launch/claude-structured-acquisition-launch.ts index 252e5bd37c9..59704e4a9dd 100644 --- a/src/main/claude/structured/launch/claude-structured-acquisition-launch.ts +++ b/src/main/claude/structured/launch/claude-structured-acquisition-launch.ts @@ -97,7 +97,6 @@ export async function resolveClaudeAcquisitionLaunch(args: { .resolveLaunch({ identity: launchIdentity, spawnToken: input.spawnToken, - ...(input.accountRecipe ? { accountRecipe: input.accountRecipe } : {}), ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}) }) .catch((error: unknown) => { diff --git a/src/main/claude/structured/launch/claude-structured-launch-account-routing.test.ts b/src/main/claude/structured/launch/claude-structured-launch-account-routing.test.ts index 7073bfa9f8b..08c3d7db08a 100644 --- a/src/main/claude/structured/launch/claude-structured-launch-account-routing.test.ts +++ b/src/main/claude/structured/launch/claude-structured-launch-account-routing.test.ts @@ -60,8 +60,8 @@ it('launches each acquisition under the current selection, not the account it wa }) const home = join(root, 'claude-profiles', 'a', 'home') // Dispatch identity names the selected account before its folder exists; availability reads refuse. - expect(read('identity')).toBe(home) - expect(() => read()).toThrow(CLAUDE_PROFILE_MISSING_MESSAGE) + await expect(read('identity')).resolves.toBe(home) + await expect(read()).rejects.toThrow(CLAUDE_PROFILE_MISSING_MESSAGE) expect(runSetup).not.toHaveBeenCalled() const record = { ...agentSessionRecordFixture(), @@ -95,23 +95,17 @@ it('launches each acquisition under the current selection, not the account it wa writeFileSync(join(root, 'claude-profiles', 'a', 'profile.json'), '{}') const routed = await resolve({ identity }) expect(routed.claudeConfigDir).toBe(home) - expect(read()).toBe(home) - expect(read('identity')).toBe(home) + await expect(read()).resolves.toBe(home) + await expect(read('identity')).resolves.toBe(home) expect(routed.env).toMatchObject({ CLAUDE_CONFIG_DIR: home, ORCA_CLAUDE_INJECTED_CONFIG_DIR: home }) - const receipt = routed.accountRecipe - expect(receipt).toEqual({ route: 'managed', accountId: 'a', home }) + expect(routed.accountRecipe).toEqual({ route: 'managed', accountId: 'a', home }) settings.activeClaudeManagedAccountId = null expect((await resolve({ identity })).claudeConfigDir).toBe(resolvePath('/user/own')) - const prepareAccount = vi.spyOn(router, 'prepareReceivingAccount') - expect((await resolve({ identity, accountRecipe: receipt })).claudeConfigDir).toBe(home) - expect(prepareAccount).toHaveBeenCalledWith('a') - expect(settings.activeClaudeManagedAccountId).toBeNull() - prepareAccount.mockRestore() - expect(read()).toBe(resolvePath('/user/own')) + await expect(read()).resolves.toBe(resolvePath('/user/own')) }) function routedResumeFixture(rewind?: AgentSessionRewindRecord, transcriptFiles = false) { diff --git a/src/main/claude/structured/launch/claude-structured-launch-home.ts b/src/main/claude/structured/launch/claude-structured-launch-home.ts index 29cf4f723c7..4aa5cf596fb 100644 --- a/src/main/claude/structured/launch/claude-structured-launch-home.ts +++ b/src/main/claude/structured/launch/claude-structured-launch-home.ts @@ -2,7 +2,7 @@ import { join } from 'node:path' import type { ClaudeProfileRouter } from '../../../claude-accounts/claude-profile-router' import { AgentSessionPreSpawnError } from '../../../native-chat/agent-session-wire/structured-agent-session-adapter-errors' import { resolveSessionFilePath } from '../../../native-chat/session-file-resolver' -import { prepareClaudeReceivingAccount } from '../../claude-receiving-account' +import { prepareClaudeLaunchAccount } from '../../claude-launch-account' /** Follow the current account selection and pin its environment for this launch. */ export async function resolveClaudeStructuredLaunchHome( @@ -10,7 +10,7 @@ export async function resolveClaudeStructuredLaunchHome( env: Record, recordHome: string ): Promise { - return (await prepareClaudeReceivingAccount(router, env, recordHome)).home + return (await prepareClaudeLaunchAccount(router, env, recordHome)).home } async function claudeTranscriptExists(input: { diff --git a/src/main/claude/structured/launch/claude-structured-launch-resolution.ts b/src/main/claude/structured/launch/claude-structured-launch-resolution.ts index 6b56532b174..55b043f65fd 100644 --- a/src/main/claude/structured/launch/claude-structured-launch-resolution.ts +++ b/src/main/claude/structured/launch/claude-structured-launch-resolution.ts @@ -1,5 +1,5 @@ import type { ClaudeAccountRecipe } from '../../../../shared/agent-session-acquired-account' -import { prepareClaudeReceivingAccount } from '../../claude-receiving-account' +import { prepareClaudeLaunchAccount } from '../../claude-launch-account' import { assertStructuredAgentResolutionCurrent } from '../../../native-chat/structured-agent-command-resolution' import { activeProviderContext } from '../../../../shared/agent-session/agent-session-provider-context' import { getClaudeProfileRouter } from '../../../claude-accounts/claude-profile-installed-router' @@ -233,8 +233,7 @@ export function claudeStructuredLaunchPart( hasTranscript: deps.hasTranscript })) // Fixed homes can be checked before the final account-routing recheck. - const resumedWithoutRouter = - router || basis.accountRecipe ? undefined : await resumes(accountHome.path) + const resumedWithoutRouter = router ? undefined : await resumes(accountHome.path) // Resolve auth after awaited launch preparation; account routing is rechecked below. const { command, prefixArgs, env } = await resolveClaudeStructuredInvocation( envDeps, @@ -250,12 +249,7 @@ export function claudeStructuredLaunchPart( sources, { runtimeOnPath: false } ) - const accountRecipe = await prepareClaudeReceivingAccount( - router, - env, - accountHome.path, - basis.accountRecipe - ) + const accountRecipe = await prepareClaudeLaunchAccount(router, env, accountHome.path) const launchHome = accountRecipe.home const resumesTranscript = resumedWithoutRouter ?? (await resumes(launchHome)) if (fork?.throughEntryId && !resumesTranscript) { diff --git a/src/main/native-chat/agent-model-catalog/agent-model-catalog-prewarm.test.ts b/src/main/native-chat/agent-model-catalog/agent-model-catalog-prewarm.test.ts index 5e10a547459..b78aa0950f9 100644 --- a/src/main/native-chat/agent-model-catalog/agent-model-catalog-prewarm.test.ts +++ b/src/main/native-chat/agent-model-catalog/agent-model-catalog-prewarm.test.ts @@ -471,7 +471,7 @@ describe('one account, one catalog key', () => { const launchAccountHome = async (record: AgentSessionRecord) => HOME( 'CLAUDE_CONFIG_DIR', - resolveStructuredClaudeAccountHomePath({ + await resolveStructuredClaudeAccountHomePath({ launchEnv: {}, wslDistro: record.location.wslDistro, getClaudeConfigDirectory: () => router.systemDefaultHome() diff --git a/src/main/native-chat/agent-session-journal/journal-database-schema.ts b/src/main/native-chat/agent-session-journal/journal-database-schema.ts index 002307b5fe7..371afc556e4 100644 --- a/src/main/native-chat/agent-session-journal/journal-database-schema.ts +++ b/src/main/native-chat/agent-session-journal/journal-database-schema.ts @@ -41,18 +41,12 @@ CREATE TABLE IF NOT EXISTS journal_set_aside ( } // JSON rows preserve unreadable records byte-for-byte. -export const AGENT_SESSION_CLEAR_SUCCESSOR_INDEX_SQL = ` -CREATE INDEX IF NOT EXISTS idx_agent_session_clear_successor - ON agent_session_records(CASE WHEN json_valid(record_json) THEN json_extract(record_json, '$.conversationCommand.replacementSessionId') END); -` - export function createAgentSessionRecordTablesSql(): string { return ` CREATE TABLE IF NOT EXISTS agent_session_records ( session_id TEXT PRIMARY KEY, record_json TEXT NOT NULL ); -${AGENT_SESSION_CLEAR_SUCCESSOR_INDEX_SQL} CREATE TABLE IF NOT EXISTS agent_session_operations ( operation_key TEXT PRIMARY KEY, row_json TEXT NOT NULL diff --git a/src/main/native-chat/agent-session-journal/journal-database.ts b/src/main/native-chat/agent-session-journal/journal-database.ts index 96d75c2f25e..f35089c9a83 100644 --- a/src/main/native-chat/agent-session-journal/journal-database.ts +++ b/src/main/native-chat/agent-session-journal/journal-database.ts @@ -5,7 +5,6 @@ import Database from '../../sqlite/sync-database' import { hardenSqliteDatabaseFiles } from '../../sqlite/harden-database-files' import { createAgentSessionRecordTablesSql, - AGENT_SESSION_CLEAR_SUCCESSOR_INDEX_SQL, createJournalTablesSql, JOURNAL_DB_OLDEST_RELEASED_VERSION, JOURNAL_DB_SCHEMA_VERSION @@ -75,7 +74,8 @@ export function openJournalDatabase(dbPath: string): OpenJournalDatabase { ensureQueuedMessagesTable(probe) ensureCommandReceiptsTable(probe) ensureJournalOutcomeTables(probe) - probe.exec(AGENT_SESSION_CLEAR_SUCCESSOR_INDEX_SQL) + // An earlier build indexed clear successors for a query that no longer exists; writes stop paying for it. + probe.exec('DROP INDEX IF EXISTS idx_agent_session_clear_successor') ensureAgentSessionAttachmentClaimTables(probe) hardenSqliteDatabaseFiles(dbPath) transferred = true diff --git a/src/main/native-chat/agent-session-journal/journal-read-row.ts b/src/main/native-chat/agent-session-journal/journal-read-row.ts index b3f90aa9c8b..7bf5e65608c 100644 --- a/src/main/native-chat/agent-session-journal/journal-read-row.ts +++ b/src/main/native-chat/agent-session-journal/journal-read-row.ts @@ -2,15 +2,13 @@ import type Database from '../../sqlite/sync-database' import type { JournalRow } from './journal-row-schema' import type { JournalOutcomeSource } from './journal-outcome-format' -type JournalOutcomeKeys = { itemIds: string[]; submissionIds: string[]; queueCardIds: string[] } - -/** In-process change index only; the public wire still contains items and submissions. Each array - * names the sequence's touched keys; `deleted` repeats the ones it removed. */ -export type JournalOutcomeReadRow = JournalOutcomeKeys & { +/** In-process change index only; the public wire still contains items and submissions. */ +export type JournalOutcomeReadRow = { kind: 'outcome' epoch: string seq: number - deleted: JournalOutcomeKeys + itemIds: string[] + submissionIds: string[] } export type JournalReadRow = JournalRow | JournalOutcomeReadRow /** `through` is the highest sequence the read covered, which may store no record of its own. */ @@ -28,15 +26,14 @@ export function readJournalOutcomeGroups( .prepare(`SELECT DISTINCT seq FROM journal_outcomes WHERE generation = ? AND seq > ? AND seq <= ? ORDER BY seq LIMIT ?`) .all(source.generation, after, source.through, limit ?? -1) - const touched = db.prepare(`SELECT field, entry_key, deleted FROM journal_outcomes - WHERE generation = ? AND seq = ? AND field IN ('items', 'submissions', 'queue.cards') - ORDER BY field, entry_key`) + const touched = db.prepare(`SELECT field, entry_key FROM journal_outcomes + WHERE generation = ? AND seq = ? AND field IN ('items', 'submissions') ORDER BY field, entry_key`) return groups.map(({ seq }) => { if (typeof seq !== 'number') { throw new Error('invalid journal outcome group') } - const keys = emptyOutcomeKeys() - const deleted = emptyOutcomeKeys() + const itemIds: string[] = [] + const submissionIds: string[] = [] for (const entry of touched.iterate(source.generation, seq)) { if (typeof entry.entry_key !== 'string') { throw new Error('invalid journal outcome key') @@ -45,21 +42,12 @@ export function readJournalOutcomeGroups( if (typeof key !== 'string') { throw new Error('invalid journal public outcome key') } - const field = - entry.field === 'items' - ? 'itemIds' - : entry.field === 'submissions' - ? 'submissionIds' - : 'queueCardIds' - keys[field].push(key) - if (entry.deleted === 1) { - deleted[field].push(key) + if (entry.field === 'items') { + itemIds.push(key) + } else { + submissionIds.push(key) } } - return { kind: 'outcome', epoch, seq, ...keys, deleted } + return { kind: 'outcome', epoch, seq, itemIds, submissionIds } }) } - -function emptyOutcomeKeys(): JournalOutcomeKeys { - return { itemIds: [], submissionIds: [], queueCardIds: [] } -} diff --git a/src/main/native-chat/agent-session-wire/agent-session-history-batches.test.ts b/src/main/native-chat/agent-session-wire/agent-session-history-batches.test.ts index a937de934c9..ab60c271e9c 100644 --- a/src/main/native-chat/agent-session-wire/agent-session-history-batches.test.ts +++ b/src/main/native-chat/agent-session-wire/agent-session-history-batches.test.ts @@ -2,10 +2,7 @@ import { mkdtemp, rm } from 'node:fs/promises' import { tmpdir } from 'node:os' import { join } from 'node:path' import { describe, expect, it } from 'vitest' -import { - agentJournalItemKey, - agentJournalSubmissionKey -} from '../../../shared/agent-session/journal/agent-session-journal-item-key' +import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' import type { AgentJournalItemIdentity } from '../../../shared/agent-session-journal-identity' import { type AgentJournalMessageItem, @@ -119,49 +116,6 @@ describe('projectJournalBatch', () => { } }) - it('names touched card keys and deleted keys per outcome sequence; a Stop mark touches no item', async () => { - const root = await mkdtemp(join(tmpdir(), 'orca-history-outcome-keys-')) - const journal = await outcomeJournals.open({ - identity: IDENTITY, - stateDirectory: root, - now: tick - }) - try { - const queued: AgentJournalMessageItem = { - kind: 'message', - role: 'user', - blocks: [{ type: 'text', text: 'queued' }] - } - await journal.queuedMessages.insert({ messageId: 'card-1', body: queued }) - await journal.appendItem(item(1), body('item-1'), { - fence: 1, - turnScope: AGENT_JOURNAL_THREAD_SCOPE - }) - const cursor = journal.cursor() - await journal.queuedMessages.withdraw(['card-1']) - await journal.appendTombstone(item(1), { fence: 1 }) - await journal.appendStopEvent({ reason: 'user-stop' }, 1) - const since = journal.readSince(cursor) - if (!since.ok) { - throw new Error(`expected rows, got reset ${since.reset}`) - } - const none = { itemIds: [], submissionIds: [], queueCardIds: [] } - expect(since.rows).toEqual([ - expect.objectContaining({ kind: 'outcome', queueCardIds: ['card-1'], deleted: none }), - expect.objectContaining({ - kind: 'outcome', - itemIds: [agentJournalItemKey(item(1))], - deleted: { ...none, itemIds: [agentJournalItemKey(item(1))] } - }), - expect.objectContaining({ kind: 'outcome', itemIds: [], queueCardIds: [], deleted: none }) - ]) - } finally { - await journal.close() - await closeTestJournalHostDatabase(root) - await rm(root, { recursive: true, force: true }) - } - }) - it('publishes touched items at their current reduced state, not as a delta', async () => { await appendItems(1) const cursor = fixture.journal.cursor() diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-account-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-account-recovery.ts deleted file mode 100644 index 8a5f473eedf..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-account-recovery.ts +++ /dev/null @@ -1,116 +0,0 @@ -import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' -import type { - AgentJournalRenderItem, - AgentJournalSubmission -} from '../../../shared/agent-session/journal/agent-session-journal-types' -import { latestNativeChatUsageLimitCut } from '../../../shared/native-chat/native-chat-usage-limit-cut' -import { isAgentSessionContextClear } from '../../../shared/agent-session/agent-session-context-clear' -import { isRootAgentJournalItem } from '../../../shared/agent-session/journal/agent-session-journal-producer' -import { isStructuredAgentSessionCommandTurn } from '../../../shared/agent-session/structured-agent-session-command-entry' -import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record' -import type { AgentSessionJournal } from '../agent-session-journal/journal-store' - -/** Index only the current request window; the canonical cut reader still decides recovery. */ -export class StructuredAccountRecovery { - private readonly groups = new Map>() - private readonly pending = new Map() - private requests: AgentJournalRenderItem[] = [] - private latest: AgentJournalRenderItem | null = null - private building = true - private floor = 0 - - reset(): void { - this.groups.clear() - this.pending.clear() - this.requests = [] - this.latest = null - this.building = true - this.floor = 0 - } - - ready(): void { - this.building = false - for (const key of this.groups.keys()) { - if (key !== this.latest?.itemId) { - this.groups.delete(key) - } - } - } - - submission(submission: AgentJournalSubmission | undefined): void { - if (!submission) { - return - } - if (submission.dispatchState === 'pending') { - this.pending.set(submission.clientMessageId, submission) - } else { - this.pending.delete(submission.clientMessageId) - } - } - - item(journal: AgentSessionJournal, item: AgentJournalRenderItem): void { - if (!isRootAgentJournalItem(item)) { - return - } - if (isAgentSessionContextClear(item.body)) { - if (item.sequence > this.floor) { - this.floor = item.sequence - this.groups.clear() - this.requests = [] - this.latest = null - } - return - } - if (item.sequence <= this.floor) { - return - } - const turn = readAgentJournalTurn(item.body) - if (turn && !isStructuredAgentSessionCommandTurn(turn, journal.itemBody)) { - if (item.sequence >= (this.latest?.sequence ?? 0)) { - if (!this.building && this.latest?.itemId !== item.itemId) { - this.groups.clear() - } - this.latest = item - } - } - const scope = turn - ? item.itemId - : item.turnScope?.kind === 'turn' - ? item.turnScope.turnItemId - : null - if (scope && (this.building || scope === this.latest?.itemId)) { - const group = this.groups.get(scope) ?? new Map() - group.set(item.itemId, item) - this.groups.set(scope, group) - } - if (item.body.kind === 'message' && item.body.role === 'user') { - this.requests = this.requests.filter((entry) => entry.itemId !== item.itemId) - } - if ( - item.body.kind === 'message' && - item.body.role === 'user' && - !item.body.command && - item.turnScope?.kind !== 'turn' - ) { - this.requests = [...this.requests.filter((entry) => entry.itemId !== item.itemId), item] - .sort((a, b) => b.sequence - a.sequence) - .slice(0, 2) - } - } - - allows(journal: AgentSessionJournal, next: AgentJournalSubmission): boolean { - const key = journal.canonicalItemId(agentJournalSubmissionKey(next.clientMessageId)) - const items = [ - ...(this.groups.get(this.latest?.itemId ?? '')?.values() ?? []), - ...this.requests.filter((item) => item.itemId !== key) - ].sort((a, b) => a.sequence - b.sequence) - return ( - latestNativeChatUsageLimitCut( - items, - [...this.pending.values()].filter( - (submission) => submission.clientMessageId !== next.clientMessageId - ) - ) !== null - ) - } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-account-switch-workers.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-account-switch-workers.test.ts new file mode 100644 index 00000000000..5dc10a03e98 --- /dev/null +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-account-switch-workers.test.ts @@ -0,0 +1,252 @@ +import { existsSync, rmSync } from 'node:fs' +import { dirname } from 'node:path' +import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' +import { acquiredAgentSessionAccount } from '../../../shared/agent-session-acquired-account' +import { describe, expect, it, vi } from 'vitest' +import { dispatchReportMailbox } from '../../runtime/orchestration/dispatch-report-mailbox' +import { OrchestrationStructuredMailboxPointerDelivery } from '../../runtime/orchestration/structured-mailbox-pointer-delivery' +import { createStructuredMailboxPointerHost } from '../../runtime/orchestration/structured-mailbox-pointer-host' +import { HOST_TEST_NOW } from './structured-agent-session-host-test-data' +import { + createReceivingCallerFixture, + PARENT, + WORKER +} from './structured-agent-session-receiving-callers.test-support' + +type Fixture = Awaited> +type Worker = Awaited> + +function journal(f: Fixture) { + return f.rig.host.collaboratorsForTests().sessions.get(PARENT)?.journal +} + +function settledState(f: Fixture, id: string) { + const submission = journal(f)?.submission(id) + return submission?.dispatchState === 'pending' ? undefined : submission +} + +/** Production report transaction -> pointer wake -> host start/handover, as a coordinator receives a result. */ +async function reportResult(f: Fixture, worker: Worker) { + const db = f.runtime.getOrchestrationDb() + const mailbox = dispatchReportMailbox(db, worker.dispatch) + await f.report(worker) + expect(f.nudges).toHaveBeenCalledWith(mailbox, 'worker_done') + const pointer = new OrchestrationStructuredMailboxPointerDelivery({ + getDb: () => db, + getMessageWaiters: () => undefined, + resolveStructuredTarget: (handle) => f.runtime.mailTarget(handle), + getCliCommand: () => 'orca-dev', + senderSnapshot: () => ({ name: null, agent: null }), + host: createStructuredMailboxPointerHost() + }) + const unsubscribe = await f.rig.host.subscribe({ + id: 'result-pointer-wake', + sessionId: PARENT, + emit: () => pointer.onJournalActivity(PARENT) + }) + expect(pointer.deliverForHandle(mailbox)).toBe(true) + const notices = () => { + const current = journal(f) + return (current?.submissions() ?? []).filter((submission) => { + const body = current?.itemBody(agentJournalSubmissionKey(submission.clientMessageId)) + return body?.kind === 'message' && body.from?.orchestration?.message === 'mail-notice' + }) + } + return { + unsubscribe, + notices, + /** The worker's result mail, while the coordinator has not been handed it. */ + undelivered: () => + db.getUnreadMessages(mailbox, ['worker_done']).filter((row) => row.delivered_at === null), + settled: async () => { + let settled: ReturnType[number] | undefined + await vi.waitFor(() => { + settled = notices().find((notice) => notice.dispatchState !== 'pending') + expect(settled).toBeDefined() + }) + return settled + } + } +} + +async function coordinatorWithWorker(f: Fixture) { + await f.found() + expect(f.rig.host.childAccountHome(PARENT)).toEqual(f.homeA) + f.runtime.getOrchestrationDb().createRun({ + objective: 'coordinate a worker', + coordinatorHandle: null, + coordinatorPaneKey: null, + coordinatorOrcaSessionId: PARENT + }) + return f.createWorker(WORKER) +} + +describe('a coordinator chat whose worker is still running when the account is switched', () => { + it('answers the worker result on the new account when it arrives first, and keeps that agent for the next message', async () => { + vi.spyOn(Date, 'now').mockReturnValue(HOST_TEST_NOW) + const f = await createReceivingCallerFixture() + try { + const worker = await coordinatorWithWorker(f) + f.selectB() + f.rig.adapter.acquire.mockClear() + + // Nothing has replaced the agent on A when the result arrives. + const result = await reportResult(f, worker) + try { + expect((await result.settled())?.dispatchState).toBe('accepted') + } finally { + result.unsubscribe() + } + expect(f.rig.adapter.closeSession).toHaveBeenCalledWith(PARENT, undefined) + expect(f.rig.host.childAccountHome(PARENT)).toEqual(f.homeB) + expect(f.launches.at(-1)).toBe(f.homeB.path) + expect(f.rig.adapter.acquire).toHaveBeenCalledTimes(1) + expect(result.undelivered()).toEqual([]) + + await f.send('keep going') + expect(f.rig.host.childAccountHome(PARENT)).toEqual(f.homeB) + expect(f.rig.adapter.acquire).toHaveBeenCalledTimes(1) + } finally { + await f.dispose() + } + }) + + it('answers a result that arrives after its process ended on the new account, not the one it last ran on', async () => { + vi.spyOn(Date, 'now').mockReturnValue(HOST_TEST_NOW) + const f = await createReceivingCallerFixture() + try { + const worker = await coordinatorWithWorker(f) + // A cold start reads only saved state, as it does after a restart. + await f.rig.host.close(PARENT, 'evict') + expect( + acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe + ).toMatchObject({ route: 'managed', accountId: 'a', home: f.homeA.path }) + f.selectB() + f.rig.adapter.acquire.mockClear() + + const result = await reportResult(f, worker) + try { + expect((await result.settled())?.dispatchState).toBe('accepted') + } finally { + result.unsubscribe() + } + expect(f.launches.at(-1)).toBe(f.homeB.path) + expect(f.rig.host.childAccountHome(PARENT)).toEqual(f.homeB) + expect(f.rig.adapter.acquire).toHaveBeenCalledTimes(1) + expect( + acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe + ).toMatchObject({ route: 'managed', accountId: 'b', home: f.homeB.path }) + } finally { + await f.dispose() + } + }) +}) + +describe('a worker result launches a resting coordinator exactly as a message from the user does', () => { + const cases: { + name: string + arrange: (f: Fixture) => void + /** The folder the Claude process starts under; none when launch refuses first. */ + home: (f: Fixture) => string | undefined + outcome: { dispatchState: 'accepted' } | { dispatchState: 'rejected'; rejection: string } + /** Brings back a refused result: a later message from the user that runs. */ + recover?: (f: Fixture) => void + }[] = [ + { + name: 'the account it ran on was removed', + arrange: (f) => { + f.selectB() + f.removeAccount('a') + rmSync(dirname(f.homeA.path), { recursive: true, force: true }) + }, + home: (f) => f.homeB.path, + outcome: { dispatchState: 'accepted' } + }, + { + name: 'the selected account is signed out', + arrange: (f) => { + f.selectB() + f.signedOut.add(f.homeB.path) + }, + home: (f) => f.homeB.path, + outcome: { dispatchState: 'rejected', rejection: 'notSignedIn' } + }, + { + name: 'its history is only under the account it ran on', + arrange: (f) => { + f.selectB() + f.transcripts.add(f.homeA.path) + }, + // Under A it would resume; the refusal is what launching under B finds. + home: () => undefined, + outcome: { dispatchState: 'rejected', rejection: 'historyInOtherAccount' }, + recover: (f) => f.select('a') + }, + { + name: 'System default is selected', + arrange: (f) => f.select(null), + home: (f) => f.systemHome.path, + outcome: { dispatchState: 'accepted' } + } + ] + + it.each(cases)('$name', async ({ arrange, home, outcome, recover }) => { + let clock = HOST_TEST_NOW + vi.spyOn(Date, 'now').mockImplementation(() => clock) + const outcomes: unknown[] = [] + for (const path of ['user message', 'worker result'] as const) { + const f = await createReceivingCallerFixture() + try { + const worker = await coordinatorWithWorker(f) + await f.rig.host.close(PARENT, 'evict') + arrange(f) + f.launches.length = 0 + + if (path === 'user message') { + const id = await f.accept('continue') + await vi.waitFor(() => expect(settledState(f, id)).toBeDefined()) + expect(f.launches.at(-1)).toBe(home(f)) + expect(existsSync(f.homeA.path)).toBe(f.accounts().includes('a')) + outcomes.push(settledState(f, id)) + continue + } + const result = await reportResult(f, worker) + try { + outcomes.push(await result.settled()) + expect(f.launches.at(-1)).toBe(home(f)) + expect(existsSync(f.homeA.path)).toBe(f.accounts().includes('a')) + if (outcome.dispatchState === 'accepted') { + expect(result.undelivered()).toEqual([]) + continue + } + // A refused result is never marked handed over; it stays owed to the coordinator. + expect(result.undelivered()).toHaveLength(1) + if (recover) { + recover(f) + expect(result.undelivered()).toHaveLength(1) + // The user's message comes after the refused result. + f.rig.clock.now += 1_000 + clock += 1_000 + await f.turn(await f.send('back on a'), 'completed') + await vi.waitFor(() => + expect(result.notices().filter((n) => n.dispatchState === 'accepted')).toHaveLength(1) + ) + await vi.waitFor(() => expect(result.undelivered()).toEqual([])) + expect(f.rig.host.childAccountHome(PARENT)).toEqual(f.homeA) + } + } finally { + result.unsubscribe() + } + } finally { + await f.dispose() + } + } + const expected = { + dispatchState: outcome.dispatchState, + ...(outcome.dispatchState === 'rejected' + ? { rejection: expect.objectContaining({ kind: outcome.rejection }) } + : {}) + } + expect(outcomes).toEqual([expect.objectContaining(expected), expect.objectContaining(expected)]) + }) +}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts index a1215753754..f31f549aead 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts @@ -45,7 +45,6 @@ export async function acquireOwner( throw new AgentSessionPreSpawnError(error) } const permissionMode = await input.launchPermissionMode?.(record) - const accountRecipe = await input.launchAccountRecipe?.(record) try { await input.assertNoTerminalWriter?.(record) } catch (error) { @@ -65,7 +64,6 @@ export async function acquireOwner( // Retry the existing reservation instead of spawning a second child. spawnToken, ...(permissionMode ? { permissionMode } : {}), - ...(accountRecipe ? { accountRecipe } : {}), ...(input.eventSink ? { events: input.eventSink } : {}), ...(input.acquireSignal ? { signal: input.acquireSignal } : {}), ...(input.startupOptions ? { startupOptions: input.startupOptions } : {}), diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-account.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-account.ts deleted file mode 100644 index e0d0760970e..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-account.ts +++ /dev/null @@ -1,28 +0,0 @@ -import type { AttachFlowInput } from './structured-agent-session-attach-flow' -import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context' -import type { StructuredAgentSessionAttachLock } from './structured-agent-session-attach-lock' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' - -export function structuredAgentSessionAttachAccount( - context: StructuredAgentSessionAttachContext, - startedFor: string | undefined, - lock: StructuredAgentSessionAttachLock -): NonNullable { - return async (record) => { - const { account } = await lock.commit(async () => { - const current = context.deps.store.requireWritableRecord(record.sessionId) - const session = context.sessions.get(record.sessionId) - const next = startedFor ? session?.journal.submission(startedFor) : undefined - return { - account: structuredAgentSessionReceivingAccount( - context.deps, - current, - session, - next, - 'identity' - ) - } - }) - return (await lock.wait(account)).recipe - } -} 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 96d7172de75..c5a0a252f03 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 @@ -1,4 +1,3 @@ -import type { ClaudeAccountRecipe } from '../../../shared/agent-session-acquired-account' import { refuse } from '../../../shared/agent-session/failures/agent-session-wire-refusals' import { settlePostAcquisitionAttachFailure, @@ -81,7 +80,6 @@ export type AttachFlowInput = { attempt: StructuredAgentSessionStartupAttempt ) => StructuredAgentSessionStartupProgress startupOptions?: Readonly> - launchAccountRecipe?: (record: AgentSessionRecord) => Promise launchPermissionMode?: ( record: AgentSessionRecord ) => Promise diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts index a9e870ab698..be37cceb568 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts @@ -1,5 +1,4 @@ import { prepareStructuredAgentSessionAttach } from './structured-agent-session-attach-preparation' -import { structuredAgentSessionAttachAccount } from './structured-agent-session-attach-account' import { publishAttachedChild, readBoundChildRewind, @@ -207,7 +206,6 @@ async function runAttachUnderAbort( }, ...(options.startupOptions ? { startupOptions: options.startupOptions } : {}), launchPermissionMode: structuredAgentSessionAttachPermission(context, options, lock), - launchAccountRecipe: structuredAgentSessionAttachAccount(context, options.startedFor, lock), assertNoTerminalWriter: async (record) => { await lock.wait(Promise.resolve(context.deps.assertNoTerminalWriter?.(record))) }, diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-catalog-reads.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-catalog-reads.ts index 2d6f4af12bd..5b113fd5a31 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-catalog-reads.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-catalog-reads.ts @@ -6,7 +6,6 @@ import type { StructuredAgentSessionHostDeps, StructuredAgentSessionHostSession } from './structured-agent-session-host-types' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' /** The caller already owns the conversation; every projection of this invocation shares this scope. */ export function structuredAgentSessionCatalogScopeOwned( @@ -20,8 +19,7 @@ export function structuredAgentSessionCatalogScopeOwned( getRecord: (id) => deps.store.getRecord(id) ?? undefined, drivesRecord: () => true, liveAccountHome: () => session?.child?.accountHome, - launchAccountHome: async (record) => - (await structuredAgentSessionReceivingAccount(deps, record, session)).home + launchAccountHome: async (record) => (await deps.launchAccountHome?.(record)) ?? null }, params ) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-claude-account-routing.test-support.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-account-routing.test-support.ts new file mode 100644 index 00000000000..2c318b4c1a3 --- /dev/null +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-account-routing.test-support.ts @@ -0,0 +1,127 @@ +import { mkdirSync, writeFileSync } from 'node:fs' +import { join } from 'node:path' +import { agentSessionAccountHome } from '../../../shared/agent-session/lifecycle/agent-session-account-home' +import type { AgentSessionJournalIdentity } from '../../../shared/agent-session-journal-identity' +import { + ClaudeProfileRouter, + type ClaudeProfileRouterSettings +} from '../../claude-accounts/claude-profile-router' +import { installClaudeProfileRouter } from '../../claude-accounts/claude-profile-installed-router' +import { claudeProfileMarkerPath } from '../../claude-accounts/claude-profile-paths' +import { CLAUDE_STRUCTURED_AGENT } from '../../claude/structured/claude-structured-agent-definition' +import { claudeInitializationAuthError } from '../../claude/structured/claude-structured-init-proof' +import type { AgentSessionRecordStore } from '../../runtime/agent-session/records/agent-session-record-store' +import { resolveStructuredClaudeAccountHomePath } from '../../runtime/structured-agent-account-home' +import { createClaudeStructuredLaunchResolver } from '../../runtime/structured-agent-launch-composition.test-support' +import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types' + +const savedAccount = (id: string) => ({ + id, + email: `${id}@example.test`, + authMethod: 'subscription-oauth' as const, + managedAuthPath: '/unused', + createdAt: 0, + updatedAt: 0, + lastAuthenticatedAt: 0 +}) + +const home = (path: string) => agentSessionAccountHome(CLAUDE_STRUCTURED_AGENT, path) + +/** The real Claude account router, desired-home read and launch resolution, with accounts a and b + * saved and a selected; only what the Claude CLI finds in a folder is scripted. */ +export function createClaudeAccountRouting() { + let router: ClaudeProfileRouter | undefined + const settings: ClaudeProfileRouterSettings = { + claudeManagedAccounts: [savedAccount('a'), savedAccount('b')], + activeClaudeManagedAccountId: 'a', + activeClaudeManagedAccountIdsByRuntime: undefined, + agentStatusHooksEnabled: false, + disabledTuiAgents: [] + } + // The production resolver hop: only dispatch identity skips the availability check. + const launchAccountHome: NonNullable< + StructuredAgentSessionHostDeps['launchAccountHome'] + > = async (_record, purpose) => + home( + await resolveStructuredClaudeAccountHomePath({ + launchEnv: {}, + wslDistro: null, + ...(purpose === 'identity' ? { purpose } : {}), + getClaudeConfigDirectory: () => router?.systemDefaultHome() ?? '' + }) + ) + + const install = ( + root: string, + store: () => Pick + ) => { + const installed = new ClaudeProfileRouter({ + getSettings: () => settings, + dataRoot: root, + userHome: join(root, 'personal'), + env: {}, + runSetup: async ({ profile }) => { + mkdirSync(profile.home, { recursive: true }) + writeFileSync(claudeProfileMarkerPath(profile), '{}') + return { outcome: 'prepared', warnings: [], surfaces: {} } + } + }) + router = installed + installClaudeProfileRouter(installed) + const homeA = home(installed.accountHome('a')) + const homeB = home(installed.accountHome('b')) + const systemHome = home(installed.systemDefaultHome()) + for (const { path } of [homeA, homeB, systemHome]) { + mkdirSync(path, { recursive: true }) + } + // What the scripted Claude CLI finds in each folder it is launched under. + const signedOut = new Set() + const transcripts = new Set() + const launches: string[] = [] + const resolveLaunch = createClaudeStructuredLaunchResolver({ + store: { + getRecord: (id) => store().getRecord(id), + pinLaunchDirectory: (id, directory) => store().pinLaunchDirectory(id, directory) + }, + resolveLaunchArgs: () => [], + resolveCommand: () => ({ command: '/usr/local/bin/claude', prefixArgs: [] }), + resolveInheritedEnv: async () => ({ PATH: '/usr/bin' }), + resolveAuthPolicy: () => ({ account: 'system' }), + hasTranscript: async ({ claudeConfigDir }) => transcripts.has(claudeConfigDir) + }) + return { + homeA, + homeB, + systemHome, + signedOut, + transcripts, + /** The folder each started Claude process ran under, in order. */ + launches, + /** Resolve the launch as the Claude adapter's acquisition does, then start the scripted CLI. */ + launch: async (input: { identity: AgentSessionJournalIdentity; spawnToken: string }) => { + const launch = await resolveLaunch(input) + launches.push(launch.claudeConfigDir) + if (signedOut.has(launch.claudeConfigDir)) { + // The init frame a signed-out Claude CLI reports. + throw claudeInitializationAuthError({ account: { tokenSource: 'none' } }, launch.account) + } + return { + accountHome: home(launch.claudeConfigDir), + ...(launch.accountRecipe ? { accountRecipe: launch.accountRecipe } : {}) + } + }, + /** Switch the selected Claude account; null is System default. */ + select: (account: 'a' | 'b' | null) => { + settings.activeClaudeManagedAccountId = account + }, + accounts: () => settings.claudeManagedAccounts.map((account) => account.id), + removeAccount: (account: 'a' | 'b') => { + settings.claudeManagedAccounts = settings.claudeManagedAccounts.filter( + (saved) => saved.id !== account + ) + }, + uninstall: () => installClaudeProfileRouter(undefined) + } + } + return { launchAccountHome, install } +} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-reads.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-reads.ts index 99a3caae87d..e4d1477480b 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-reads.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-conversation-reads.ts @@ -6,13 +6,10 @@ import { revealStructuredAgentSession } from './structured-agent-session-reveal' import type { StructuredAgentSessionClientDelivery } from './structured-agent-session-client-delivery' import type { AgentSessionExecutionLocation } from '../../../shared/agent-session/lifecycle/agent-session-record' import * as providerSupport from './structured-agent-session-provider-support' -import type { OpenedStructuredAgentSessionConversation } from './structured-agent-session-conversation-open' import type { StructuredAgentSessionHostDeps, StructuredAgentSessionHostSession } from './structured-agent-session-host-types' -import { restoreStructuredAgentSessionRead } from './structured-agent-session-read-restore' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' type ReadContext = { deps: StructuredAgentSessionHostDeps @@ -20,32 +17,10 @@ type ReadContext = { serialize: (id: string, task: () => Promise) => Promise readCommands: StructuredAgentSessionClientDelivery['readCommandsSettled'] conversation: (id: string) => Promise - adoptOpened: (id: string, opened: OpenedStructuredAgentSessionConversation) => Promise } /** Readers share the conversation owner; inventory never founds a journal or prepares a provider. */ export function createStructuredAgentSessionConversationReads(context: () => ReadContext) { - const sessionOwned = async (id: string, current: () => boolean = () => true) => { - const { deps, sessions, adoptOpened } = context() - const record = deps.store.requireWritableRecord(id) - let session = sessions.get(id) - if (!session) { - const opened = await restoreStructuredAgentSessionRead(deps, id) - if (opened) { - if (current()) { - await adoptOpened(id, opened) - session = opened.session - } else { - await opened.session.journal.close() - } - } - } - return { record, session } - } - const prospectiveAccountHomeOwned = async (id: string) => { - const { record, session } = await sessionOwned(id) - return (await structuredAgentSessionReceivingAccount(context().deps, record, session)).home - } const readModelCatalog = createStructuredAgentSessionCatalogReads(() => ({ deps: context().deps, serialize: context().serialize, @@ -66,11 +41,11 @@ export function createStructuredAgentSessionConversationReads(context: () => Rea if (!context().deps.store.getRecord(record.sessionId)) { return structuredAgentSessionCatalogScopeOwned(context().deps, params, undefined) } - const { session } = await sessionOwned(record.sessionId, params.operation?.current) - if (params.operation?.current() === false) { - return null - } - return structuredAgentSessionCatalogScopeOwned(context().deps, params, session) + return structuredAgentSessionCatalogScopeOwned( + context().deps, + params, + context().sessions.get(record.sessionId) + ) } })) return { @@ -90,7 +65,11 @@ export function createStructuredAgentSessionConversationReads(context: () => Rea holdsSessions: () => context().deps.store.holdsRecords(), onSessionsHeld: (listener: () => void) => context().deps.store.onFirstRecord(listener), prospectiveAccountHome: (id: string) => { - return context().serialize(id, () => prospectiveAccountHomeOwned(id)) + const { deps, serialize } = context() + return serialize( + id, + async () => (await deps.launchAccountHome?.(deps.store.requireWritableRecord(id))) ?? null + ) } } } diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts index 22be534ebbc..0805b0cf531 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-delivery.ts @@ -1,5 +1,4 @@ import { selectableStructuredSubmission } from './structured-agent-session-input-selection' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' // Open conversations with queued sends always need delivery; opening also wakes leftover recovery. import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session/requests/agent-session-queued-submission' @@ -140,17 +139,7 @@ export function createStructuredAgentSessionConversationDelivery(input: { }, launchAccountHome: async () => { const record = deps.store.getRecord(sessionId) - return record - ? ( - await structuredAgentSessionReceivingAccount( - deps, - record, - session, - next, - 'identity' - ) - ).home - : null + return record ? ((await deps.launchAccountHome?.(record, 'identity')) ?? null) : null }, logger: deps.logger }) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts index 7dff368de4f..45fb326eff4 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts @@ -1,5 +1,3 @@ -import type { AgentSessionRecordReader } from '../../runtime/orchestration/structured-session-lineage' -import type { NativeResponseEvidence } from '../../runtime/orchestration/structured-parent-account-work' import type { AgentModelCatalogSource } from '../agent-model-catalog/agent-model-catalog-service-contract' import type { StructuredAgentSessionDeliveryLoop } from './structured-agent-session-delivery-loop' import type { @@ -206,12 +204,6 @@ export type StructuredAgentSessionHostDeps = { record: AgentSessionRecord, purpose?: 'read' | 'identity' ) => Promise - parentAccountWork?: ( - record: AgentSessionRecord, - root: string, - response: NativeResponseEvidence, - reader: AgentSessionRecordReader - ) => boolean conversationNaming?: StructuredAgentSessionConversationNaming /** Carries the user's chat name into the agent's own conversation; never delays the caller. */ nameProviderConversation?: (record: AgentSessionRecord) => void diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts index fc979e947e0..b9de7275ef2 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts @@ -148,8 +148,7 @@ export class StructuredAgentSessionHost { serialize: this.serialize, readCommands: (id, commandsOnRequest) => this.clientDelivery.readCommandsSettled(id, commandsOnRequest), - conversation: (id) => this.lifetime.conversation(id), - adoptOpened: this.conversationDelivery.adoptOpened + conversation: (id) => this.lifetime.conversation(id) })) sessionAgent = this.reads.sessionAgent readModelCatalog = this.reads.readModelCatalog diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-native-responses.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-native-responses.ts deleted file mode 100644 index b3984397259..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-native-responses.ts +++ /dev/null @@ -1,317 +0,0 @@ -import { isQueuedAgentJournalSubmission } from '../../../shared/agent-session/requests/agent-session-queued-submission' -import { - isJournalStopOrResumeRow, - type JournalRow -} from '../agent-session-journal/journal-row-schema' -import { isAgentSessionContextClear } from '../../../shared/agent-session/agent-session-context-clear' -import { StructuredQueuedNativeResponses } from './structured-agent-session-queued-native-responses' -import { StructuredAccountRecovery } from './structured-agent-session-account-recovery' -import { readWholeAgentSessionFailureFact } from '../../../shared/agent-session/failures/agent-session-failure' -import { - agentJournalSubmissionKey, - parseAgentJournalItemKey -} from '../../../shared/agent-session/journal/agent-session-journal-item-key' -import { isRootAgentJournalItem } from '../../../shared/agent-session/journal/agent-session-journal-producer' -import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record' -import type { AgentJournalCursor } from '../../../shared/agent-session-journal-identity' -import type { - AgentJournalItemBody, - AgentJournalRenderItem -} from '../../../shared/agent-session/journal/agent-session-journal-types' -import type { AgentSessionJournal } from '../agent-session-journal/journal-store' -import type { - JournalOutcomeReadRow, - JournalReadRow -} from '../agent-session-journal/journal-read-row' - -type Notice = { fence: number; clientMessageId: string; mailbox: string; messages: string[] } - -/** Replayable projection, not a saved obligation: initial history once, then changed row keys only. */ -export class StructuredNativeResponses { - readonly recovery = new StructuredAccountRecovery() - private readonly queued = new StructuredQueuedNativeResponses() - private readonly signedOutFences = new Set() - private cursor: AgentJournalCursor | null = null - private executionFence: number | undefined - private readonly submissionKeys = new Map() - private readonly notices = new Map() - private readonly turns = new Map>() - private readonly resolved = new Set() - private readonly pending = new Set() - private readonly noticesByUser = new Map>() - - read( - journal: AgentSessionJournal, - executionFence?: number - ): { - pending: Iterable - disposed: ReadonlySet - } { - const next = journal.cursor() - const fenceChanged = this.executionFence !== executionFence - if ( - !fenceChanged && - this.cursor?.epoch === next.epoch && - this.cursor.sequence === next.sequence - ) { - return this.result() - } - const changes = this.cursor ? journal.readSince(this.cursor) : null - if (!changes?.ok) { - this.recovery.reset() - this.signedOutFences.clear() - this.submissionKeys.clear() - this.notices.clear() - this.turns.clear() - this.resolved.clear() - this.pending.clear() - this.noticesByUser.clear() - for (const submission of journal.submissions()) { - this.observeSubmission(journal, submission.clientMessageId) - } - journal.visitItemsWithLinkage((id, _sequence, body, item) => - this.observe(journal, id, body, item) - ) - this.queued.reset(journal) - } else { - for (const row of changes.rows) { - if (row.kind === 'outcome') { - this.changedOutcome(journal, row) - } else { - this.changed(journal, row) - } - } - if (changes.rows.some(rewritesHistory)) { - this.recovery.reset() - for (const submission of journal.submissions()) { - this.recovery.submission(submission) - } - journal.visitItemsWithLinkage((id) => { - const item = journal.item(id) - if (item) { - this.recovery.item(journal, item) - } - }) - } - } - if (executionFence !== undefined && (fenceChanged || !changes?.ok)) { - this.disposeEndedExecution(journal, executionFence) - } - this.executionFence = executionFence - this.recovery.ready() - this.cursor = changes?.ok ? { epoch: next.epoch, sequence: changes.through } : next - return this.result() - } - - private changed(journal: AgentSessionJournal, row: JournalRow): void { - this.queued.changed(journal, row) - if (row.kind === 'submission' || row.kind === 'dispatch') { - this.observeSubmission(journal, row.clientMessageId) - } else if (row.kind === 'item' || row.kind === 'tombstone') { - if (row.kind === 'tombstone' && row.retireSubmission) { - const identity = parseAgentJournalItemKey(row.itemId) - if (identity?.provider === 'orca') { - this.disposeNotice(identity.clientMessageId) - } - } - this.observeKey(journal, row.itemId) - } else if (row.kind === 'lifecycle-batch') { - for (const mutation of row.mutations) { - this.observeKey(journal, mutation.itemId) - } - } - } - - /** An outcome sequence names touched keys; each is re-read at its current value, as typed rows were. */ - private changedOutcome(journal: AgentSessionJournal, row: JournalOutcomeReadRow): void { - for (const id of row.queueCardIds) { - this.queued.changedCard(journal, id) - } - for (const clientMessageId of row.submissionIds) { - // Only a rewind retiring an Orca send deletes a submission: the typed tombstone's retireSubmission. - if (row.deleted.submissionIds.includes(clientMessageId)) { - this.disposeNotice(clientMessageId) - } else { - this.observeSubmission(journal, clientMessageId) - } - } - for (const itemId of row.itemIds) { - this.observeKey(journal, itemId) - } - } - - private observeKey(journal: AgentSessionJournal, key: string): void { - const item = journal.item(journal.canonicalItemId(key)) - if (item) { - const clientMessageId = this.submissionKeys.get(journal.canonicalItemId(key)) - if (clientMessageId) { - this.observeSubmission(journal, clientMessageId) - } - this.observe(journal, key, item.body, item) - } - } - - private observe( - journal: AgentSessionJournal, - key: string, - body: AgentJournalItemBody, - item: Pick - ): void { - if (!isRootAgentJournalItem(item)) { - return - } - const rendered = journal.item(journal.canonicalItemId(key)) - if (rendered) { - this.recovery.item(journal, rendered) - } - if ( - body.kind === 'status' && - readWholeAgentSessionFailureFact(body.failure)?.kind === 'notSignedIn' - ) { - const fence = journal.itemFence(key) - if (fence !== undefined) { - this.signedOutFences.add(fence) - } - } - if (isAgentSessionContextClear(body) && body.kind === 'status' && body.contextClear) { - for (const notice of this.notices.values()) { - if (notice.fence <= body.contextClear.afterFence) { - for (const message of notice.messages) { - this.resolved.add(message) - this.pending.delete(message) - } - this.notices.delete(notice.clientMessageId) - } - } - } - const source = body.kind === 'message' ? body.from?.orchestration : undefined - if (source?.message === 'mail-notice') { - const clientMessageId = this.submissionKeys.get(journal.canonicalItemId(key)) - if (clientMessageId) { - this.notices.set(clientMessageId, { - clientMessageId, - fence: identityFence(journal, clientMessageId), - mailbox: source.mailbox, - messages: source.messages.map((message) => message.messageId) - }) - this.observeSubmission(journal, clientMessageId) - } - } - const turn = readAgentJournalTurn(body) - if (turn?.userItemId) { - const user = journal.canonicalItemId(turn.userItemId) - const keys = this.turns.get(user) ?? new Set() - keys.add(key) - this.turns.set(user, keys) - for (const clientMessageId of this.noticesByUser.get(user) ?? []) { - this.observeSubmission(journal, clientMessageId) - } - } - } - - private observeSubmission(journal: AgentSessionJournal, clientMessageId: string): void { - const submission = journal.submission(clientMessageId) - this.recovery.submission(submission) - const rendered = journal.item( - journal.canonicalItemId(agentJournalSubmissionKey(clientMessageId)) - ) - if (rendered) { - this.recovery.item(journal, rendered) - } - if ( - submission?.dispatchState === 'rejected' && - readWholeAgentSessionFailureFact(submission.rejection)?.kind === 'notSignedIn' - ) { - this.signedOutFences.add(submission.fence) - } - this.submissionKeys.set( - journal.canonicalItemId(agentJournalSubmissionKey(clientMessageId)), - clientMessageId - ) - const body = journal.itemBody(agentJournalSubmissionKey(clientMessageId)) - const source = body?.kind === 'message' ? body.from?.orchestration : undefined - if (source?.message === 'mail-notice' && !this.notices.has(clientMessageId)) { - this.notices.set(clientMessageId, { - clientMessageId, - fence: identityFence(journal, clientMessageId), - mailbox: source.mailbox, - messages: source.messages.map((message) => message.messageId) - }) - } - const notice = this.notices.get(clientMessageId) - if (!notice || !submission) { - return - } - const user = journal.canonicalItemId(agentJournalSubmissionKey(clientMessageId)) - const clients = this.noticesByUser.get(user) ?? new Set() - clients.add(clientMessageId) - this.noticesByUser.set(user, clients) - for (const message of notice.messages) { - if (!this.resolved.has(message)) { - this.pending.add(message) - } - } - const terminal = [...(this.turns.get(user) ?? [])].some((key) => { - const turn = readAgentJournalTurn(journal.itemBody(key) ?? undefined) - // Ending this exact turn disposes its account ownership, without claiming unknown/failed output succeeded. - return turn !== null && turn.state !== 'running' - }) - if ( - terminal || - submission.dispatchState === 'rejected' || - (submission.dispatchState === 'unknown' && submission.recovered === true) - ) { - for (const message of notice.messages) { - this.resolved.add(message) - this.pending.delete(message) - } - clients.delete(clientMessageId) - this.notices.delete(clientMessageId) - } - } - - /** Ended generations keep main's handed-over/no-reply disposition; unhanded input still owns a future response. */ - private disposeEndedExecution(journal: AgentSessionJournal, fence: number): void { - for (const notice of this.notices.values()) { - const submission = journal.submission(notice.clientMessageId) - if (submission && submission.fence !== fence && !isQueuedAgentJournalSubmission(submission)) { - this.disposeNotice(notice.clientMessageId) - } - } - } - - private disposeNotice(clientMessageId: string): void { - const notice = this.notices.get(clientMessageId) - for (const message of notice?.messages ?? []) { - this.resolved.add(message) - this.pending.delete(message) - } - this.notices.delete(clientMessageId) - } - - signedOut(fence: number): boolean { - return this.signedOutFences.has(fence) - } - - private result() { - return { - pending: this.queued.pendingWith(this.pending, this.resolved), - disposed: this.resolved - } - } -} - -function identityFence(journal: AgentSessionJournal, clientMessageId: string): number { - return journal.submission(clientMessageId)?.fence ?? 0 -} - -/** Provider history was rewritten: a tombstone outside Stop/resume marks, or an outcome sequence that deleted an item. */ -function rewritesHistory(row: JournalReadRow): boolean { - if (row.kind === 'outcome') { - return row.deleted.itemIds.length > 0 - } - return ( - (row.kind === 'tombstone' && !isJournalStopOrResumeRow(row)) || - (row.kind === 'lifecycle-batch' && row.mutations.some((item) => item.kind === 'tombstone')) - ) -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-outgrown-child.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-outgrown-child.test.ts index 28167fe2171..7ad204541c2 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-outgrown-child.test.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-outgrown-child.test.ts @@ -1,7 +1,6 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs' import { tmpdir } from 'node:os' import { dirname, join } from 'node:path' -import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' import { acquiredAgentSessionAccount } from '../../../shared/agent-session-acquired-account' import { agentSessionAccountHome, @@ -14,11 +13,9 @@ import { type ClaudeProfileRouterSettings } from '../../claude-accounts/claude-profile-router' import type { ClaudeProfileSetupReport } from '../../claude-accounts/claude-profile-setup' -import { prepareClaudeReceivingAccount } from '../../claude/claude-receiving-account' +import { prepareClaudeLaunchAccount } from '../../claude/claude-launch-account' import { CLAUDE_STRUCTURED_AGENT } from '../../claude/structured/claude-structured-agent-definition' import { resolveStructuredClaudeAccountHomePath } from '../../runtime/structured-agent-account-home' -import { createReceivingAccountFixture } from './structured-agent-session-receiving-account.test-support' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import { agentSessionFailureFact } from '../../../shared/agent-session/failures/agent-session-failure' import { agentSessionFailureWords } from '../../../shared/agent-session/failures/agent-session-failure-words' @@ -34,7 +31,6 @@ import { type RestTestRig } from './structured-agent-session-rest-test-rig' import { hostTestAttachParams } from './structured-agent-session-host-test-data' -import { retireOutgrownStructuredAgentSessionChild } from './structured-agent-session-outgrown-child' const accountHome = (path: string): LegacyAgentSessionAccountHome => ({ variable: 'CODEX_HOME', @@ -131,7 +127,7 @@ describe('a send while the selected account folder is not set up yet', () => { launchAccountHome: async (_record, purpose) => agentSessionAccountHome( CLAUDE_STRUCTURED_AGENT, - resolveStructuredClaudeAccountHomePath({ + await resolveStructuredClaudeAccountHomePath({ launchEnv: {}, wslDistro: null, ...(purpose === 'identity' ? { purpose } : {}), @@ -145,7 +141,7 @@ describe('a send while the selected account folder is not set up yet', () => { } rig.adapter.acquire.mockImplementation(async (input) => { // The real router prepares the selected account, joining or failing its setup, as a launch does. - const recipe = await prepareClaudeReceivingAccount(router, {}, home('a'), input.accountRecipe) + const recipe = await prepareClaudeLaunchAccount(router, {}, home('a')) const acquired = await base(input) if (!acquired.link) { throw new Error('the rig acquisition always links a provider handle') @@ -296,75 +292,3 @@ describe('a send after the agent said it is not signed in', () => { expect(rig.adapter.acquire).toHaveBeenCalledTimes(2) }) }) - -describe('retireOutgrownStructuredAgentSessionChild', () => { - const idle: Parameters[2]['work'] = { - currentWork: () => ({ activeTurnId: () => null, hasActionablePrompt: () => false }), - childWork: () => [], - childWorkOpen: () => false, - hasOpenDispatch: () => false, - providerHoldsDispatch: () => false - } - it('keeps healthy acquired Claude A for canonical native result mail without provider children', async () => { - const fixture = await createReceivingAccountFixture() - try { - await fixture.turn('completed-lead', 'completed') - const next = await fixture.submit({ - kind: 'message', - role: 'user', - blocks: [ - { - type: 'text', - text: 'You have 1 orchestration message. Run `orca-dev orchestration check --run run_01227aad9fcf`.' - } - ], - from: { - kind: 'agent', - senders: [ - { - party: { - address: 'structworker_e7f53907-0cde-40b9-81c5-d18eb66c07a4', - terminalHandle: 'structworker_e7f53907-0cde-40b9-81c5-d18eb66c07a4', - orcaSessionId: testOrcaSessionId('d93bb955-2f5f-4206-93e9-cbbc9460d7e3') - }, - name: 'QA30955 wake-home child' - } - ], - orchestration: { - message: 'mail-notice', - mailbox: 'run:run_01227aad9fcf', - dispatchId: null, - messages: [ - { - messageId: 'msg_1df05968e9bb', - runId: 'run_01227aad9fcf', - from: 'structworker_e7f53907-0cde-40b9-81c5-d18eb66c07a4' - } - ] - } - } - }) - const child = fixture.session.child - const stopAgent = vi.fn(async () => undefined) - await retireOutgrownStructuredAgentSessionChild(fixture.root, fixture.session, { - next, - work: idle, - launchAccountHome: async () => - ( - await structuredAgentSessionReceivingAccount( - fixture.deps, - fixture.record, - fixture.session, - next - ) - ).home, - stopAgent, - logger: { warn: vi.fn(), error: vi.fn() } - }) - expect(stopAgent).not.toHaveBeenCalled() - expect(fixture.session.child).toBe(child) - } finally { - await fixture.dispose() - } - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-native-responses.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-queued-native-responses.ts deleted file mode 100644 index 7339f7e9969..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-queued-native-responses.ts +++ /dev/null @@ -1,65 +0,0 @@ -import type { AgentSessionJournal } from '../agent-session-journal/journal-store' -import type { JournalRow } from '../agent-session-journal/journal-row-schema' -import type { QueuedMessageRow } from '../agent-session-journal/queued-message-table' - -/** Pointer delivery transfers ownership to a card before any submitted turn exists. */ -export class StructuredQueuedNativeResponses { - private readonly messages = new Map() - - reset(journal: AgentSessionJournal): void { - this.messages.clear() - for (const card of journal.queuedMessages.list()) { - this.observe(card) - } - } - - changed(journal: AgentSessionJournal, row: JournalRow): void { - const id = - row.kind === 'queue' - ? row.messageId - : row.kind === 'submission' - ? row.queuedMessageId - : row.kind === 'dispatch' - ? journal.submission(row.clientMessageId)?.queuedMessageId - : undefined - if (id) { - this.changedCard(journal, id) - } - } - - /** The card's current value decides: a present card is re-read, a gone one forgotten. */ - changedCard(journal: AgentSessionJournal, id: string): void { - const card = journal.queuedMessages.get(id) - if (card) { - this.observe(card) - } else { - this.messages.delete(id) - } - } - - private observe(card: QueuedMessageRow): void { - const source = card.body.from?.orchestration - if ( - (card.state === 'waiting' || card.state === 'returned') && - source?.message === 'mail-notice' - ) { - this.messages.set( - card.messageId, - source.messages.map((message) => message.messageId) - ) - } else { - this.messages.delete(card.messageId) - } - } - - *pendingWith(pending: ReadonlySet, disposed: ReadonlySet): Iterable { - yield* pending - for (const messages of this.messages.values()) { - for (const message of messages) { - if (!disposed.has(message)) { - yield message - } - } - } - } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.test.ts deleted file mode 100644 index d56f5fde58e..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.test.ts +++ /dev/null @@ -1,90 +0,0 @@ -import { - agentSessionLeaseFixture, - agentSessionRecordFixture -} from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture' -import { agentSessionConversationView } from '../../../shared/agent-session-conversation-view' -import { mkdtemp, rm } from 'node:fs/promises' -import { tmpdir } from 'node:os' -import { join } from 'node:path' -import { afterEach, beforeEach, describe, expect, it } from 'vitest' -import type { AgentSessionRecord } from '../../../shared/agent-session/lifecycle/agent-session-record' -import type { StructuredAgentSessionConversationOpenDeps } from './structured-agent-session-conversation-open' -import type { AgentSessionJournal } from '../agent-session-journal/journal-store' -import { - closeTestJournalHostDatabases, - openTestJournalHostDatabase -} from '../agent-session-journal/journal-host-database-test-support' -import { publishJournalSessionEpoch } from '../agent-session-journal/journal-row-table' -import { restoreStructuredAgentSessionRead } from './structured-agent-session-read-restore' -import { recordingStructuredAgentSessionLogger } from './structured-agent-session-logger-test-support' -import { codexProviderHandle } from '../../../shared/agent-session/lifecycle/agent-session-provider-handle-encoding' - -const SESSION_ID = 'codex_read_restore_fixture' -const WORKSPACE_ID = 'repo-1::/tmp/workspace' - -const RECORD: AgentSessionRecord = { - ...agentSessionRecordFixture( - agentSessionLeaseFixture({ sessionId: SESSION_ID, runtimeFence: 1 }) - ), - sessionId: SESSION_ID, - location: { - executionHostId: 'local', - wslDistro: null, - workspaceId: WORKSPACE_ID, - workspaceKind: 'git-worktree' - }, - provider: 'codex', - accountHome: { variable: 'CODEX_HOME', path: '/tmp/codex-home' }, - providerHandleChain: [ - { - linkId: 'link-1', - handle: codexProviderHandle('thread-1'), - origin: 'created', - mintedAtFence: 1, - observedAt: 1 - } - ] -} - -const store: StructuredAgentSessionConversationOpenDeps['store'] = { - getConversation: (sessionId: string) => - sessionId === SESSION_ID ? agentSessionConversationView(RECORD) : null, - replacedRuntime: () => undefined -} - -let journalRoot: string -const openDeps = () => ({ - store, - journalDatabase: openTestJournalHostDatabase(journalRoot), - logger: recordingStructuredAgentSessionLogger().logger -}) -const opened: AgentSessionJournal[] = [] - -beforeEach(async () => { - journalRoot = await mkdtemp(join(tmpdir(), 'orca-read-restore-')) -}) - -afterEach(async () => { - await Promise.allSettled(opened.splice(0).map((journal) => journal.close())) - closeTestJournalHostDatabases() - await rm(journalRoot, { recursive: true, force: true }) -}) - -describe('read restore', () => { - it('publishes a session with a journal, starting no agent', async () => { - const deps = openDeps() - const restored = await restoreStructuredAgentSessionRead(deps, SESSION_ID) - expect(restored).toBeNull() - publishJournalSessionEpoch( - deps.journalDatabase.db, - { sessionId: SESSION_ID, workspaceId: WORKSPACE_ID }, - 'epoch-1' - ) - - const published = await restoreStructuredAgentSessionRead(deps, SESSION_ID) - - expect(published).not.toBeNull() - opened.push(published!.session.journal) - expect(published!.session.child).toBeNull() - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts deleted file mode 100644 index 30344ffb1ef..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts +++ /dev/null @@ -1,21 +0,0 @@ -import { readJournalSessionEpoch } from '../agent-session-journal/journal-row-table' -import { - openStructuredAgentSessionConversationJournal, - type OpenedStructuredAgentSessionConversation, - type StructuredAgentSessionConversationOpenDeps -} from './structured-agent-session-conversation-open' - -/** Open only existing journals without founding empty chats; recovery may still write the crash boundary. */ -export async function restoreStructuredAgentSessionRead( - deps: StructuredAgentSessionConversationOpenDeps, - sessionId: string -): Promise { - const record = deps.store.getConversation(sessionId) - if (!record) { - return null - } - if (readJournalSessionEpoch(deps.journalDatabase.db, sessionId) === null) { - return null - } - return openStructuredAgentSessionConversationJournal(deps, record) -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-perf.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-perf.test.ts deleted file mode 100644 index 7a35d07a722..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-perf.test.ts +++ /dev/null @@ -1,325 +0,0 @@ -import { randomUUID } from 'node:crypto' -import * as conversationView from '../../../shared/agent-session-conversation-view' -import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' -import { conversationRecordReader } from '../../runtime/orchestration/structured-session-lineage' -import { structuredSessionMailReach } from '../../runtime/orchestration/structured-session-mail-address' -import { dispatchReportMailbox } from '../../runtime/orchestration/dispatch-report-mailbox' -import { structuredMailNotice } from '../../runtime/orchestration/structured-mail-source' -import { observeReceivingSql } from './structured-agent-session-receiving-sql.test-support' -import { - agentSessionRecordFixture, - agentSessionLeaseFixture -} from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture' -import { - openTestAgentSessionRecordStore, - seedTestAgentSessionRecordStore -} from '../../runtime/agent-session/records/agent-session-record-store-test-harness' -import { openTestJournalHostDatabase } from '../agent-session-journal/journal-host-database-test-support' -import type { AgentJournalMessageItem } from '../../../shared/agent-session/journal/agent-session-journal-types' -import { expect, it, vi } from 'vitest' -import { - createReceivingAccountFixture, - RECEIVING_A, - SELECTED_B -} from './structured-agent-session-receiving-account.test-support' -import { StructuredNativeResponses } from './structured-agent-session-native-responses' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' -const ordinary: AgentJournalMessageItem = { - kind: 'message', - role: 'user', - blocks: [{ type: 'text', text: 'ordinary' }] -} -it.each([10, 100])( - 'indexes %i native results once and reads only changed journal rows thereafter', - async (n) => { - const f = await createReceivingAccountFixture() - try { - const started = performance.now() - const messages = Array.from({ length: n }, () => f.finish(f.start())) - for (const message of messages) { - const next = await f.submit(f.body(message)) - await f.turn(next.clientMessageId, 'completed') - } - const visits = vi.spyOn(f.journal, 'visitItemsWithLinkage') - const submissions = vi.spyOn(f.journal, 'submissions') - const rows = vi.spyOn(f.journal, 'readSince') - const keys = vi.spyOn(f.journal, 'canonicalItemId') - const projection = new StructuredNativeResponses() - expect(projection.read(f.journal).disposed.size).toBe(n) - expect(visits).toHaveBeenCalledTimes(1) - expect(submissions).toHaveBeenCalledTimes(1) - keys.mockClear() - for (let i = 0; i < n; i += 1) { - projection.read(f.journal) - } - expect(keys).not.toHaveBeenCalled() - expect(rows).not.toHaveBeenCalled() - const next = await f.submit(ordinary, 'client') - keys.mockClear() - projection.read(f.journal) - expect(keys.mock.calls.length).toBeLessThanOrEqual(8) - expect(rows).toHaveBeenCalledTimes(1) - expect(rows.mock.results[0]?.value).toMatchObject({ ok: true }) - expect(visits).toHaveBeenCalledTimes(1) - expect(submissions).toHaveBeenCalledTimes(1) - expect(next.clientMessageId).toBeTruthy() - for (let i = 1; i <= n; i += 1) { - await f.journal.appendTombstone( - { provider: 'claude', sessionId: 'parent-provider', uuid: `turn-receiving-${i}` }, - { fence: 2 } - ) - } - projection.read(f.journal) - expect(visits).toHaveBeenCalledTimes(2) - expect(submissions).toHaveBeenCalledTimes(2) - expect(rows).toHaveBeenCalledTimes(2) - process.stdout.write( - `receiving-account journal corpus=${n} initialVisits=1 initialSubmissionLists=1 unchangedReads=${n} incrementalReads=1 destructiveBatchRebuilds=1 elapsedMs=${(performance.now() - started).toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) - -it.each([10, 100])( - 'bounds real native mailbox enumeration at %i results despite unrelated history', - async (n) => { - const f = await createReceivingAccountFixture() - try { - const began = performance.now() - for (let i = 0; i < n; i += 1) { - const next = await f.submit(f.body(f.finish(f.start()))) - await f.turn(next.clientMessageId, 'completed') - } - for (let i = 0; i < n * 10; i += 1) { - f.db.createTask({ spec: 'unrelated corpus', runId: f.run.id }) - } - const observed = observeReceivingSql(f.db) - const selected = await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - expect(selected.home).toEqual(SELECTED_B) - // Scoped reach + current mailbox discovery + canonical report routing are constant preparations. - expect(observed.measurements.prepares).toBeLessThanOrEqual(20) - expect(observed.measurements.allRows).toBeLessThanOrEqual(n + 4) - expect(observed.measurements.plans.length).toBeGreaterThan(0) - expect( - observed.measurements.plans.filter((detail) => - /\bSCAN (?:run|child|task|parent|messages|dispatch_contexts|agent_session_records)\b/.test( - detail - ) - ) - ).toEqual([]) - observed.stop() - process.stdout.write( - `receiving-account native results=${n} unrelatedTasks=${n * 10} statements=${observed.measurements.prepares} enumerated=${observed.measurements.allRows} elapsedMs=${(performance.now() - began).toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) - -it.each([10, 100])( - 'reads %i historical clear links through the real record index, independent of other chats', - async (n) => { - const f = await createReceivingAccountFixture() - try { - const began = performance.now() - const predecessors = Array.from({ length: n }, (_, i) => ({ - ...agentSessionRecordFixture( - agentSessionLeaseFixture({ sessionId: `clear-source-${i}`, runtimeFence: 2 }) - ), - conversationCommand: { - command: 'clear' as const, - state: 'completed' as const, - phase: 'committed' as const, - runtimeFence: 2, - callerKey: 'legacy-client', - operationId: '1800000000000-00000000000000000000000000000003', - replacementSessionId: i === n - 1 ? f.root : `clear-source-${i + 1}` - } - })) - const unrelated = Array.from({ length: n * 10 }, (_, i) => - agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId: `unrelated-chat-${i}` })) - ) - await seedTestAgentSessionRecordStore(f.rig.root, { - records: [f.record, ...predecessors, ...unrelated] - }) - const store = await openTestAgentSessionRecordStore(f.rig.root) - const db = openTestJournalHostDatabase(f.rig.root).db - const prepare = db.prepare.bind(db) - let reads = 0 - let enumerated = 0 - const spy = vi.spyOn(db, 'prepare').mockImplementation((sql) => { - const statement = prepare(sql) - const all = statement.all.bind(statement) - vi.spyOn(statement, 'all').mockImplementation((...args) => { - reads += 1 - const rows = all(...args) - enumerated += rows.length - const plan = prepare(`EXPLAIN QUERY PLAN ${sql}`).all(...args) - expect( - plan.some( - (row) => - typeof row.detail === 'string' && - row.detail.includes('idx_agent_session_clear_successor') - ) - ).toBe(true) - return rows - }) - return statement - }) - const lineage = store.lineageRecords(f.record) - expect(lineage.map((record) => record.sessionId)).toEqual([ - ...predecessors.map((record) => record.sessionId), - f.root - ]) - expect(spy).toHaveBeenCalledTimes(1) - expect(reads).toBe(n + 1) - expect(enumerated).toBe(n) - spy.mockRestore() - process.stdout.write( - `receiving-account clearLinks=${n} unrelatedChats=${n * 10} indexPrepares=1 lookups=${reads} enumerated=${enumerated} elapsedMs=${(performance.now() - began).toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) - -it.each([ - { l: 10, u: 100 }, - { l: 100, u: 100 }, - { l: 10, u: 1000 }, - { l: 100, u: 1000 } -])( - 'bounds canonical receiving projections for lineage $l with $u unrelated chats', - async ({ l, u }) => { - const f = await createReceivingAccountFixture() - try { - const ids = Array.from({ length: l - 1 }, () => testOrcaSessionId(randomUUID())) - const predecessors = ids.map((sessionId, i) => ({ - ...agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId, runtimeFence: 2 })), - conversationCommand: { - command: 'clear' as const, - state: 'completed' as const, - phase: 'committed' as const, - runtimeFence: 2, - callerKey: 'legacy-client', - operationId: '1800000000000-00000000000000000000000000000003', - replacementSessionId: ids[i + 1] ?? f.root - } - })) - const unrelated = Array.from({ length: u }, () => - agentSessionRecordFixture(agentSessionLeaseFixture({ sessionId: randomUUID() })) - ) - await seedTestAgentSessionRecordStore(f.rig.root, { - records: [f.record, ...predecessors, ...unrelated] - }) - const store = await openTestAgentSessionRecordStore(f.rig.root) - const record = store.requireWritableRecord(f.root) - expect(store.lineageRecords(record).map((item) => item.sessionId)).toEqual([...ids, f.root]) - const root = ids[0] - if (!root) { - throw new Error('clear lineage requires a predecessor') - } - const original = store.getConversation(root) - if (!original) { - throw new Error('canonical lineage root missing') - } - const reader = conversationRecordReader(store) - expect(structuredSessionMailReach(reader, original, f.db, reader)).toMatchObject({ - kind: 'reachable', - session: { sessionId: f.root } - }) - const run = f.db.createRun({ - objective: 'clear-lineage native work', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: root - }) - const child = f.db.createStartingWorkerDispatch({ - taskSpec: 'report to the current clear successor', - taskRunId: run.id, - taskCreatedByRunGeneration: run.consumer_generation, - creator: { kind: 'session', orcaSessionId: root }, - maxDepth: 9, - startOptions: {} - }) - expect(dispatchReportMailbox(f.db, child.dispatch)).toBe(`run:${run.id}`) - const all = vi.spyOn(store, 'listRecords').mockImplementation(() => { - throw new Error('global raw history scan') - }) - const conversations = vi.spyOn(store, 'listConversations').mockImplementation(() => { - throw new Error('global conversation scan') - }) - const projection = vi.spyOn(conversationView, 'agentSessionConversationView') - const decide = async (expected: typeof RECEIVING_A) => { - projection.mockClear() - const observed = observeReceivingSql(f.db) - try { - expect( - (await structuredAgentSessionReceivingAccount({ ...f.deps, store }, record, f.session)) - .home - ).toEqual(expected) - // Array.map supplies index/array; direct getConversation projections take one argument. - const mapped = projection.mock.calls.filter((args) => args.length > 1).length - expect(mapped).toBeGreaterThan(0) - expect(mapped).toBeLessThanOrEqual(3 * l) - expect(observed.measurements.prepares).toBeLessThanOrEqual(20) - expect(observed.measurements.allRows).toBeLessThanOrEqual(8) - expect(observed.measurements.plans.length).toBeGreaterThan(0) - expect( - observed.measurements.plans.filter((detail) => - /\bSCAN (?:run|child|task|parent|messages|dispatch_contexts|agent_session_records)\b/.test( - detail - ) - ) - ).toEqual([]) - expect(all).not.toHaveBeenCalled() - expect(conversations).not.toHaveBeenCalled() - process.stdout.write( - `receiving-projection lineage=${l} unrelated=${u} mapped=${mapped} bound=${3 * l} sql=${observed.measurements.prepares} rows=${observed.measurements.allRows} home=${expected.path}\n` - ) - } finally { - observed.stop() - } - } - await decide(RECEIVING_A) - const message = f.db.commitWorkerDoneMessageMutation(() => { - f.db.completeDispatch(child.dispatch.id) - return f.db.insertMessage({ - from: 'structworker_e7f53907-0cde-40b9-81c5-d18eb66c07a4', - to: dispatchReportMailbox(f.db, child.dispatch), - runId: run.id, - type: 'worker_done', - subject: 'completed', - payload: JSON.stringify({ - dispatchId: child.dispatch.id, - taskId: child.task.id, - outcome: 'succeeded' - }), - deliveryContract: 'current_delivery' - }) - }) - await decide(RECEIVING_A) - const next = await f.submit( - structuredMailNotice({ - db: f.db, - mailboxHandle: `run:${run.id}`, - dispatchId: null, - batch: { messages: [message], heldDeliveryId: undefined }, - cliCommand: 'orca-dev', - senderSnapshot: () => ({ name: null, agent: null }) - }) - ) - await decide(RECEIVING_A) - await f.turn(next.clientMessageId, 'completed') - await decide(SELECTED_B) - expect(f.db.getMessageById(message.id)?.read).toBe(0) - } finally { - vi.restoreAllMocks() - await f.dispose() - } - } -) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-queue.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-queue.test.ts deleted file mode 100644 index 3509a8ee28c..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account-queue.test.ts +++ /dev/null @@ -1,108 +0,0 @@ -import { AGENT_JOURNAL_THREAD_SCOPE } from '../../../shared/agent-session/journal/agent-session-journal-types' -import { expect, it, vi } from 'vitest' -import { agentSessionSendBodyFingerprint } from '../../../shared/agent-session/requests/structured-agent-session-send-mutation' -import { StructuredNativeResponses } from './structured-agent-session-native-responses' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' -import { - createReceivingAccountFixture, - RECEIVING_A, - SELECTED_B -} from './structured-agent-session-receiving-account.test-support' - -it('retains queued pointer ownership across epoch replacement, then disposes only its actual response', async () => { - const f = await createReceivingAccountFixture() - try { - const message = f.finish(f.start()) - const body = f.body(message) - const target = () => structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - await f.journal.queuedMessages.insert({ messageId: 'native-pointer-card', body }) - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - expect((await target()).home).toEqual(RECEIVING_A) - await f.journal.replaceEpochItems('handle_forked', 2, []) - expect((await target()).home).toEqual(RECEIVING_A) - await f.journal.appendSubmission( - { - clientMessageId: 'queued-native-response', - payloadFingerprint: agentSessionSendBodyFingerprint(f.root, body), - body, - origin: 'host', - fence: 2, - handoverRecorded: true - }, - { messageId: 'native-pointer-card', expect: 'waiting' } - ) - await f.journal.resolveDispatch({ - clientMessageId: 'queued-native-response', - fence: 2, - state: 'pending', - turnScope: AGENT_JOURNAL_THREAD_SCOPE - }) - await f.turn('queued-native-response', 'running') - f.db.markAsRead([message.id]) - expect((await target()).home).toEqual(RECEIVING_A) - await f.turn('queued-native-response', 'completed') - expect((await target()).home).toEqual(SELECTED_B) - // Provider history replacement removes the old turn, not the result's delivery stamp. - await f.journal.replaceEpochItems('handle_forked', 2, []) - expect((await target()).home).toEqual(SELECTED_B) - } finally { - await f.dispose() - } -}) - -it('withdrawal ends queued notice ownership even when the result remains unread', async () => { - const f = await createReceivingAccountFixture() - try { - const message = f.finish(f.start()) - await f.journal.queuedMessages.insert({ messageId: 'withdrawn-pointer', body: f.body(message) }) - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - const target = () => structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - expect((await target()).home).toEqual(RECEIVING_A) - await f.journal.queuedMessages.withdraw(['withdrawn-pointer']) - expect((await target()).home).toEqual(SELECTED_B) - await f.journal.replaceEpochItems('handle_forked', 2, []) - expect((await target()).home).toEqual(SELECTED_B) - } finally { - await f.dispose() - } -}) - -it.each([10, 100])( - 'bounds queued native ownership updates at %i cards to the changed card', - async (n) => { - const f = await createReceivingAccountFixture() - try { - const started = performance.now() - const ids: string[] = [] - for (let i = 0; i < n; i += 1) { - const message = f.finish(f.start()) - const id = `pointer-${i}` - ids.push(id) - await f.journal.queuedMessages.insert({ messageId: id, body: f.body(message) }) - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - } - const list = vi.spyOn(f.journal.queuedMessages, 'list') - const get = vi.spyOn(f.journal.queuedMessages, 'get') - const projection = new StructuredNativeResponses() - expect([...projection.read(f.journal).pending]).toHaveLength(n) - expect(list).toHaveBeenCalledTimes(1) - for (let i = 0; i < n; i += 1) { - expect([...projection.read(f.journal).pending]).toHaveLength(n) - } - expect(list).toHaveBeenCalledTimes(1) - expect(get).not.toHaveBeenCalled() - await f.journal.queuedMessages.withdraw([ids[0]]) - // Count the receiving projection, excluding the existing mutation owner's own lookups. - list.mockClear() - get.mockClear() - expect([...projection.read(f.journal).pending]).toHaveLength(n - 1) - expect(list).not.toHaveBeenCalled() - expect(get).toHaveBeenCalledTimes(1) - process.stdout.write( - `receiving-account queue corpus=${n} initialLists=1 unchangedReads=${n} changedCardGets=1 changedCardLists=0 elapsedMs=${(performance.now() - started).toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test-support.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test-support.ts deleted file mode 100644 index 93e3d276a8d..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test-support.ts +++ /dev/null @@ -1,218 +0,0 @@ -import { createRestTestRig } from './structured-agent-session-rest-test-rig' -import { hostTestAttachParams } from './structured-agent-session-host-test-data' -import { - agentSessionRecordFixture, - agentSessionLeaseFixture -} from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture' -import { withAcquiredAgentSessionAccount } from '../../../shared/agent-session-acquired-account' -import { - AGENT_JOURNAL_THREAD_SCOPE, - type AgentJournalMessageItem, - type AgentJournalTurnLifecycle -} from '../../../shared/agent-session/journal/agent-session-journal-types' -import { - agentJournalSubmissionKey, - agentJournalItemKey -} from '../../../shared/agent-session/journal/agent-session-journal-item-key' -import { isOrcaSessionId } from '../../../shared/orca-session-address' -import { StructuredAgentSessionCurrentWork } from './structured-agent-session-current-work' -import { AgentSessionJournal } from '../agent-session-journal/journal-store' -import { openTestJournalHostDatabase } from '../agent-session-journal/journal-host-database-test-support' -import { - seedTestAgentSessionRecordStore, - openTestAgentSessionRecordStore -} from '../../runtime/agent-session/records/agent-session-record-store-test-harness' -import { OrchestrationDb } from '../../runtime/orchestration/db' -import { structuredNativeWorkReaders } from '../../runtime/structured-native-work-readers' -import { structuredMailNotice } from '../../runtime/orchestration/structured-mail-source' -import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types' - -export const RECEIVING_A = { variable: 'CLAUDE_CONFIG_DIR', path: '/qa/claude-profiles/qa-a/home' } -export const SELECTED_B = { variable: 'CLAUDE_CONFIG_DIR', path: '/qa/claude-profiles/qa-b/home' } -export async function createReceivingAccountFixture() { - const rig = await createRestTestRig() - const record = withAcquiredAgentSessionAccount( - agentSessionRecordFixture( - agentSessionLeaseFixture({ - sessionId: '6e1b4ae5-2354-4ca5-999e-647deeb23894', - runtimeFence: 2 - }) - ), - { - generation: 'generation-2', - recipe: { route: 'system', home: RECEIVING_A.path, configDir: RECEIVING_A.path } - } - ) - const root = record.sessionId - if (!isOrcaSessionId(root)) { - throw new Error('fixture requires a canonical session id') - } - await seedTestAgentSessionRecordStore(rig.root, { records: [record] }) - const store = await openTestAgentSessionRecordStore(rig.root) - const journal = new AgentSessionJournal({ - database: openTestJournalHostDatabase(rig.root), - identity: { - sessionId: root, - workspaceId: 'workspace-1', - hostId: 'local', - agent: 'claude', - providerHandle: null - } - }) - await journal.open() - const session: StructuredAgentSessionHostSession = { - journal, - params: hostTestAttachParams(null, { - provider: 'claude', - agent: 'claude', - accountHome: RECEIVING_A - }), - child: { phase: 'ready', fence: 2, generation: 'generation-2', accountHome: RECEIVING_A } - } - const db = new OrchestrationDb(':memory:') - const run = db.createRun({ - objective: 'native parent', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: root - }) - const deps = { - ...rig.host.deps, - store, - launchAccountHome: async () => SELECTED_B, - ...structuredNativeWorkReaders(() => db) - } - let sends = 0 - const submit = async ( - body: AgentJournalMessageItem, - origin: 'client' | 'host' = 'host', - legacy = false - ) => { - const clientMessageId = `receiving-${++sends}` - await journal.appendSubmission({ - clientMessageId, - payloadFingerprint: clientMessageId, - ...(legacy ? {} : { handoverRecorded: true }), - body, - origin, - fence: 2 - }) - const submission = journal.submission(clientMessageId) - if (!submission) { - throw new Error('submission was not committed') - } - return submission - } - const turn = async ( - clientMessageId: string, - state: AgentJournalTurnLifecycle['state'], - legacy = false - ) => { - const identity = { - provider: 'claude' as const, - sessionId: 'parent-provider', - uuid: `turn-${clientMessageId}` - } - let userItemId = agentJournalSubmissionKey(clientMessageId) - const submitted = journal.submission(clientMessageId) - if (submitted) { - const echo = { - provider: 'claude' as const, - sessionId: 'parent-provider', - uuid: `echo-${clientMessageId}` - } - const body = journal.itemBody(userItemId) - if (!body) { - throw new Error('provider echo requires its actual submitted input') - } - const turnScope = new StructuredAgentSessionCurrentWork(journal, 2).turnScope() - if (submitted.handoverRecorded && submitted.handedOverAt === undefined) { - await journal.resolveDispatch({ clientMessageId, fence: 2, state: 'pending', turnScope }) - } - await journal.resolveDispatch({ - clientMessageId, - fence: 2, - state: 'accepted', - providerIdentity: echo - }) - await journal.appendItem(echo, body, { fence: 2, turnScope }) - if (legacy) { - userItemId = agentJournalItemKey(echo) - } - } - const lifecycle: AgentJournalTurnLifecycle = { - turnId: `turn-${clientMessageId}`, - state, - outcome: state === 'completed' ? 'success' : undefined, - userItemId, - ...(state === 'running' ? {} : { completedAt: 100 }) - } - await journal.appendItem( - identity, - legacy - ? { kind: 'status', text: 'Done', turnLifecycle: lifecycle } - : { kind: 'turn', ...lifecycle }, - { fence: 2, turnScope: AGENT_JOURNAL_THREAD_SCOPE } - ) - return agentJournalItemKey(identity) - } - const start = () => - db.createStartingWorkerDispatch({ - taskSpec: 'real native child work', - taskRunId: run.id, - taskCreatedByRunGeneration: run.consumer_generation, - startOptions: {}, - creator: { kind: 'session', orcaSessionId: root }, - maxDepth: 9 - }) - const finish = ( - child: ReturnType, - contract: 'legacy_direct' | 'current_delivery' = 'current_delivery' - ) => - db.commitWorkerDoneMessageMutation(() => { - db.completeDispatch(child.dispatch.id) - return db.insertMessage({ - from: 'structworker_e7f53907-0cde-40b9-81c5-d18eb66c07a4', - to: `run:${run.id}`, - runId: run.id, - type: 'worker_done', - subject: 'child completed', - payload: JSON.stringify({ - dispatchId: child.dispatch.id, - taskId: child.task.id, - outcome: 'succeeded' - }), - deliveryContract: contract - }) - }) - const body = (message: ReturnType) => - structuredMailNotice({ - db, - mailboxHandle: `run:${run.id}`, - dispatchId: null, - batch: { messages: [message], heldDeliveryId: undefined }, - cliCommand: 'orca-dev', - senderSnapshot: () => ({ name: null, agent: null }) - }) - return { - rig, - record, - store, - session, - deps, - journal, - db, - run, - root, - submit, - turn, - start, - finish, - body, - dispose: async () => { - await journal.close() - db.close() - await rig.dispose() - } - } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test.ts deleted file mode 100644 index fe184c1b166..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.test.ts +++ /dev/null @@ -1,285 +0,0 @@ -import { - AGENT_JOURNAL_THREAD_SCOPE, - type AgentJournalMessageItem -} from '../../../shared/agent-session/journal/agent-session-journal-types' -import { describe, expect, it, vi } from 'vitest' -import { - createReceivingAccountFixture, - RECEIVING_A, - SELECTED_B -} from './structured-agent-session-receiving-account.test-support' -import { structuredAgentSessionReceivingAccount } from './structured-agent-session-receiving-account' -import { agentSessionFailureFact } from '../../../shared/agent-session/failures/agent-session-failure' -import { agentSessionFailureWords } from '../../../shared/agent-session/failures/agent-session-failure-words' -import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' - -const ordinary: AgentJournalMessageItem = { - kind: 'message', - role: 'user', - blocks: [{ type: 'text', text: 'next ordinary input' }] -} - -describe('receiving account through native work and exact parent disposition', () => { - it.each(['current_delivery', 'legacy_direct'] as const)( - 'retains A from creation through %s response, then eligible ordinary follows B', - async (contract) => { - const f = await createReceivingAccountFixture() - try { - const target = async () => - structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - const child = f.start() - expect((await target()).home).toEqual(RECEIVING_A) - const message = f.finish(child, contract) - expect((await target()).home).toEqual(RECEIVING_A) - const next = await f.submit(f.body(message), 'host', contract === 'legacy_direct') - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - await f.turn(next.clientMessageId, 'running', contract === 'legacy_direct') - expect((await target()).home).toEqual(RECEIVING_A) - f.db.markAsRead([message.id]) - expect((await target()).home).toEqual(RECEIVING_A) - await f.turn('unrelated-parent-request', 'completed') - expect((await target()).home).toEqual(RECEIVING_A) - await f.turn(next.clientMessageId, 'completed', contract === 'legacy_direct') - expect((await target()).home).toEqual(SELECTED_B) - const picked = await f.submit(ordinary, 'client') - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, picked)).recipe - ).toBeUndefined() - // Repeated unread notice replays cannot recreate account ownership after the exact response. - f.db.markAsUndelivered([message.id]) - expect((await target()).home).toEqual(SELECTED_B) - } finally { - await f.dispose() - } - } - ) - - it('retires owed ownership when a rewind retires the Orca send that carried the notice', async () => { - const f = await createReceivingAccountFixture() - try { - const target = () => structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - const receipt = { write: () => undefined, committed: () => undefined } - await f.journal.context.clear( - { operationId: 'clear-1', afterFence: 1, clearedAt: 1 }, - receipt - ) - const floor = f.journal.cursor() - const message = f.finish(f.start()) - const next = await f.submit(f.body(message)) - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - await f.turn(next.clientMessageId, 'running') - expect((await target()).home).toEqual(RECEIVING_A) - await f.journal.context.rewind(floor, 2, [], () => receipt) - expect(f.journal.submission(next.clientMessageId)).toBeUndefined() - expect((await target()).home).toEqual(SELECTED_B) - } finally { - await f.dispose() - } - }) - - it.each(['interrupted', 'unverifiable'] as const)( - 'keeps existing %s disposition without a success-only hold', - async (state) => { - const f = await createReceivingAccountFixture() - try { - const message = f.finish(f.start()) - const next = await f.submit(f.body(message)) - const target = () => structuredAgentSessionReceivingAccount(f.deps, f.record, f.session) - expect((await target()).home).toEqual(RECEIVING_A) - await f.turn(next.clientMessageId, state) - expect((await target()).home).toEqual(SELECTED_B) - } finally { - await f.dispose() - } - } - ) - - it('retains known recipe after true absence; unknown historical absence uses selection, without inventing A', async () => { - const f = await createReceivingAccountFixture() - try { - const next = await f.submit(f.body(f.finish(f.start()))) - await f.store.reconcileOnRestart({ - sessionId: f.root, - probe: async () => ({ outcome: 'exit-observed' }), - now: 40_000 - }) - f.session.child = null - const released = f.store.getRecord(f.root) - if (!released) { - throw new Error('record missing after actual release') - } - const known = await structuredAgentSessionReceivingAccount(f.deps, released, f.session, next) - expect(known.home).toEqual(RECEIVING_A) - expect(known.recipe).toMatchObject({ route: 'system', home: RECEIVING_A.path }) - const { acquiredAccount: _observation, ...historical } = released - // The store reader returns this historical record rather than a retained source observation. - const lineageRecords = vi.spyOn(f.store, 'lineageRecords').mockReturnValue([historical]) - expect( - await structuredAgentSessionReceivingAccount(f.deps, historical, f.session, next) - ).toEqual({ home: SELECTED_B }) - lineageRecords.mockRestore() - } finally { - await f.dispose() - } - }) - - it('fences a previous consumer through the real Run rebind owner', async () => { - const f = await createReceivingAccountFixture() - try { - f.start() - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session)).home - ).toEqual(RECEIVING_A) - const next = f.db.createRun({ - objective: 'new coordinator consumer', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: f.root - }) - // Creation keeps the earlier consumer; run-use is the real rebind owner. - f.db.bindRun({ - runId: next.id, - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: f.root - }) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session)).home - ).toEqual(SELECTED_B) - } finally { - await f.dispose() - } - }) - - it('signed-out native mail uses existing selected-route recovery, including reacquisition', async () => { - const f = await createReceivingAccountFixture() - try { - const next = await f.submit(f.body(f.finish(f.start()))) - await f.journal.appendItem( - { provider: 'orca', clientMessageId: 'signed-out' }, - { - kind: 'status', - ...agentSessionFailureWords(agentSessionFailureFact('notSignedIn'), { surface: 'row' }) - }, - { fence: 2, turnScope: AGENT_JOURNAL_THREAD_SCOPE } - ) - expect( - await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, next) - ).toEqual({ home: SELECTED_B }) - f.session.child = null - expect( - await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, next) - ).toEqual({ home: SELECTED_B }) - } finally { - await f.dispose() - } - }) - - it('allows explicit latest usage-cut recovery without automatically rerouting native mail', async () => { - const f = await createReceivingAccountFixture() - try { - f.start() - const turnId = await f.turn('limited', 'completed') - await f.journal.appendItem( - { provider: 'claude', sessionId: 'parent-provider', uuid: 'turn-limited' }, - { - kind: 'turn', - turnId: 'turn-limited', - state: 'completed', - outcome: 'failure', - userItemId: agentJournalSubmissionKey('limited') - }, - { fence: 2, turnScope: AGENT_JOURNAL_THREAD_SCOPE } - ) - await f.journal.appendItem( - { provider: 'orca', clientMessageId: 'usage' }, - { - kind: 'status', - ...agentSessionFailureWords(agentSessionFailureFact('usageLimitReached'), { - surface: 'row' - }) - }, - { fence: 2, turnScope: { kind: 'turn', turnItemId: turnId } } - ) - const next = await f.submit(ordinary, 'client') - expect( - await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, next) - ).toEqual({ home: SELECTED_B }) - await f.turn(next.clientMessageId, 'completed') - const afterRecovery = await f.submit(ordinary, 'client') - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, afterRecovery)) - .home - ).toEqual(RECEIVING_A) - const automatic = await f.submit(f.body(f.finish(f.start()))) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session, automatic)).home - ).toEqual(RECEIVING_A) - } finally { - await f.dispose() - } - }) - it('ends pre-notice ownership when the actual created worker is stopped', async () => { - const f = await createReceivingAccountFixture() - try { - const child = f.start() - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session)).home - ).toEqual(RECEIVING_A) - f.db.reconcileFederatedWorkerStart({ - dispatchId: child.dispatch.id, - state: 'ready', - stage: 'ready' - }) - expect(f.db.beginWorkerStop(child.dispatch.id, 'test-runtime').disposition).toBe('stopping') - f.db.settleWorkerStop(child.dispatch.id) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session)).home - ).toEqual(SELECTED_B) - } finally { - await f.dispose() - } - }) - it("does not add an account hold to main's accepted-but-unanswered ended generation", async () => { - const f = await createReceivingAccountFixture() - try { - const message = f.finish(f.start()) - const next = await f.submit(f.body(message), 'host', true) - await f.journal.resolveDispatch({ - clientMessageId: next.clientMessageId, - fence: 2, - state: 'accepted', - providerIdentity: { - provider: 'claude', - sessionId: 'parent-provider', - uuid: 'unanswered-echo' - } - }) - f.db.markAsDelivered([message.id], `run:${f.run.id}`) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.record, f.session)).home - ).toEqual(RECEIVING_A) - await f.store.reconcileOnRestart({ - sessionId: f.root, - probe: async () => ({ outcome: 'exit-observed' }), - now: 40_000 - }) - f.session.child = null - const released = f.store.getRecord(f.root) - if (!released) { - throw new Error('record missing after execution ended') - } - expect( - (await structuredAgentSessionReceivingAccount(f.deps, released, f.session)).home - ).toEqual(SELECTED_B) - expect(f.journal.submission(next.clientMessageId)?.dispatchState).toBe('accepted') - // A distinct later result still has known receiving A; this does not erase the actual recipe. - f.finish(f.start()) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, released, f.session)).home - ).toEqual(RECEIVING_A) - } finally { - await f.dispose() - } - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.ts deleted file mode 100644 index c713dbf659b..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-account.ts +++ /dev/null @@ -1,85 +0,0 @@ -import { - acquiredAgentSessionAccount, - type ClaudeAccountRecipe -} from '../../../shared/agent-session-acquired-account' -import { agentSessionConversationView } from '../../../shared/agent-session-conversation-view' -import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' -import type { AgentJournalSubmission } from '../../../shared/agent-session/journal/agent-session-journal-types' -import type { AgentSessionAccountHome } from '../../../shared/agent-session/lifecycle/agent-session-account-home' -import type { AgentSessionRecord } from '../../../shared/agent-session/lifecycle/agent-session-record' -import type { - StructuredAgentSessionHostDeps, - StructuredAgentSessionHostSession -} from './structured-agent-session-host-types' -import type { NativeResponseEvidence } from '../../runtime/orchestration/structured-parent-account-work' -import { StructuredNativeResponses } from './structured-agent-session-native-responses' - -const responses = new WeakMap< - StructuredAgentSessionHostSession['journal'], - StructuredNativeResponses ->() - -/** Account construction authority is independent of whether an existing child may be retired. */ -export async function structuredAgentSessionReceivingAccount( - deps: StructuredAgentSessionHostDeps, - record: AgentSessionRecord, - session: StructuredAgentSessionHostSession | undefined, - next?: AgentJournalSubmission, - purpose?: 'read' | 'identity' -): Promise<{ home: AgentSessionAccountHome | null; recipe?: ClaudeAccountRecipe }> { - const selected = () => deps.launchAccountHome?.(record, purpose) ?? Promise.resolve(null) - if (record.provider !== 'claude' || !deps.launchAccountHome) { - return { home: await selected() } - } - let index = session && responses.get(session.journal) - if (session && !index) { - index = new StructuredNativeResponses() - responses.set(session.journal, index) - } - const evidence: NativeResponseEvidence = - session && index - ? index.read(session.journal, record.lease.runtimeFence) - : { pending: [], disposed: new Set() } - const lineage = deps.store.lineageRecords(record) - const recorded = acquiredAgentSessionAccount(record, deps.store.hostId) - // Historical clear links identify native work; they cannot prove a successor's acquired account. - const observation = - recorded && - (!session?.child || - (recorded.fence === session.child.fence && recorded.generation === session.child.generation)) - ? recorded - : null - const fence = session?.child?.fence ?? observation?.fence - if (fence !== undefined && index?.signedOut(fence)) { - return { home: await selected() } - } - const body = - next && session - ? session.journal.itemBody(agentJournalSubmissionKey(next.clientMessageId)) - : null - const mail = body?.kind === 'message' && body.from?.orchestration?.message === 'mail-notice' - if ( - !mail && - session && - next?.origin === 'client' && - index?.recovery.allows(session.journal, next) - ) { - return { home: await selected() } - } - const native = - deps.parentAccountWork?.(record, lineage[0].sessionId, evidence, { - getRecord: deps.store.getConversation, - listRecords: () => lineage.map(agentSessionConversationView), - getVisibleSessionTabIndex: deps.store.getVisibleSessionTabIndex - }) ?? false - if (mail || native) { - const home = - session?.child?.accountHome ?? - (observation ? { variable: 'CLAUDE_CONFIG_DIR', path: observation.recipe.home } : null) - if (home) { - return { home, ...(observation ? { recipe: observation.recipe } : {}) } - } - } - // No successful observation exists for a gone historical process: use the selected route truthfully. - return { home: await selected() } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-auth.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-auth.test.ts deleted file mode 100644 index 26c2d3ad8db..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-auth.test.ts +++ /dev/null @@ -1,61 +0,0 @@ -import { readFile } from 'node:fs/promises' -import { describe, expect, it } from 'vitest' -import { z } from 'zod' -import { createClaudeJournalTranslator } from '../../claude/structured/journal/claude-structured-journal-translation' -import { - createReceivingCallerFixture, - HOME_A, - HOME_B, - PARENT -} from './structured-agent-session-receiving-callers.test-support' - -const entry = z.looseObject({ kind: z.string() }) -const capturedFrame = z.object({ at: z.number(), frame: z.record(z.string(), z.unknown()) }) - -describe('recorded Claude authentication failure reaches receiving recovery', () => { - it('uses the recorded typed failure through the production translator and current acquired fence', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.coldNative() - f.selectB() - await f.ensure() - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - const sink = f.sinks.get(PARENT) - if (!sink) { - throw new Error('successful actual parent acquisition missing') - } - const translator = createClaudeJournalTranslator({ account: () => 'system', sink }) - try { - // Shipping recorded CLI2.1.280 authentication_failed frames; context/fence comes from this actual host acquisition. - const capture = await readFile( - new URL( - '../../claude/__fixtures__/claude-lifecycle-capture-auth-failed.jsonl', - import.meta.url - ), - 'utf8' - ) - for (const line of capture.trim().split('\n')) { - const value: unknown = JSON.parse(line) - if (entry.parse(value).kind !== 'frame') { - continue - } - const { at, frame } = capturedFrame.parse(value) - translator.handle({ type: 'message', sessionId: PARENT, observedAt: at, message: frame }) - } - await f.rig.host.flushStreamedEvents(PARENT) - const snapshot = await f.rig.host.journalSnapshot(PARENT) - expect( - snapshot.items.some( - (item) => item.body.kind === 'status' && item.body.failure?.kind === 'notSignedIn' - ) - ).toBe(true) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_B) - } finally { - translator.dispose() - } - } finally { - await f.dispose() - } - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers-perf.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers-perf.test.ts deleted file mode 100644 index 73d0c1ddc9a..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers-perf.test.ts +++ /dev/null @@ -1,165 +0,0 @@ -import { randomUUID } from 'node:crypto' -import { join } from 'node:path' -import { expect, it } from 'vitest' -import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' -import { OrchestrationDb } from '../../runtime/orchestration/db' -import { - createReceivingCallerFixture, - HOME_A, - PARENT, - WORKER -} from './structured-agent-session-receiving-callers.test-support' -import { observeReceivingSql } from './structured-agent-session-receiving-sql.test-support' - -it.each([ - { n: 10, u: 100 }, - { n: 100, u: 100 }, - { n: 10, u: 1000 } -])( - 'bounds real receiving/report work with D/P=$n and independently varied U=$u', - async ({ n, u }) => { - const f = await createReceivingCallerFixture() - try { - await f.found() - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'relevant Run', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const workers: Awaited>[] = [] - for (let i = 0; i < n; i += 1) { - workers.push(await f.createWorker(testOrcaSessionId(randomUUID()))) - } - const other = db.createRun({ - objective: 'unrelated', - coordinatorHandle: null, - coordinatorPaneKey: null - }) - for (let i = 0; i < u; i += 1) { - db.createStartingWorkerDispatch({ - taskSpec: 'unrelated work', - taskRunId: other.id, - creator: { kind: 'system' }, - maxDepth: 9, - startOptions: {} - }) - } - // Reopen a real populated database with the old branch's index shape; keep cold cost separate. - db.db.exec( - 'DROP INDEX idx_dispatch_creator_mailbox_work; DROP INDEX idx_runs_current_coordinator_handle; DROP INDEX idx_messages_native_direct_work' - ) - const coldAt = performance.now() - const reopened = new OrchestrationDb(join(f.rig.root, 'orchestration.db')) - const coldMs = performance.now() - coldAt - expect( - reopened.db - .prepare( - "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_dispatch_creator_mailbox_work'" - ) - .get() - ).toBeDefined() - expect(reopened.db.prepare('SELECT count(*) AS n FROM dispatch_contexts').get()?.n).toBe( - n + u - ) - reopened.close() - f.selectB() - const active = observeReceivingSql(db) - const activeAt = performance.now() - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - const activeMs = performance.now() - activeAt - active.stop() - expect(active.measurements.executions).toBeLessThanOrEqual(40 + 5 * n) - expect(active.measurements.rows).toBeLessThanOrEqual(12 + 4 * n) - let reportExecutions = 0 - let reportRows = 0 - let reportMs = 0 - for (const worker of workers) { - const observed = observeReceivingSql(db) - const at = performance.now() - await f.report(worker) - reportMs += performance.now() - at - observed.stop() - expect(db.getWorkerDispatch(worker.dispatch.id)?.state).toBe('succeeded') - expect(observed.measurements.executions).toBeLessThanOrEqual(300 + 25 * n) - expect(observed.measurements.rows).toBeLessThanOrEqual(200 + 20 * n) - reportExecutions += observed.measurements.executions - reportRows += observed.measurements.rows - } - expect(db.getUndeliveredUnreadMessages(`run:${run.id}`)).toHaveLength(n) - const pending = observeReceivingSql(db) - const pendingAt = performance.now() - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - const pendingMs = performance.now() - pendingAt - pending.stop() - expect(pending.measurements.executions).toBeLessThanOrEqual(40 + 5 * n) - expect(pending.measurements.rows).toBeLessThanOrEqual(12 + 4 * n) - const plans = [...active.measurements.plans, ...pending.measurements.plans] - expect(plans.some((plan) => plan.includes('idx_dispatch_run_status'))).toBe(true) - expect( - plans.filter((plan) => /\bSCAN (?:runs|dispatch_contexts|messages|tasks)\b/.test(plan)) - ).toEqual([]) - process.stdout.write( - `receiving-callers D=${n} P=${n} M=1 U=${u} coldIndexedRows=${n + u} coldOpenMs=${coldMs.toFixed(3)} active=${JSON.stringify(active.measurements)} activeMs=${activeMs.toFixed(3)} pending=${JSON.stringify(pending.measurements)} pendingMs=${pendingMs.toFixed(3)} reportExecutions=${reportExecutions} reportRows=${reportRows} reportMs=${reportMs.toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) - -it.each([10, 100])( - 'bounds two current mailbox roles at %i real nested candidates per role', - async (n) => { - const f = await createReceivingCallerFixture() - try { - await f.found() - const db = f.runtime.getOrchestrationDb() - db.createRun({ - objective: 'original parent', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const worker = await f.createWorker(WORKER) - for (let i = 0; i < n; i += 1) { - await f.createWorker(testOrcaSessionId(randomUUID()), WORKER) - } - const own = db.createRun({ - objective: 'worker also coordinates', - coordinatorHandle: worker.handle, - coordinatorPaneKey: worker.paneKey, - coordinatorOrcaSessionId: WORKER - }) - for (let i = 0; i < n; i += 1) { - await f.createWorker(testOrcaSessionId(randomUUID()), WORKER) - } - expect(f.runtime.mailTarget(`run:${own.id}`)?.sessionId).toBe(WORKER) - expect(f.runtime.mailTarget(`dispatch:${worker.dispatch.id}`)?.sessionId).toBe(WORKER) - f.selectB() - const observed = observeReceivingSql(db) - const began = performance.now() - expect(await f.rig.host.prospectiveAccountHome(WORKER)).toEqual(HOME_A) - const elapsedMs = performance.now() - began - observed.stop() - expect(observed.measurements.executions).toBeLessThanOrEqual(60 + 10 * n) - expect(observed.measurements.rows).toBeLessThanOrEqual(30 + 8 * n) - expect( - observed.measurements.plans.some((plan) => - plan.includes('idx_dispatch_creator_mailbox_work') - ) - ).toBe(true) - expect( - observed.measurements.plans.filter((plan) => - /\bSCAN (?:runs|dispatch_contexts|messages|tasks)\b/.test(plan) - ) - ).toEqual([]) - process.stdout.write( - `receiving-callers M=2 D=${n * 2} P=0 U=0 ${JSON.stringify(observed.measurements)} elapsedMs=${elapsedMs.toFixed(3)}\n` - ) - } finally { - await f.dispose() - } - } -) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers.test-support.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers.test-support.ts index 6c949f69f3d..6fafc38981a 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers.test-support.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-callers.test-support.ts @@ -1,12 +1,10 @@ -import { - receivingPersistedFixtures, - receivingRuntimeStore -} from './structured-agent-session-receiving-persisted.test-support' +import { join } from 'node:path' import { expect, vi } from 'vitest' +import { Store } from '../../persistence/loading-store/store' +import { ProfileStateSqliteAuthority } from '../../persistence/profile-state/profile-state-sqlite-authority' import { getAppEnvironment, setAppEnvironment } from '../../../shared/app-environment' import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' import { claudeProviderHandle } from '../../../shared/agent-session/lifecycle/agent-session-provider-handle-encoding' -import type { ClaudeAccountRecipe } from '../../../shared/agent-session-acquired-account' import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session/lifecycle/agent-session-mutation-envelope' import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' import type { AgentJournalMessageItem } from '../../../shared/agent-session/journal/agent-session-journal-types' @@ -24,7 +22,7 @@ import { structuredWorkerIdentities, structuredWorkerProcessIncarnation } from '../../runtime/structured-worker-identity' -import { structuredNativeWorkReaders } from '../../runtime/structured-native-work-readers' +import { structuredWorkerOwesWork } from '../../runtime/structured-worker-custody' import { createRestTestRig, REST_TEST_CALLER } from './structured-agent-session-rest-test-rig' import { hostTestAttachParams, @@ -32,24 +30,36 @@ import { hostTestOperationId } from './structured-agent-session-host-test-data' import { setStructuredAgentSessionHost } from './structured-agent-session-registry' +import { createClaudeAccountRouting } from './structured-agent-session-claude-account-routing.test-support' import type { StructuredAgentSessionEventSink } from './structured-agent-session-event-sink' export const PARENT = testOrcaSessionId('cfe50e96-3a95-4353-9cdc-7a652779c6e8') export const WORKER = testOrcaSessionId('4c1b8d7a-975c-4984-a2e4-8149fdd4177a') -export const HELPER = testOrcaSessionId('8e2ab9f7-0ad7-43f0-9241-539b1e4c5bc7') -export const HOME_A = { variable: 'CLAUDE_CONFIG_DIR', path: '/qa/claude/a' } -export const HOME_B = { variable: 'CLAUDE_CONFIG_DIR', path: '/qa/claude/b' } -/** Script only external adapter IO; reservation, proof, journals, RPC and native transactions are real. */ -export async function createReceivingCallerFixture(options: { reportsRecipe?: boolean } = {}) { +/** The registered attach path reads launch defaults from the runtime's profile store. */ +function receivingRuntimeStore(root: string) { + return new Store({ + dataFile: join(root, 'runtime-state.json'), + profileStateAuthority: new ProfileStateSqliteAuthority( + join(root, 'runtime-profile.db'), + 'receiving' + ) + }) +} + +/** Script only external adapter IO (the Claude process and its transcripts); the account router, + * Claude launch resolution, reservation, proof, journals, RPC and native transactions are real. */ +export async function createReceivingCallerFixture() { const previousEnvironment = getAppEnvironment() - let selected = HOME_A let runtime: ReceivingRuntime | undefined - const readers = structuredNativeWorkReaders( - () => runtime?.getOrchestrationDbIfAvailable() ?? null, - () => runtime?.getExistingOrchestrationDb() ?? null - ) - const rig = await createRestTestRig({ ...readers, launchAccountHome: async () => selected }) + const routing = createClaudeAccountRouting() + const rig = await createRestTestRig({ + // Production wiring: an assigned worker's own open Dispatch keeps its process. + hasOpenDispatch: (record) => + structuredWorkerOwesWork(runtime?.getOrchestrationDbIfAvailable() ?? null, record), + launchAccountHome: routing.launchAccountHome + }) + const accounts = routing.install(rig.root, () => rig.store) setAppEnvironment({ ...previousEnvironment, getPath: (name) => (name === 'userData' ? rig.root : previousEnvironment.getPath(name)) @@ -65,18 +75,14 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo const sinks = new Map() let generation = 0 rig.adapter.acquire.mockImplementation(async (input) => { - const recipe: ClaudeAccountRecipe = input.accountRecipe ?? { - route: 'system', - home: selected.path, - configDir: selected.path - } + // Production launch resolution picks the account, as the Claude adapter's acquisition does. + const launched = await accounts.launch(input) if (input.events) { sinks.set(input.identity.sessionId, input.events) } return { acquisitionGeneration: `caller-generation-${++generation}`, - accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: recipe.home }, - ...(options.reportsRecipe === false ? {} : { accountRecipe: recipe }), + ...launched, process: { hostId: 'local', pid: 4242, @@ -85,7 +91,8 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo }, link: { linkId: `caller-link-${generation}`, - handle: claudeProviderHandle(`provider-${input.identity.sessionId}`, null), + // A chat that has answered has a leaf, which a resume elsewhere is checked against. + handle: claudeProviderHandle(`provider-${input.identity.sessionId}`, 'leaf-1'), origin: rig.store.getRecord(input.identity.sessionId)?.providerHandleChain.length ? 'resumed' : 'created', @@ -113,7 +120,7 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo }, provider: 'claude', agent: 'claude', - accountHome: HOME_A, + accountHome: accounts.homeA, providerHandle: { kind: 'claude', sessionId: `provider-${id}`, leafUuid: null } }) const ensure = async (id = PARENT) => { @@ -189,7 +196,7 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo ) await rig.host.flushStreamedEvents(PARENT) } - const createWorker = async (id: typeof WORKER | typeof HELPER, creator = PARENT) => { + const createWorker = async (id: typeof WORKER, creator = PARENT) => { const from = caller(creator) const taskSpec = `work for ${id}` const { bindRun, helperCreator } = resolveWorkerStartRun(service, { @@ -269,16 +276,12 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo report, sinks, nudges, - selectB: () => { - selected = HOME_B - }, - ...receivingPersistedFixtures({ rig, params }), + ...accounts, + selectB: () => accounts.select('b'), found: async () => { await ensure() await rig.store.setSessionTabVisibility(PARENT, true) - if (options.reportsRecipe !== false) { - expect(rig.store.requireWritableRecord(PARENT).acquiredAccount).toBeDefined() - } + expect(rig.store.requireWritableRecord(PARENT).acquiredAccount).toBeDefined() }, dispose: async ( stopHost = () => rig.host.flushAllStreamedEvents(), @@ -286,6 +289,7 @@ export async function createReceivingCallerFixture(options: { reportsRecipe?: bo ) => { service.stopOrchestrationFederationRelay() setStructuredAgentSessionHost(null) + accounts.uninstall() structuredWorkerIdentities.clear() await stopHost() service.getOrchestrationDbIfAvailable()?.close() diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cancellation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cancellation.test.ts index a415ecc7cd4..66532c816a1 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cancellation.test.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cancellation.test.ts @@ -6,7 +6,6 @@ import { REST_TEST_CALLER } from './structured-agent-session-rest-test-rig' import { hostTestMessage, hostTestOperationId } from './structured-agent-session-host-test-data' import { createReceivingCallerFixture, - HOME_B, PARENT } from './structured-agent-session-receiving-callers.test-support' @@ -16,7 +15,7 @@ it('finishes an owned ordinary open but direct cancellation publishes no child', const release = Promise.withResolvers() try { await f.found() - await f.coldNative() + await f.rig.host.close(PARENT, 'evict') f.selectB() const original = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT)) const open = AgentSessionJournal.prototype.open @@ -51,54 +50,6 @@ it('finishes an owned ordinary open but direct cancellation publishes no child', } }) -it('a real Stop remains responsive while a background start awaits the selected resolver', async () => { - const f = await createReceivingCallerFixture() - const release = Promise.withResolvers() - try { - await f.found() - await f.rig.host.close(PARENT, 'evict') - const original = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT)) - const resolution = vi - .spyOn(f.rig.host.deps, 'launchAccountHome') - .mockImplementation(async () => { - await release.promise - return HOME_B - }) - f.rig.adapter.acquire.mockClear() - f.rig.adapter.dispatch.mockClear() - const id = await f.accept('cancel this background start') - await vi.waitFor(() => expect(resolution).toHaveBeenCalled()) - const stopped = await f.rig.host.cancel(REST_TEST_CALLER, { - envelope: { - sessionId: PARENT, - clientOperationId: hostTestOperationId(), - expectedRuntimeFence: f.rig.store.requireWritableRecord(PARENT).lease.runtimeFence, - payloadFingerprint: computeAgentSessionPayloadFingerprint({ - method: 'agentSession.cancel', - sessionId: PARENT, - fields: {} - }) - } - }) - expect(stopped).toMatchObject({ ok: true, value: { cancelled: true } }) - release.resolve() - await vi.waitFor(() => - expect(f.rig.host.collaboratorsForTests().runtimeState.startFlights.has(PARENT)).toBe(false) - ) - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - expect(f.rig.adapter.dispatch).not.toHaveBeenCalled() - expect( - f.rig.host.collaboratorsForTests().sessions.get(PARENT)?.journal.submission(id) - ).toMatchObject({ rejection: { kind: 'cancelled' } }) - expect(acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe).toEqual( - original?.recipe - ) - } finally { - release.resolve() - await f.dispose() - } -}) - it('ensure and ordinary send share the journal refusal; retry retains history without a failed spawn', async () => { const f = await createReceivingCallerFixture() try { diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-catalog.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-catalog.test.ts index 4d5ba876043..59dda1e1e33 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-catalog.test.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-catalog.test.ts @@ -1,42 +1,29 @@ -import { eraseRpcMethods, isStreamingMethod } from '../../runtime/rpc/core' -import { STRUCTURED_AGENT_SESSION_OPTIONS_READ_METHODS } from '../../runtime/rpc/methods/structured-agent-session-options-read' import { type AgentModelCatalogSuccess, AgentModelCatalogStore } from '../agent-model-catalog/agent-model-catalog-store' import type { AgentModelCatalogProbe } from '../agent-model-catalog/agent-model-catalog-discovery' -import { rm } from 'node:fs/promises' -import { describe, expect, it, vi } from 'vitest' +import { expect, it, vi } from 'vitest' import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session/lifecycle/agent-session-mutation-envelope' import { REST_TEST_CALLER } from './structured-agent-session-rest-test-rig' import { hostTestOperationId } from './structured-agent-session-host-test-data' -import { - catalogMutationDeadline as settled, - disposeCatalogMutationHost -} from './structured-agent-session-catalog-mutation.test-support' +import { catalogMutationDeadline as settled } from './structured-agent-session-catalog-mutation.test-support' import { createAgentModelCatalogService } from '../agent-model-catalog/agent-model-catalog-service' import { agentModelCatalogFingerprint, agentModelCatalogScopeFingerprint } from '../agent-model-catalog/agent-model-catalog-fingerprint' import { structuredAgentModelCatalogAccountReads } from '../../runtime/structured-agent-model-catalog-wiring' -import { readJournalSessionEpoch } from '../agent-session-journal/journal-row-table' -import { setStructuredAgentSessionHost } from './structured-agent-session-registry' import { createReceivingCallerFixture, - HOME_A, - HOME_B, PARENT } from './structured-agent-session-receiving-callers.test-support' -function catalog( - f: Awaited>, - _countSavedScope = false -) { +function catalog(f: Awaited>) { const store = new AgentModelCatalogStore() for (const [home, id] of [ - [HOME_A, 'claude-sonnet-5'], - [HOME_B, 'claude-opus-5-5[1m]'] + [f.homeA, 'claude-sonnet-5'], + [f.homeB, 'claude-opus-5-5[1m]'] ] as const) { store.recordSuccess( agentModelCatalogScopeFingerprint( @@ -67,7 +54,7 @@ function catalog( getRecord: (id) => f.rig.store.getRecord(id) ?? undefined, recordWorkspacePath: async () => f.rig.root, drivesRecord: () => true, - resolveAccountHome: async () => HOME_B, + resolveAccountHome: async () => f.homeB, ...structuredAgentModelCatalogAccountReads(() => f.rig.host), probes: { claude: Object.assign(probe, { resolve }) }, agentReadsProjectModelConfig: () => false @@ -75,195 +62,16 @@ function catalog( f.rig.host.deps.modelCatalog = service const demands = vi.spyOn(service, 'demand') const read = () => f.rig.host.readModelCatalog({ agent: 'claude', sessionId: PARENT }) - const completed = async (viaRpc = false) => { - if (viaRpc) { - const method = eraseRpcMethods(STRUCTURED_AGENT_SESSION_OPTIONS_READ_METHODS).find( - (entry) => entry.name === 'agentSession.modelCatalog' - ) - if (!method?.params || isStreamingMethod(method)) { - throw new Error('named catalog RPC is not installed') - } - await method.handler(method.params.parse({ agent: 'claude', sessionId: PARENT }), { - runtime: f.runtime - }) - } else { - await read() - } - const claim = demands.mock.results.at(-1)?.value - if (claim) { - await settled(claim, 'named catalog demand completion') - } - const request = demands.mock.calls.at(-1)?.[0] - return request ? service.snapshot(request) : { origin: 'unknown' as const } - } return { service, store, probe, resolve, demands, - read, - ids: async (viaRpc = false) => { - const result = await completed(viaRpc) - expect(result.origin).not.toBe('unknown') - if (result.origin === 'unknown') { - throw new Error('catalog unexpectedly unknown') - } - return result.models.map((model) => model.id) - } + read } } -describe('catalog consumes the constructed host receiving account', () => { - it('reads A before exact native disposition and B afterward, without the global registry', async () => { - const f = await createReceivingCallerFixture() - let service: ReturnType | undefined - try { - await f.found() - const { started } = await f.coldNative() - f.selectB() - setStructuredAgentSessionHost(null) - const c = catalog(f) - service = c.service - f.rig.adapter.acquire.mockClear() - const all = vi.spyOn(f.rig.store, 'listRecords').mockImplementation(() => { - throw new Error('global history scan') - }) - expect(await c.ids()).toEqual(['claude-sonnet-5']) - expect((await f.rig.host.readOptions(PARENT)).current.model).toBe('claude-sonnet-5') - expect(f.rig.host.hasSession(PARENT)).toBe(true) - const session = f.rig.host.collaboratorsForTests().sessions.get(PARENT) - if (!session) { - throw new Error('existing journal was not adopted') - } - const visits = vi.spyOn(session.journal, 'visitItemsWithLinkage') - await c.read() - expect(visits).not.toHaveBeenCalled() - const db = f.runtime.getOrchestrationDb() - db.failWorkerStart(started.dispatch.id, 'agent_readiness', 'never constructed a worker') - expect(await c.ids()).toEqual(['claude-opus-5-5[1m]']) - expect((await f.rig.host.readOptions(PARENT)).current.model).toBe('claude-opus-5-5[1m]') - expect(c.probe).not.toHaveBeenCalled() - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - all.mockRestore() - } finally { - service?.stop() - await f.dispose() - } - }) - - it('a proven absent journal still reads A from actual success and pre-notice work without founding one', async () => { - const f = await createReceivingCallerFixture() - let service: ReturnType | undefined - try { - await f.proveWithoutJournal() - await f.coldNative() - f.selectB() - const c = catalog(f) - service = c.service - f.rig.adapter.acquire.mockClear() - expect(await c.ids()).toEqual(['claude-sonnet-5']) - expect(readJournalSessionEpoch(f.rig.host.deps.journalDatabase.db, PARENT)).toBeNull() - expect(f.rig.host.hasSession(PARENT)).toBe(false) - expect(c.probe).not.toHaveBeenCalled() - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - } finally { - service?.stop() - await f.dispose() - } - }) - - it('real prospective read failure answers unknown instead of using B cached facts', async () => { - const f = await createReceivingCallerFixture() - let service: ReturnType | undefined - try { - await f.found() - await f.coldNative() - f.selectB() - const c = catalog(f) - service = c.service - const db = f.runtime.getOrchestrationDb() - const prepare = db.db.prepare.bind(db.db) - vi.spyOn(db.db, 'prepare').mockImplementation((sql) => { - if (sql.includes('SELECT id FROM runs WHERE coordinator_orca_session_id')) { - throw new Error('native read unavailable') - } - return prepare(sql) - }) - expect(await c.read()).toEqual({ origin: 'unknown' }) - expect(c.probe).not.toHaveBeenCalled() - expect(f.rig.host.childAccountHome(PARENT)).toBeUndefined() - } finally { - service?.stop() - await f.dispose() - } - }) - - // Real journal/native DB setup, two 2s mutations and bounded host cleanup share this budget. - it('owned permission settlement reads actual A until exact native disposition, then eligible B', async () => { - const f = await createReceivingCallerFixture() - let service: ReturnType | undefined - try { - await f.found() - const { started } = await f.coldNative() - f.selectB() - setStructuredAgentSessionHost(null) - const c = catalog(f) - service = c.service - f.rig.adapter.acquire.mockClear() - const all = vi.spyOn(f.rig.store, 'listRecords').mockImplementation(() => { - throw new Error('global history scan') - }) - const pick = async () => { - const key = 'permissionMode' - const value = 'own' - expect( - await settled( - f.rig.host.setOption(REST_TEST_CALLER, { - key, - value, - envelope: { - sessionId: PARENT, - clientOperationId: hostTestOperationId(), - expectedRuntimeFence: f.rig.store.requireWritableRecord(PARENT).lease.runtimeFence, - payloadFingerprint: computeAgentSessionPayloadFingerprint({ - method: 'agentSession.setOption', - sessionId: PARENT, - fields: { key, value } - }) - } - }), - 'receiving-account permission mutation' - ) - ).toMatchObject({ - ok: true, - value: { key, value, options: { permissionMode: 'own' } } - }) - expect(f.rig.store.requireWritableRecord(PARENT).permissionMode).toBe('own') - return undefined - } - await pick() - expect(await c.ids()).toEqual(['claude-sonnet-5']) - f.runtime - .getOrchestrationDb() - .failWorkerStart(started.dispatch.id, 'agent_readiness', 'never constructed a worker') - await pick() - expect(await c.ids()).toEqual(['claude-opus-5-5[1m]']) - expect(c.probe).not.toHaveBeenCalled() - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - expect(f.rig.adapter.dispatch).not.toHaveBeenCalled() - expect(f.rig.adapter.readOptions).not.toHaveBeenCalled() - expect(all).not.toHaveBeenCalled() - } finally { - service?.stop() - await f.dispose( - () => disposeCatalogMutationHost(f.rig), - () => rm(f.rig.root, { recursive: true, force: true }) - ) - } - }, 10_000) -}) - // These operations run the real host owner and catalog claim; only external provider IO is scripted. it('keeps newer public intent while discovery waits and reports a failed listing without holding Stop', async () => { const f = await createReceivingCallerFixture() @@ -273,7 +81,7 @@ it('keeps newer public intent while discovery waits and reports a failed listing await f.found() await f.rig.host.close(PARENT, 'evict') f.rig.adapter.acquire.mockClear() - const c = catalog(f, true) + const c = catalog(f) service = c.service c.store.expireAgent('claude') c.probe.mockImplementationOnce(() => listing.promise) @@ -330,7 +138,7 @@ it('keeps newer public intent while discovery waits and reports a failed listing expect( c.store.failureDetail( agentModelCatalogScopeFingerprint( - agentModelCatalogFingerprint({ agent: 'claude', accountHome: HOME_B, wslDistro: null }), + agentModelCatalogFingerprint({ agent: 'claude', accountHome: f.homeB, wslDistro: null }), f.rig.root ) ) @@ -369,12 +177,12 @@ it.each(['deadline', 'retirement', 'stop', 'workspace'] as const)( async (end) => { const f = await createReceivingCallerFixture() let service: ReturnType | undefined - const home = Promise.withResolvers() + const home = Promise.withResolvers() try { await f.found() await f.rig.host.close(PARENT, 'evict') f.rig.adapter.acquire.mockClear() - const c = catalog(f, true) + const c = catalog(f) service = c.service const selected = vi.spyOn(f.rig.host.deps, 'launchAccountHome').mockReturnValue(home.promise) let workspaceIdentity = 'original' @@ -408,14 +216,14 @@ it.each(['deadline', 'retirement', 'stop', 'workspace'] as const)( await vi.advanceTimersByTimeAsync(500) expect(await settled(pending, 'original scope deadline')).toEqual({ origin: 'unknown' }) } - home.resolve(HOME_B) + home.resolve(f.homeB) expect(await settled(pending, 'retired scope completion')).toEqual({ origin: 'unknown' }) expect(c.demands).not.toHaveBeenCalled() expect(c.resolve).not.toHaveBeenCalled() expect(c.probe).not.toHaveBeenCalled() expect(f.rig.adapter.acquire).not.toHaveBeenCalled() } finally { - home.resolve(HOME_B) + home.resolve(f.homeB) service?.stop() vi.useRealTimers() await f.dispose() diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cold.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cold.test.ts deleted file mode 100644 index 2ff093bc884..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-cold.test.ts +++ /dev/null @@ -1,156 +0,0 @@ -import { describe, expect, it, vi } from 'vitest' -import { acquiredAgentSessionAccount } from '../../../shared/agent-session-acquired-account' -import { readJournalSessionEpoch } from '../agent-session-journal/journal-row-table' -import { - createReceivingCallerFixture, - HOME_A, - HOME_B, - PARENT -} from './structured-agent-session-receiving-callers.test-support' - -describe('registered ensure constructs from cold conversation-owned evidence', () => { - it('opens existing native state and journal before reservation, then proves the actual A recipe', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - const original = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT)) - expect(original?.recipe.home).toBe(HOME_A.path) - await f.coldNative() - expect(f.runtime.getOrchestrationDbIfAvailable()).toBeNull() - f.selectB() - const adopts = vi.spyOn(f.rig.host.collaboratorsForTests().sessions, 'set') - const acquire = f.rig.adapter.acquire - acquire.mockClear() - expect(await f.ensure()).toMatchObject({ ok: true }) - expect(acquire).toHaveBeenCalledTimes(1) - expect(acquire.mock.calls[0]?.[0].accountRecipe).toEqual(original?.recipe) - expect( - acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe - ).toEqual(original?.recipe) - expect(f.runtime.getOrchestrationDbIfAvailable()).not.toBeNull() - expect(f.rig.host.childAccountHome(PARENT)).toEqual(HOME_A) - expect(adopts).toHaveBeenCalledTimes(1) - } finally { - await f.dispose() - } - }) - - it('a last-success receipt alone does not pin an eligible ordinary acquisition', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.rig.host.close(PARENT, 'evict') - f.selectB() - f.rig.adapter.acquire.mockClear() - expect(await f.ensure()).toMatchObject({ ok: true }) - expect(f.rig.adapter.acquire.mock.calls[0]?.[0].accountRecipe).toBeUndefined() - expect(f.rig.host.childAccountHome(PARENT)).toEqual(HOME_B) - expect( - acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe.home - ).toBe(HOME_B.path) - } finally { - await f.dispose() - } - }) - - it.each([true, false])( - 'absent journal keeps native evidence, reportsRecipe=%s', - async (reportsRecipe) => { - const f = await createReceivingCallerFixture({ reportsRecipe }) - try { - await f.proveWithoutJournal() - expect(readJournalSessionEpoch(f.rig.host.deps.journalDatabase.db, PARENT)).toBeNull() - await f.coldNative() - f.selectB() - f.rig.adapter.acquire.mockClear() - expect(await f.ensure()).toMatchObject({ ok: true }) - expect(f.rig.host.childAccountHome(PARENT)).toEqual(reportsRecipe ? HOME_A : HOME_B) - expect(f.rig.adapter.acquire.mock.calls[0]?.[0].accountRecipe?.home).toBe( - reportsRecipe ? HOME_A.path : undefined - ) - } finally { - await f.dispose() - } - } - ) - - it('an actually unreadable native DB fails the operation without constructing or overwriting A', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.coldNative() - f.selectB() - const record = f.rig.store.requireWritableRecord(PARENT) - const db = f.runtime.getExistingOrchestrationDb() - if (!db) { - throw new Error('persisted database missing') - } - const prepare = db.db.prepare.bind(db.db) - const read = vi.spyOn(db.db, 'prepare').mockImplementation((sql) => { - if (sql.includes('SELECT id FROM runs WHERE coordinator_orca_session_id')) { - throw new Error('fixture native read unavailable') - } - return prepare(sql) - }) - f.rig.adapter.acquire.mockClear() - expect(await f.ensure()).toEqual({ - ok: false, - refusal: { - code: 'agent_session_operation_invalid', - details: { ownerVerdict: 'exited' }, - ownerVerdict: 'exited', - message: "Claude couldn't restart. Send your message to try again." - } - }) - read.mockRestore() - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - const after = f.rig.store.requireWritableRecord(PARENT) - expect(after.lease.claimStatus).toBe('released') - expect(acquiredAgentSessionAccount(after)?.recipe).toEqual( - acquiredAgentSessionAccount(record)?.recipe - ) - expect(await f.ensure()).toMatchObject({ ok: true }) - expect(f.rig.host.childAccountHome(PARENT)).toEqual(HOME_A) - } finally { - await f.dispose() - } - }) - - it('direct cancellation during selected resolution starts nothing and preserves last success', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.rig.host.close(PARENT, 'evict') - const receipt = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT)) - let release: (() => void) | undefined - const waiting = new Promise((resolve) => { - release = resolve - }) - const resolveAccount = vi - .spyOn(f.rig.host.deps, 'launchAccountHome') - .mockImplementation(async () => { - await waiting - return HOME_B - }) - f.rig.adapter.acquire.mockClear() - const result = f.ensure().then( - (value) => ({ value }), - (error: unknown) => ({ error }) - ) - await vi.waitFor(() => expect(resolveAccount).toHaveBeenCalled()) - f.rig.host - .collaboratorsForTests() - .runtimeState.acquireAborts.abort(PARENT, 'stopped while starting') - release?.() - await result - expect(f.rig.adapter.acquire).not.toHaveBeenCalled() - expect( - acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT))?.recipe - ).toEqual(receipt?.recipe) - expect(f.rig.store.requireWritableRecord(PARENT).lease.claimStatus).toBe('released') - expect(readJournalSessionEpoch(f.rig.host.deps.journalDatabase.db, PARENT)).not.toBeNull() - } finally { - await f.dispose() - } - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-nested.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-nested.test.ts deleted file mode 100644 index 5e5524ddec3..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-nested.test.ts +++ /dev/null @@ -1,142 +0,0 @@ -import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key' -import { describe, expect, it, vi } from 'vitest' -import { dispatchReportMailbox } from '../../runtime/orchestration/dispatch-report-mailbox' -import { OrchestrationStructuredMailboxPointerDelivery } from '../../runtime/orchestration/structured-mailbox-pointer-delivery' -import { createStructuredMailboxPointerHost } from '../../runtime/orchestration/structured-mailbox-pointer-host' -import { HOST_TEST_NOW } from './structured-agent-session-host-test-data' -import { - createReceivingCallerFixture, - HELPER, - HOME_A, - HOME_B, - PARENT, - WORKER -} from './structured-agent-session-receiving-callers.test-support' - -/** Production report transaction -> pointer park/wake -> host start/handover/settlement. */ -describe('nested receiving work follows its current consumer', () => { - it('keeps A after creator Stop, accepts its helper result, then ordinary input acquires B', async () => { - vi.spyOn(Date, 'now').mockReturnValue(HOST_TEST_NOW) - const f = await createReceivingCallerFixture() - let unsubscribe: (() => void) | undefined - try { - await f.found() - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'nested production iteration', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const worker = await f.createWorker(WORKER) - const helper = await f.createWorker(HELPER, WORKER) - expect(helper.task.id).not.toBe(worker.task.id) - expect(dispatchReportMailbox(db, helper.dispatch)).toBe(`dispatch:${worker.dispatch.id}`) - const stopped = await f.call('orchestration.workerStop', { dispatch: worker.dispatch.id }) - expect(stopped).toMatchObject({ state: 'stopped', processAction: 'closed_agent_terminal' }) - expect(db.getDispatchContextById(helper.dispatch.id)?.status).toBe('dispatched') - expect(dispatchReportMailbox(db, helper.dispatch)).toBe(`run:${run.id}`) - await f.rig.host.close(PARENT, 'evict') - f.selectB() - f.rig.adapter.acquire.mockClear() - const ordinary = await f.send('continue while the helper works') - await f.turn(ordinary, 'running') - expect(f.rig.host.childAccountHome(PARENT)).toEqual(HOME_A) - expect(f.rig.adapter.acquire.mock.calls[0]?.[0].accountRecipe?.home).toBe(HOME_A.path) - - const nudges = f.nudges - await f.call( - 'orchestration.send', - { - from: helper.handle, - to: `run:${run.id}`, - type: 'status', - subject: 'finishing helper work' - }, - f.caller(HELPER) - ) - const batch = db.getOrCreateMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation - }) - if (!batch) { - throw new Error('real status not accepted into the current Run') - } - expect(batch.messages.map((message) => message.to_handle)).toEqual([`run:${run.id}`]) - expect(batch.messages.map((message) => message.type)).toEqual(['status']) - await f.report(helper) - expect(nudges).toHaveBeenCalledWith(`run:${run.id}`, 'worker_done') - expect(db.getWorkerDispatch(helper.dispatch.id)?.state).toBe('succeeded') - const retained = vi.fn() - const pointer = new OrchestrationStructuredMailboxPointerDelivery({ - getDb: () => db, - getMessageWaiters: () => undefined, - resolveStructuredTarget: (handle) => f.runtime.mailTarget(handle), - getCliCommand: () => 'orca-dev', - senderSnapshot: () => ({ name: null, agent: null }), - host: createStructuredMailboxPointerHost(), - onRetain: retained - }) - unsubscribe = await f.rig.host.subscribe({ - id: 'real-pointer-wake', - sessionId: PARENT, - emit: () => pointer.onJournalActivity(PARENT) - }) - const dispatches = f.rig.adapter.dispatch.mock.calls.length - expect(pointer.deliverForHandle(`run:${run.id}`)).toBe(true) - await vi.waitFor(() => - expect(retained).toHaveBeenCalledWith(expect.objectContaining({ reason: 'turn-unsettled' })) - ) - expect(f.rig.adapter.dispatch).toHaveBeenCalledTimes(dispatches) - await f.turn(ordinary, 'completed') - await vi.waitFor(() => expect(f.rig.adapter.dispatch.mock.calls.length).toBe(dispatches + 1)) - const journal = f.rig.host.collaboratorsForTests().sessions.get(PARENT)?.journal - if (!journal) { - throw new Error('actual opened parent journal missing') - } - const notice = journal.submissions().find((submission) => { - const body = journal.itemBody(agentJournalSubmissionKey(submission.clientMessageId)) - return body?.kind === 'message' && body.from?.orchestration?.message === 'mail-notice' - }) - if (!notice) { - throw new Error('production pointer did not submit its canonical notice') - } - await f.turn(notice.clientMessageId, 'running') - db.acknowledgeMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation, - deliveryId: batch.delivery.id - }) - const resultBatch = db.getOrCreateMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation - }) - if (!resultBatch) { - throw new Error('real report not accepted into the current Run') - } - expect(resultBatch.messages.map((message) => message.to_handle)).toEqual([`run:${run.id}`]) - expect(resultBatch.messages.map((message) => message.type)).toEqual(['worker_done']) - db.acknowledgeMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation, - deliveryId: resultBatch.delivery.id - }) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - await f.turn('unrelated-newer', 'completed') - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - await f.turn(notice.clientMessageId, 'completed') - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_B) - const next = await f.send('next eligible ordinary input') - expect(f.rig.host.childAccountHome(PARENT)).toEqual(HOME_B) - expect(f.rig.adapter.acquire).toHaveBeenCalledTimes(2) - await f.turn(next, 'completed') - } finally { - unsubscribe?.() - await f.dispose() - } - }) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-persisted.test-support.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-persisted.test-support.ts deleted file mode 100644 index 54032ee6712..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-persisted.test-support.ts +++ /dev/null @@ -1,116 +0,0 @@ -import { join } from 'node:path' -import { Store } from '../../persistence/loading-store/store' -import { ProfileStateSqliteAuthority } from '../../persistence/profile-state/profile-state-sqlite-authority' -import { expect } from 'vitest' -import { OrchestrationDb } from '../../runtime/orchestration/db' -import { REST_TEST_CALLER, type RestTestRig } from './structured-agent-session-rest-test-rig' -import { hostTestOperationId } from './structured-agent-session-host-test-data' -import type { AgentSessionAttachParams } from './structured-agent-session-attach' -import { HOME_A, PARENT } from './structured-agent-session-receiving-callers.test-support' - -/** The registered attach path reads launch defaults from the runtime's profile store. */ -export function receivingRuntimeStore(root: string) { - return new Store({ - dataFile: join(root, 'runtime-state.json'), - profileStateAuthority: new ProfileStateSqliteAuthority( - join(root, 'runtime-profile.db'), - 'receiving' - ) - }) -} - -/** Build persisted success/pre-notice state with the real store and database owners. */ -export function receivingPersistedFixtures({ - rig, - params -}: { - rig: RestTestRig - params: () => AgentSessionAttachParams -}) { - return { - proveWithoutJournal: async () => { - const input = params() - await rig.store.reserveOwner({ - sessionId: PARENT, - location: input.location, - provider: 'claude', - accountHome: HOME_A, - expectedFence: null, - spawnToken: 'pre-journal-spawn', - claimKeyId: 'key-1', - handoffOperationId: null, - probe: { outcome: 'reservation-unused' }, - now: rig.clock.now, - operation: { - callerKey: REST_TEST_CALLER.callerKey, - operationId: hostTestOperationId(), - fingerprint: 'pre-journal-success' - } - }) - const record = rig.store.requireWritableRecord(PARENT) - const acquired = await rig.adapter.acquire({ - identity: { - sessionId: PARENT, - workspaceId: input.location.workspaceId, - hostId: 'local', - agent: 'claude', - providerHandle: null - }, - fence: record.lease.runtimeFence, - spawnToken: 'pre-journal-spawn' - }) - await rig.store.commitProcessIdentity({ - sessionId: PARENT, - fence: record.lease.runtimeFence, - process: acquired.process, - now: rig.clock.now - }) - await rig.store.proveOwner({ - sessionId: PARENT, - fence: record.lease.runtimeFence, - ...(acquired.link ? { link: acquired.link } : {}), - now: rig.clock.now, - ...(acquired.accountRecipe - ? { - accountAcquisition: { - generation: acquired.acquisitionGeneration, - recipe: acquired.accountRecipe - } - } - : {}) - }) - await rig.store.evictProvenDeadOwner({ - sessionId: PARENT, - expectedFence: record.lease.runtimeFence, - probe: { outcome: 'exit-observed' }, - now: rig.clock.now - }) - expect(rig.store.requireWritableRecord(PARENT).lease).toMatchObject({ - claimStatus: 'released', - ownerProcess: null, - deathEvidence: { kind: 'exit-observed' } - }) - await rig.store.setSessionTabVisibility(PARENT, true) - }, - coldNative: async () => { - await rig.host.close(PARENT, 'evict') - expect(rig.host.hasSession(PARENT)).toBe(false) - const db = new OrchestrationDb(join(rig.root, 'orchestration.db')) - const run = db.createRun({ - objective: 'parent native work', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const started = db.createStartingWorkerDispatch({ - taskSpec: 'pre-notice', - taskRunId: run.id, - creator: { kind: 'session', orcaSessionId: PARENT }, - maxDepth: 9, - startOptions: {} - }) - db.close() - return { run, started } - } - } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-recipient.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-recipient.test.ts deleted file mode 100644 index 0de8373de7a..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-recipient.test.ts +++ /dev/null @@ -1,146 +0,0 @@ -import { describe, expect, it } from 'vitest' -import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' -import { dispatchReportMailbox } from '../../runtime/orchestration/dispatch-report-mailbox' -import { - createReceivingCallerFixture, - HELPER, - HOME_A, - HOME_B, - PARENT, - WORKER -} from './structured-agent-session-receiving-callers.test-support' - -const NEXT = testOrcaSessionId('d2e4056e-2cf2-4e9f-958a-173f72acb592') - -describe('receiving ownership uses current canonical mailbox and consumer', () => { - it('hands actual unread helper mail from a stopped creator to its Run, then fences the old Run consumer', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.ensure(NEXT) - await f.rig.store.setSessionTabVisibility(NEXT, true) - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'handback and takeover', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const worker = await f.createWorker(WORKER) - const helper = await f.createWorker(HELPER, WORKER) - f.selectB() - expect(await f.rig.host.prospectiveAccountHome(WORKER)).toEqual(HOME_A) - await f.report(helper) - const message = db.getUndeliveredUnreadMessages(`dispatch:${worker.dispatch.id}`)[0] - if (!message) { - throw new Error('canonical report was not sent to its live creator') - } - expect(message.to_handle).toBe(dispatchReportMailbox(db, helper.dispatch)) - expect(f.runtime.mailTarget(message.to_handle)?.sessionId).toBe(WORKER) - expect( - await f.call('orchestration.workerStop', { dispatch: worker.dispatch.id }) - ).toMatchObject({ state: 'stopped' }) - expect(db.getMessageById(message.id)?.to_handle).toBe(`run:${run.id}`) - expect(f.runtime.mailTarget(`run:${run.id}`)?.sessionId).toBe(PARENT) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - const old = db.getOrCreateMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation - }) - if (!old) { - throw new Error('old current consumer could not check real handback mail') - } - const rebound = db.bindRun({ - runId: run.id, - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: NEXT - }) - if (!rebound) { - throw new Error('supported Run takeover failed') - } - expect(rebound.consumer_generation).toBeGreaterThan(run.consumer_generation) - expect(f.runtime.mailTarget(`run:${run.id}`)?.sessionId).toBe(NEXT) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_B) - expect(await f.rig.host.prospectiveAccountHome(NEXT)).toEqual(HOME_A) - expect(() => - db.acknowledgeMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: run.consumer_generation, - deliveryId: old.delivery.id - }) - ).toThrow() - const current = db.getOrCreateMailboxDelivery({ - runId: run.id, - mailboxHandle: `run:${run.id}`, - consumerGeneration: rebound.consumer_generation - }) - expect(current?.messages.map((row) => row.id)).toContain(message.id) - } finally { - await f.dispose() - } - }) - - it.each(['settled', 'missing', 'wrong-run', 'null'] as const)( - 'accepts the actual report with a %s creator shape and old Task generation', - async (shape) => { - const f = await createReceivingCallerFixture() - try { - await f.found() - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'old canonical creator shapes', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - const worker = await f.createWorker(WORKER) - const helper = await f.createWorker(HELPER, WORKER) - await f.call('orchestration.workerStop', { dispatch: worker.dispatch.id }) - if (shape !== 'settled') { - let creator: string | null = null - if (shape === 'missing') { - creator = 'dispatch_old_missing' - } - if (shape === 'wrong-run') { - const other = db.createRun({ - objective: 'different Run', - coordinatorHandle: null, - coordinatorPaneKey: null - }) - creator = db.createStartingWorkerDispatch({ - taskSpec: 'other active creator', - taskRunId: other.id, - creator: { kind: 'system' }, - maxDepth: 9, - startOptions: {} - }).dispatch.id - } - // Persisted older/imported row shapes; report admission and Task lifetime remain production-owned. - db.db - .prepare('UPDATE dispatch_contexts SET creator_dispatch_id = ? WHERE id = ?') - .run(creator, helper.dispatch.id) - } - db.db - .prepare('UPDATE tasks SET created_by_run_generation = ? WHERE id = ?') - .run(run.consumer_generation - 1, helper.task.id) - const row = db.getDispatchContextById(helper.dispatch.id) - if (!row) { - throw new Error('real helper missing') - } - expect(dispatchReportMailbox(db, row)).toBe(`run:${run.id}`) - f.selectB() - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - await f.report(helper) - expect(db.getWorkerDispatch(helper.dispatch.id)?.state).toBe('succeeded') - const message = db.getUndeliveredUnreadMessages(`run:${run.id}`)[0] - expect(message?.to_handle).toBe(`run:${run.id}`) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - } finally { - await f.dispose() - } - } - ) -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-routes.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-routes.test.ts deleted file mode 100644 index f9aebcbf53d..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-routes.test.ts +++ /dev/null @@ -1,127 +0,0 @@ -import { expect, it } from 'vitest' -import { ORCHESTRATION_FEDERATION_LIFECYCLE_SETTLEMENT_PROTOCOL_VERSION } from '../../../shared/protocol-version' -import { testOrcaSessionId } from '../../../shared/orca-session-address-test-fixture' -import { acquiredAgentSessionAccount } from '../../../shared/agent-session-acquired-account' -import { hostTestOperationId } from './structured-agent-session-host-test-data' -import { - createReceivingCallerFixture, - HOME_A, - HOME_B, - PARENT -} from './structured-agent-session-receiving-callers.test-support' - -const SUCCESSOR = testOrcaSessionId('2842b48e-8a73-443a-99fb-810bf7eb09ce') - -it('routes an imported committed clear lineage to its current visible receiver, using its own successful receipt', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - await f.ensure(SUCCESSOR) - await f.rig.store.setSessionTabVisibility(SUCCESSOR, true) - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'lineage receiving work', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - db.createStartingWorkerDispatch({ - taskSpec: 'still owed to this conversation', - taskRunId: run.id, - creator: { kind: 'session', orcaSessionId: PARENT }, - maxDepth: 9, - startOptions: {} - }) - await f.rig.host.close(PARENT, 'evict') - // Stored older clear shape, written through the real record owner; no caller admission is changed. - await f.rig.store.transitionHandoff(PARENT, (record) => ({ - ...record, - conversationCommand: { - command: 'clear', - state: 'completed', - phase: 'committed', - runtimeFence: record.lease.runtimeFence, - callerKey: 'older-clear-client', - operationId: hostTestOperationId(), - replacementSessionId: SUCCESSOR - } - })) - await f.rig.store.setSessionTabVisibility(PARENT, false) - f.selectB() - expect(f.runtime.mailTarget(`run:${run.id}`)?.sessionId).toBe(SUCCESSOR) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_B) - expect(await f.rig.host.prospectiveAccountHome(SUCCESSOR)).toEqual(HOME_A) - const parent = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(PARENT)) - const successor = acquiredAgentSessionAccount(f.rig.store.requireWritableRecord(SUCCESSOR)) - expect(successor?.generation).not.toBe(parent?.generation) - await f.rig.host.close(SUCCESSOR, 'evict') - await f.rig.store.setSessionTabVisibility(SUCCESSOR, false) - expect(f.runtime.mailTarget(`run:${run.id}`)).toBeNull() - expect(await f.rig.host.prospectiveAccountHome(SUCCESSOR)).toEqual(HOME_B) - } finally { - await f.dispose() - } -}) - -it('a real root-remote relay import transfers pre-notice work into the home current mailbox', async () => { - const f = await createReceivingCallerFixture() - try { - await f.found() - const db = f.runtime.getOrchestrationDb() - const run = db.createRun({ - objective: 'remote root result', - coordinatorHandle: null, - coordinatorPaneKey: null, - coordinatorOrcaSessionId: PARENT - }) - f.runtime.stopOrchestrationFederationRelay() - const worker = db.createStartingWorkerDispatch({ - taskSpec: 'remote work', - taskRunId: run.id, - creator: { kind: 'session', orcaSessionId: PARENT }, - maxDepth: 9, - startOptions: {}, - federation: { - environmentId: 'remote-environment', - environmentName: 'paired worker', - peerFingerprint: 'fixture-peer', - protocolVersion: ORCHESTRATION_FEDERATION_LIFECYCLE_SETTLEMENT_PROTOCOL_VERSION - } - }) - f.selectB() - expect(f.runtime.mailTarget(`run:${run.id}`)?.sessionId).toBe(PARENT) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - const imported = db.importFederatedRelayItem({ - dispatchId: worker.dispatch.id, - sequence: 1, - message: { - id: 'relay_root_result', - runId: run.id, - from: `dispatch:${worker.dispatch.id}`, - to: `run:${run.id}`, - subject: 'complete', - body: 'real relay input', - type: 'worker_done', - priority: 'normal', - payload: JSON.stringify({ - taskId: worker.task.id, - dispatchId: worker.dispatch.id, - outcome: 'succeeded' - }) - }, - lifecycle: { - kind: 'worker_report', - taskId: worker.task.id, - outcome: 'succeeded', - result: 'complete' - } - }) - expect(imported.lifecycle).toMatchObject({ action: 'settled', outcome: 'succeeded' }) - expect(db.getMessageById(imported.message.id)?.to_handle).toBe(`run:${run.id}`) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_A) - db.markAsRead([imported.message.id]) - expect(await f.rig.host.prospectiveAccountHome(PARENT)).toEqual(HOME_B) - } finally { - await f.dispose() - } -}) diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-sql.test-support.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-sql.test-support.ts deleted file mode 100644 index b0d2e25e56c..00000000000 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-receiving-sql.test-support.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { vi } from 'vitest' -import type { SqliteBindings } from '../../sqlite/sqlite-statement' -import type { OrchestrationDb } from '../../runtime/orchestration/db' - -/** Count actual SQL calls/results and their plans; EXPLAIN itself is excluded. */ -export function observeReceivingSql(db: OrchestrationDb) { - const prepare = db.db.prepare.bind(db.db) - const instrumented = new WeakSet() - const restores: (() => void)[] = [] - const plans: string[] = [] - const measurements = { prepares: 0, executions: 0, rows: 0, allRows: 0, plans } - const explain = (sql: string, args: SqliteBindings) => { - if (!/^\s*(SELECT|WITH)\b/i.test(sql)) { - return - } - for (const row of prepare(`EXPLAIN QUERY PLAN ${sql}`).all(...args)) { - if (typeof row.detail === 'string') { - measurements.plans.push(row.detail) - } - } - } - const spy = vi.spyOn(db.db, 'prepare').mockImplementation((sql) => { - measurements.prepares += 1 - const statement = prepare(sql) - if (instrumented.has(statement)) { - return statement - } - instrumented.add(statement) - const all = statement.all.bind(statement) - const get = statement.get.bind(statement) - const run = statement.run.bind(statement) - const allSpy = vi.spyOn(statement, 'all').mockImplementation((...args) => { - measurements.executions += 1 - explain(sql, args) - const rows = all(...args) - measurements.rows += rows.length - measurements.allRows += rows.length - return rows - }) - const getSpy = vi.spyOn(statement, 'get').mockImplementation((...args) => { - measurements.executions += 1 - explain(sql, args) - const row = get(...args) - measurements.rows += row === undefined ? 0 : 1 - return row - }) - const runSpy = vi.spyOn(statement, 'run').mockImplementation((...args) => { - measurements.executions += 1 - return run(...args) - }) - restores.push( - () => allSpy.mockRestore(), - () => getSpy.mockRestore(), - () => runSpy.mockRestore() - ) - return statement - }) - return { - measurements, - stop: () => { - spy.mockRestore() - for (const restore of restores.toReversed()) { - restore() - } - } - } -} diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-contract.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-contract.ts index 1a5d9b9302f..ee927c4399b 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-contract.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-contract.ts @@ -1,4 +1,3 @@ -import type { ClaudeAccountRecipe } from '../../../shared/agent-session-acquired-account' // Adapter-reachable contract must remain free of host and Node-only process dependencies. import type { AgentSessionJournalIdentity } from '../../../shared/agent-session-journal-identity' @@ -31,7 +30,6 @@ export type StructuredAgentSessionStartupAttempt = { /** Saved launch intent, never catalog guesses. */ readonly options?: Readonly> readonly permissionMode?: AgentChatPermissionChoice - readonly accountRecipe?: ClaudeAccountRecipe /** Provider events may begin before spawn returns. */ readonly events?: StructuredAgentSessionEventSink /** Attempt-scoped background evidence; adapters use registration reporting when absent. */ diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt.ts index be9f06e471a..0cdeb047a6f 100644 --- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt.ts +++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt.ts @@ -1,4 +1,3 @@ -import type { ClaudeAccountRecipe } from '../../../shared/agent-session-acquired-account' import { randomUUID } from 'node:crypto' import type { SubmissionRejectionFact } from '../../../shared/agent-session/failures/agent-session-failure' import { @@ -23,7 +22,6 @@ export function mintStructuredAgentSessionStartupAttempt(input: { identity: AgentSessionJournalIdentity spawnToken: string permissionMode?: AgentChatPermissionChoice - accountRecipe?: ClaudeAccountRecipe events?: StructuredAgentSessionEventSink signal?: AbortSignal startupOptions?: Readonly> @@ -44,7 +42,6 @@ export function mintStructuredAgentSessionStartupAttempt(input: { }, ...(options ? { options } : {}), ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}), - ...(input.accountRecipe ? { accountRecipe: input.accountRecipe } : {}), ...(input.events ? { events: input.events } : {}), ...(input.signal ? { signal: input.signal } : {}) } diff --git a/src/main/runtime/agent-session-acquired-account.test.ts b/src/main/runtime/agent-session-acquired-account.test.ts index be2fe33a843..85c1390ef72 100644 --- a/src/main/runtime/agent-session-acquired-account.test.ts +++ b/src/main/runtime/agent-session-acquired-account.test.ts @@ -1,8 +1,3 @@ -import { - providerContextBoundaryForClear, - type AgentSessionConversationClear -} from './agent-session/records/agent-session-conversation-command-record' -import { structuredAgentSessionReceivingAccount } from '../native-chat/agent-session-wire/structured-agent-session-receiving-account' import { describe, expect, it } from 'vitest' import { acquiredAgentSessionAccount, @@ -10,36 +5,55 @@ import { } from '../../shared/agent-session-acquired-account' import { agentSessionConversationView } from '../../shared/agent-session-conversation-view' import { - createReceivingAccountFixture, - RECEIVING_A, - SELECTED_B -} from '../native-chat/agent-session-wire/structured-agent-session-receiving-account.test-support' -import { openTestAgentSessionRecordStore } from './agent-session/records/agent-session-record-store-test-harness' + agentSessionLeaseFixture, + agentSessionRecordFixture +} from '../../shared/agent-session/lifecycle/agent-session-record.test-fixture' +import { createRestTestRig } from '../native-chat/agent-session-wire/structured-agent-session-rest-test-rig' +import { + openTestAgentSessionRecordStore, + seedTestAgentSessionRecordStore +} from './agent-session/records/agent-session-record-store-test-harness' import { proveAgentSessionOwner, withLease } from './agent-session/ownership/agent-session-lease-transitions' -import { prepareClaudeReceivingAccount } from '../claude/claude-receiving-account' + +const RECEIVING_A = '/qa/claude-profiles/qa-a/home' async function releasedFixture() { - const f = await createReceivingAccountFixture() - await f.store.reconcileOnRestart({ - sessionId: f.root, + const rig = await createRestTestRig() + const record = withAcquiredAgentSessionAccount( + agentSessionRecordFixture( + agentSessionLeaseFixture({ + sessionId: '6e1b4ae5-2354-4ca5-999e-647deeb23894', + runtimeFence: 2 + }) + ), + { + generation: 'generation-2', + recipe: { route: 'system', home: RECEIVING_A, configDir: RECEIVING_A } + } + ) + const root = record.sessionId + await seedTestAgentSessionRecordStore(rig.root, { records: [record] }) + const store = await openTestAgentSessionRecordStore(rig.root) + await store.reconcileOnRestart({ + sessionId: root, probe: async () => ({ outcome: 'exit-observed' }), now: 40_000 }) - const record = f.store.getRecord(f.root) - if (!record) { + const released = store.getRecord(root) + if (!released) { throw new Error('record missing after reconciliation') } - return { ...f, released: record } + return { rig, store, root, released, dispose: () => rig.dispose() } } describe('actual acquired account receipt in the fenced record owner', () => { it('reloads the last success across a proven release and reservation, then co-writes the next success', async () => { const f = await releasedFixture() try { - expect(acquiredAgentSessionAccount(f.released, 'local')?.recipe.home).toBe(RECEIVING_A.path) + expect(acquiredAgentSessionAccount(f.released, 'local')?.recipe.home).toBe(RECEIVING_A) expect(acquiredAgentSessionAccount(f.released, 'another-host')).toBeNull() expect(acquiredAgentSessionAccount({ ...f.released, sessionId: 'another-chat' })).toBeNull() const reserved = await f.store.reserveOwner({ @@ -64,7 +78,7 @@ describe('actual acquired account receipt in the fenced record owner', () => { if (!current) { throw new Error('reservation missing') } - expect(acquiredAgentSessionAccount(current)?.recipe.home).toBe(RECEIVING_A.path) + expect(acquiredAgentSessionAccount(current)?.recipe.home).toBe(RECEIVING_A) await f.store.commitProcessIdentity({ sessionId: f.root, fence: current.lease.runtimeFence, @@ -94,11 +108,6 @@ describe('actual acquired account receipt in the fenced record owner', () => { expect(acquiredAgentSessionAccount(reloaded)?.recipe).toEqual(recipe) expect(acquiredAgentSessionAccount(reloaded)?.fence).toBe(current.lease.runtimeFence) expect(agentSessionConversationView(reloaded)).not.toHaveProperty('acquiredAccount') - const env = { CLAUDE_CONFIG_DIR: '/selected/b', PATH: '/usr/bin' } - expect(await prepareClaudeReceivingAccount(undefined, env, '/founding/c', recipe)).toEqual( - recipe - ) - expect(env).toEqual({ CLAUDE_CONFIG_DIR: '/custom/receiving', PATH: '/usr/bin' }) } finally { await f.dispose() } @@ -129,7 +138,7 @@ describe('actual acquired account receipt in the fenced record owner', () => { ownerFence: reserved.lease.runtimeFence } }) - expect(acquiredAgentSessionAccount(failed)?.recipe.home).toBe(RECEIVING_A.path) + expect(acquiredAgentSessionAccount(failed)?.recipe.home).toBe(RECEIVING_A) const process = { hostId: 'local', pid: 4242, processStartTimeMs: 50_000, spawnToken: 'next' } const proving = withLease(reserved, { ...reserved.lease, ownerProcess: process }) // Older proof preserves unknown extension bytes but does not observe the successful new construction. @@ -160,52 +169,4 @@ describe('actual acquired account receipt in the fenced record owner', () => { await f.dispose() } }) - it('clears exact response ownership with the existing fenced record/journal receipt, retaining created work', async () => { - const f = await releasedFixture() - try { - const message = f.finish(f.start()) - const next = await f.submit(f.body(message)) - f.session.child = null - expect( - (await structuredAgentSessionReceivingAccount(f.deps, f.released, f.session, next)).home - ).toEqual(RECEIVING_A) - const clear: AgentSessionConversationClear = { - sessionId: f.root, - fence: f.released.lease.runtimeFence, - now: 40_001, - command: { - command: 'clear', - phase: 'committed', - state: 'completed', - runtimeFence: f.released.lease.runtimeFence, - callerKey: 'client', - operationId: '1800000000000-00000000000000000000000000000002' - } - } - const operation = { - callerKey: clear.command.callerKey, - operationId: clear.command.operationId - } - await f.store.admitOperation({ ...operation, fingerprint: 'clear', now: 40_001 }) - await f.journal.context.clear( - providerContextBoundaryForClear(clear), - f.store.conversationReceipts.clear(() => clear, operation) - ) - const current = f.store.getRecord(f.root) - if (!current) { - throw new Error('record missing after clear') - } - expect(current.providerHandleChain).toEqual([]) - expect(acquiredAgentSessionAccount(current)?.recipe.home).toBe(RECEIVING_A.path) - expect( - (await structuredAgentSessionReceivingAccount(f.deps, current, f.session)).home - ).toEqual(SELECTED_B) - f.start() - expect( - (await structuredAgentSessionReceivingAccount(f.deps, current, f.session)).home - ).toEqual(RECEIVING_A) - } finally { - await f.dispose() - } - }) }) diff --git a/src/main/runtime/agent-session-record-lineage.ts b/src/main/runtime/agent-session-record-lineage.ts deleted file mode 100644 index e5c6502f650..00000000000 --- a/src/main/runtime/agent-session-record-lineage.ts +++ /dev/null @@ -1,34 +0,0 @@ -import type Database from '../sqlite/sync-database' -import type { AgentSessionRecord } from '../../shared/agent-session/lifecycle/agent-session-record' - -/** Indexed reverse links cover historical clear successors without scanning every conversation. */ -export function agentSessionRecordLineage( - db: Database.Database, - record: AgentSessionRecord, - getRecord: (id: string) => AgentSessionRecord | null -): AgentSessionRecord[] { - const records = [record] - const seen = new Set([record.sessionId]) - const prior = db.prepare(`SELECT session_id FROM agent_session_records - WHERE CASE WHEN json_valid(record_json) THEN json_extract(record_json, '$.conversationCommand.replacementSessionId') END = ?`) - for (let current = record; ;) { - const rows = prior.all(current.sessionId) - if ( - rows.length !== 1 || - typeof rows[0].session_id !== 'string' || - seen.has(rows[0].session_id) - ) { - return records.toReversed() - } - const earlier = getRecord(rows[0].session_id) - if ( - earlier?.conversationCommand?.command !== 'clear' || - earlier.conversationCommand.phase !== 'committed' - ) { - return records.toReversed() - } - seen.add(earlier.sessionId) - records.push(earlier) - current = earlier - } -} diff --git a/src/main/runtime/agent-session/records/agent-session-record-store.ts b/src/main/runtime/agent-session/records/agent-session-record-store.ts index 1e48b60b52d..fd254bcdb51 100644 --- a/src/main/runtime/agent-session/records/agent-session-record-store.ts +++ b/src/main/runtime/agent-session/records/agent-session-record-store.ts @@ -1,5 +1,3 @@ -import { agentSessionRecordLineage } from '../../agent-session-record-lineage' -import type Database from '../../../sqlite/sync-database' import { createAgentSessionOwnerProof } from '../../agent-session-owner-proof' import { backfillAgentSessionPermissionModes } from '../ownership/agent-session-permission-backfill' import { createAgentSessionConversationReceipts } from '../agent-session-conversation-receipts' @@ -91,8 +89,7 @@ export class AgentSessionRecordStore extends AgentSessionRecordTabs { private constructor( transactions: AgentSessionStoreTransactions, - readonly hostId: string, - private readonly database: Database.Database + readonly hostId: string ) { super(transactions) this.founding = createAgentSessionFoundingStore(transactions, this.firstRecordListeners) @@ -112,7 +109,7 @@ export class AgentSessionRecordStore extends AgentSessionRecordTabs { args.hostId, args.legacySessionTabIds ) - return new AgentSessionRecordStore(transactions, args.hostId, args.journalDatabase.db) + return new AgentSessionRecordStore(transactions, args.hostId) } private get state(): AgentSessionStoreState { @@ -130,9 +127,6 @@ export class AgentSessionRecordStore extends AgentSessionRecordTabs { getRecord = (sessionId: string): AgentSessionRecord | null => this.state.records.get(sessionId) ?? null - lineageRecords = (record: AgentSessionRecord) => - agentSessionRecordLineage(this.database, record, this.getRecord) - getConversation = (sessionId: string) => getAgentSessionConversation(this.state, sessionId) listConversations = () => listAgentSessionConversations(this.state) selectWritableRecord = (sessionId: string) => diff --git a/src/main/runtime/orchestration/structured-parent-account-work.ts b/src/main/runtime/orchestration/structured-parent-account-work.ts deleted file mode 100644 index 77078fc23ba..00000000000 --- a/src/main/runtime/orchestration/structured-parent-account-work.ts +++ /dev/null @@ -1,154 +0,0 @@ -import { structuredWorkerAddressable } from '../structured-worker-custody' -import { isOrcaSessionId } from '../../../shared/orca-session-address' -import type { AgentSessionRecord } from '../../../shared/agent-session/lifecycle/agent-session-record' -import type { OrchestrationDb } from './db' -import { currentRunCoordinatorOrcaSessionId } from './db/runs/run-coordinator-orca-session' -import { dispatchReportMailbox } from './dispatch-report-mailbox' -import { - addressableSessionParty, - structuredSessionMailReach -} from './structured-session-mail-address' -import type { AgentSessionRecordReader } from './structured-session-lineage' - -export type NativeResponseEvidence = { pending: Iterable; disposed: ReadonlySet } - -/** Current canonical recipients own future reports; original creator provenance does not. */ -export function structuredParentAccountWork( - db: OrchestrationDb | null, - record: AgentSessionRecord, - root: string, - response: NativeResponseEvidence, - reader: AgentSessionRecordReader -): boolean { - if (!db || !isOrcaSessionId(root)) { - return false - } - const original = reader.getRecord(root) - const reach = original && structuredSessionMailReach(reader, original, db, reader) - if (!reach || reach.kind !== 'reachable' || reach.session.sessionId !== record.sessionId) { - return false - } - const party = addressableSessionParty(root, db, reader) - if (!party) { - return false - } - if ( - party.terminalHandle && - !structuredWorkerAddressable( - db, - { - sessionId: reach.session.sessionId, - record: reach.session, - lineage: reader.listRecords().map((item) => item.sessionId) - }, - db.getWorkerTerminalResourceByHandle(party.terminalHandle), - { - getPersistedVisibleSessionTabIndex: () => - reader.getVisibleSessionTabIndex?.() ?? { present: false, sessionIds: [] } - } - ) - ) { - return false - } - const mailboxes = new Map() - const runs = new Set() - const dispatches = new Set() - const add = (runId: string, mailbox: string) => { - mailboxes.set(`${runId}\0${mailbox}`, { runId, mailbox }) - } - const runCandidates = db.db - .prepare(`SELECT id FROM runs WHERE coordinator_orca_session_id = ? - UNION SELECT id FROM runs WHERE coordinator_handle = ?`) - .all(root, party.terminalHandle) - for (const run of party.paneKey ? db.runsBoundToPane(party.paneKey) : []) { - runCandidates.push({ id: run.id }) - } - for (const candidate of runCandidates) { - if (typeof candidate.id !== 'string') { - continue - } - const run = db.getRunRaw(candidate.id) - if ( - run && - (run.coordinator_handle !== null - ? run.coordinator_handle === party.terminalHandle - : currentRunCoordinatorOrcaSessionId(run) === root) - ) { - runs.add(run.id) - add(run.id, `run:${run.id}`) - } - } - const assigned = db.db - .prepare(`SELECT id FROM dispatch_contexts - WHERE assignee_orca_session_id = ? AND status IN ('pending', 'dispatched') - UNION SELECT id FROM dispatch_contexts WHERE assignee_handle = ? AND status IN ('pending', 'dispatched')`) - .all(root, party.address) - for (const candidate of assigned) { - if (typeof candidate.id !== 'string') { - continue - } - const dispatch = db.getDispatchContextById(candidate.id) - if (dispatch?.assignee_handle === party.address) { - dispatches.add(dispatch.id) - add(dispatch.run_id, `dispatch:${dispatch.id}`) - } - } - const candidates = new Set() - const byRun = db.db.prepare( - `SELECT id FROM dispatch_contexts WHERE run_id = ? AND status IN ('pending', 'dispatched')` - ) - const byCreator = db.db.prepare( - `SELECT id FROM dispatch_contexts WHERE creator_dispatch_id = ? AND status IN ('pending', 'dispatched')` - ) - for (const rows of [ - ...Array.from(runs, (id) => byRun.all(id)), - ...Array.from(dispatches, (id) => byCreator.all(id)) - ]) { - for (const row of rows) { - if (typeof row.id === 'string') { - candidates.add(row.id) - } - } - } - for (const id of candidates) { - const dispatch = db.getDispatchContextById(id) - if (dispatch && mailboxes.has(`${dispatch.run_id}\0${dispatchReportMailbox(db, dispatch)}`)) { - return true - } - } - const unread = db.db.prepare(`SELECT id FROM messages WHERE run_id = ? AND to_handle = ? - AND type = 'worker_done' AND read = 0 AND delivered_at IS NULL AND delivery_contract <> 'audit_only'`) - const direct = db.db.prepare(`SELECT id FROM messages WHERE to_handle = ? - AND type = 'worker_done' AND read = 0 AND delivered_at IS NULL AND delivery_contract <> 'audit_only'`) - const exact = db.db - .prepare(`SELECT run_id, to_handle FROM messages WHERE id = ? AND type = 'worker_done' - AND delivery_contract <> 'audit_only'`) - for (const { runId, mailbox } of mailboxes.values()) { - if ( - unread - .all(runId, mailbox) - .some((message) => typeof message.id === 'string' && !response.disposed.has(message.id)) - ) { - return true - } - } - if ( - direct - .all(party.address) - .some((message) => typeof message.id === 'string' && !response.disposed.has(message.id)) - ) { - return true - } - // Acknowledgement does not dispose a response already accepted by the current recipient. - for (const id of response.pending) { - const message = exact.get(id) - if ( - message && - (message.to_handle === party.address || - mailboxes.has(`${String(message.run_id)}\0${String(message.to_handle)}`)) - ) { - return true - } - } - return false -} diff --git a/src/main/runtime/session-tabs/structured-session-account-home-perf.test.ts b/src/main/runtime/session-tabs/structured-session-account-home-perf.test.ts index c24e055da38..0e2b1ea62b9 100644 --- a/src/main/runtime/session-tabs/structured-session-account-home-perf.test.ts +++ b/src/main/runtime/session-tabs/structured-session-account-home-perf.test.ts @@ -1,4 +1,5 @@ import * as fs from 'node:fs' +import * as fsp from 'node:fs/promises' import { tmpdir } from 'node:os' import { join } from 'node:path' import { performance } from 'node:perf_hooks' @@ -21,6 +22,10 @@ vi.mock('node:fs', async (original) => { readdirSync: vi.fn(actual.readdirSync) } }) +vi.mock('node:fs/promises', async (original) => { + const actual = await original() + return { ...actual, stat: vi.fn(actual.stat), readFile: vi.fn(actual.readFile) } +}) vi.mock('../../orca-profiles/profile-storage-paths', async () => { const { tmpdir } = await import('node:os') return { getProfileUserDataPath: () => tmpdir() } @@ -37,7 +42,12 @@ afterEach(() => { }) it.each([25, 250])('bounds desired-home reads with %i managed accounts', async (accounts) => { - for (const signedIn of [true, false]) { + for (const [signedIn, concurrent] of [ + [true, false], + [false, false], + [true, true], + [false, true] + ]) { for (const deliveries of [10, 100]) { const root = fs.mkdtempSync(join(tmpdir(), 'orca-account-read-perf-')) roots.push(root) @@ -98,7 +108,45 @@ it.each([25, 250])('bounds desired-home reads with %i managed accounts', async ( structuredAgentLaunchEnv: () => ({}) } ) - const reads = vi.spyOn(router, 'routedHome') + const reads = vi.spyOn(router, 'selectedProfile') + for (const spy of [ + fs.statSync, + fs.lstatSync, + fs.existsSync, + fs.readFileSync, + fs.readdirSync, + fsp.stat, + fsp.readFile + ]) { + vi.mocked(spy).mockClear() + } + accountVisits = 0 + selectionReads = 0 + const record = agentSessionRecordFixture() + const deliver = () => runtime.resolveStructuredAgentLaunchAccountHome(record) + const answers: (AgentSessionAccountHome | null)[] = [] + const started = performance.now() + if (concurrent) { + // Many chats reading at once on a cold cache, before any read has finished. + answers.push(...(await Promise.all(Array.from({ length: deliveries }, deliver)))) + } else { + for (let delivery = 0; delivery < deliveries; delivery += 1) { + answers.push(await deliver()) + } + } + const elapsedMs = performance.now() - started + expect(answers).toEqual( + Array.from({ length: deliveries }, () => ({ + variable: 'CLAUDE_CONFIG_DIR', + path: signedIn ? selectedHome : systemHome + })) + ) + const stats = vi.mocked(fsp.stat).mock.calls.length + const stateReads = vi.mocked(fsp.readFile).mock.calls.length + expect(reads).toHaveBeenCalledTimes(deliveries) + expect(selectionReads).toBe(deliveries) + expect(accountVisits).toBe(signedIn ? 0 : accounts * deliveries) + // Chat reads run on main once per options read and send: nothing here may block it. for (const spy of [ fs.statSync, fs.lstatSync, @@ -106,41 +154,25 @@ it.each([25, 250])('bounds desired-home reads with %i managed accounts', async ( fs.readFileSync, fs.readdirSync ]) { - vi.mocked(spy).mockClear() + expect(spy).not.toHaveBeenCalled() } - accountVisits = 0 - selectionReads = 0 - const record = agentSessionRecordFixture() - let answer: AgentSessionAccountHome | null = null - const started = performance.now() - for (let delivery = 0; delivery < deliveries; delivery += 1) { - answer = await runtime.resolveStructuredAgentLaunchAccountHome(record) + // Cold first read (shared by concurrent readers), then metadata-validated login cache. + expect(stateReads).toBe(1) + expect(vi.mocked(fsp.readFile).mock.calls[0][0]).toBe(stateFile) + if (concurrent) { + // Claude rewrote the file: one more read for the new revision, however many readers. + fs.writeFileSync(stateFile, `${state} `) + await Promise.all(Array.from({ length: deliveries }, deliver)) + expect(vi.mocked(fsp.readFile).mock.calls.length).toBe(2) } - const elapsedMs = performance.now() - started - expect(answer).toEqual({ - variable: 'CLAUDE_CONFIG_DIR', - path: signedIn ? selectedHome : systemHome - }) - const stats = vi.mocked(fs.statSync).mock.calls.length - const directoryStats = vi.mocked(fs.lstatSync).mock.calls.length - const stateReads = vi.mocked(fs.readFileSync).mock.calls.length - expect(reads).toHaveBeenCalledTimes(deliveries) - expect(selectionReads).toBe(deliveries) - expect(accountVisits).toBe(signedIn ? 0 : accounts * deliveries) - expect(stats).toBe(signedIn ? deliveries : 2 * deliveries) - expect(directoryStats).toBe(signedIn ? deliveries : 0) - expect(vi.mocked(fs.existsSync).mock.calls.length).toBeLessThanOrEqual(2 * deliveries) - expect(stateReads).toBe(1) // Cold first read, then metadata-validated login cache. - expect(vi.mocked(fs.readFileSync).mock.calls[0][0]).toBe(stateFile) - expect(fs.readdirSync).not.toHaveBeenCalled() console.info('account-home-perf', { accounts, deliveries, signedIn, + concurrent, selectionReads, accountVisits, stats, - directoryStats, stateReads, stateBytes: Buffer.byteLength(state), elapsedMs diff --git a/src/main/runtime/structured-agent-account-home.ts b/src/main/runtime/structured-agent-account-home.ts index e88686bf669..c3dce579ddf 100644 --- a/src/main/runtime/structured-agent-account-home.ts +++ b/src/main/runtime/structured-agent-account-home.ts @@ -2,6 +2,7 @@ import type { AgentSessionAccountKind } from '../../shared/agent-session/agent-s import type { GlobalSettings } from '../../shared/global-settings-types' import { normalizeRuntimePathForComparison } from '../../shared/cross-platform-path' import { getClaudeProfileRouter } from '../claude-accounts/claude-profile-installed-router' +import { claudeRoutedHomeAsync } from '../claude-accounts/claude-profile-routed-home' import { normalizeCodexRuntimeSelection } from '../codex-accounts/runtime-selection' import { resolveOrcaManagedCodexHomePath, getSystemCodexHomePath } from '../codex/codex-home-paths' import { resolveAbsoluteDirOverride } from '../../shared/absolute-dir-override' @@ -20,13 +21,14 @@ export type StructuredClaudeAccountHomeDeps = { ) => string | null | undefined } -export function resolveStructuredClaudeAccountHomePath( +export async function resolveStructuredClaudeAccountHomePath( deps: StructuredClaudeAccountHomeDeps -): string { +): Promise { // Why only an account: System default keeps the launch-env and configured homes below. - const accountHome = deps.wslDistro - ? null - : getClaudeProfileRouter()?.routedHome(deps.purpose === 'identity' ? 'identity' : 'checked') + const router = deps.wslDistro ? undefined : getClaudeProfileRouter() + const accountHome = router + ? await claudeRoutedHomeAsync(router, deps.purpose === 'identity' ? 'identity' : 'checked') + : null if (accountHome) { return accountHome } diff --git a/src/main/runtime/structured-agent-launch-composition.test-support.ts b/src/main/runtime/structured-agent-launch-composition.test-support.ts index a36ea791a4f..d57a3023874 100644 --- a/src/main/runtime/structured-agent-launch-composition.test-support.ts +++ b/src/main/runtime/structured-agent-launch-composition.test-support.ts @@ -1,4 +1,3 @@ -import type { ClaudeAccountRecipe } from '../../shared/agent-session-acquired-account' // Build agent launch resolvers with production composition over test doubles so tests exercise the shared path. import type { AgentSessionRecordStore } from './agent-session/records/agent-session-record-store' @@ -108,7 +107,6 @@ function withTestSpawnToken( identity: AgentSessionJournalIdentity spawnToken?: string | null permissionMode?: AgentChatPermissionChoice - accountRecipe?: ClaudeAccountRecipe }) => { const spawnToken = input.spawnToken === undefined ? defaultToken : input.spawnToken return spawnToken === null @@ -116,7 +114,6 @@ function withTestSpawnToken( : resolve({ identity: input.identity, spawnToken, - ...(input.accountRecipe ? { accountRecipe: input.accountRecipe } : {}), ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}) }) } diff --git a/src/main/runtime/structured-agent-launch-composition.ts b/src/main/runtime/structured-agent-launch-composition.ts index 6f429fb577c..d6ecdc43687 100644 --- a/src/main/runtime/structured-agent-launch-composition.ts +++ b/src/main/runtime/structured-agent-launch-composition.ts @@ -1,4 +1,3 @@ -import type { ClaudeAccountRecipe } from '../../shared/agent-session-acquired-account' // Compose shared admission, cwd, environment, visuals and child sealing; agent parts add only agent-specific inputs and never set cwd/sealed env. import type { AgentSessionJournalIdentity } from '../../shared/agent-session-journal-identity' @@ -54,7 +53,6 @@ export type StructuredAgentLaunchBasis = { refreshAfterMissingProgram?: (askedAt: number) => Promise /** The permission mode the host decided this start runs with; absent asks. */ permissionMode?: AgentChatPermissionChoice - accountRecipe?: ClaudeAccountRecipe } export type StructuredLaunchRequest = { @@ -62,7 +60,6 @@ export type StructuredLaunchRequest = { /** The reservation's token, which the seal hands the child. */ spawnToken: string permissionMode?: AgentChatPermissionChoice - accountRecipe?: ClaudeAccountRecipe } /** What the composition sets on a launch; an agent's part never does. */ @@ -141,8 +138,7 @@ async function composedPart( sources: StructuredAgentLaunchSources, part: StructuredAgentLaunchPartResolver, identity: AgentSessionJournalIdentity, - permissionMode?: AgentChatPermissionChoice, - accountRecipe?: ClaudeAccountRecipe + permissionMode?: AgentChatPermissionChoice ): Promise & { cwd: string }> { const record = admittedRecord(definition, sources.store, identity.sessionId) const launchEnv = once(() => sources.resolveAgentLaunchEnv?.(definition.agent) ?? {}) @@ -168,7 +164,6 @@ async function composedPart( } } : {}), - ...(accountRecipe ? { accountRecipe } : {}), ...(permissionMode ? { permissionMode } : {}) } const composed = await part(basis, identity) @@ -180,14 +175,13 @@ export function composeStructuredLaunch( sources: StructuredAgentLaunchSources, part: StructuredAgentLaunchPartResolver ): StructuredAgentLaunchResolver { - return async ({ identity, spawnToken, permissionMode, accountRecipe }) => { + return async ({ identity, spawnToken, permissionMode }) => { const { launch, cwd, env, inheritedEnvToDelete, cliRuntimeCommand } = await composedPart( definition, sources, part, identity, - permissionMode, - accountRecipe + permissionMode ) admittedRecord(definition, sources.store, identity.sessionId) const child = sealStructuredSessionChild({ diff --git a/src/main/runtime/structured-agent-runtime-metadata.ts b/src/main/runtime/structured-agent-runtime-metadata.ts index 4fc97a3e78f..ff5d12ca99d 100644 --- a/src/main/runtime/structured-agent-runtime-metadata.ts +++ b/src/main/runtime/structured-agent-runtime-metadata.ts @@ -139,7 +139,7 @@ export const STRUCTURED_AGENT_RUNTIME_CATALOG: readonly StructuredAgentRuntimeCa resolveAccountHome: async ({ launchEnv, location, purpose }, services) => agentSessionAccountHome( CLAUDE_STRUCTURED_AGENT, - resolveStructuredClaudeAccountHomePath({ + await resolveStructuredClaudeAccountHomePath({ launchEnv, wslDistro: location?.wslDistro ?? null, ...(purpose === 'identity' ? { purpose } : {}), diff --git a/src/main/runtime/structured-agent-session-host-assembly.ts b/src/main/runtime/structured-agent-session-host-assembly.ts index 24406386c8e..908ffc18322 100644 --- a/src/main/runtime/structured-agent-session-host-assembly.ts +++ b/src/main/runtime/structured-agent-session-host-assembly.ts @@ -89,7 +89,6 @@ export async function installOnJournal( ...(deps.startupLimits ? { startupLimits: deps.startupLimits } : {}), ...(deps.onSessionTabHidden ? { onSessionTabHidden: deps.onSessionTabHidden } : {}), ...(deps.launchAccountHome ? { launchAccountHome: deps.launchAccountHome } : {}), - ...(deps.parentAccountWork ? { parentAccountWork: deps.parentAccountWork } : {}), ...(deps.assertNoTerminalWriter ? { assertNoTerminalWriter: deps.assertNoTerminalWriter } : {}), ...(await modelCatalogHostDeps({ host: () => host, diff --git a/src/main/runtime/structured-agent-session-runtime-contract.ts b/src/main/runtime/structured-agent-session-runtime-contract.ts index 64e60b33e8a..c8ceaf6374c 100644 --- a/src/main/runtime/structured-agent-session-runtime-contract.ts +++ b/src/main/runtime/structured-agent-session-runtime-contract.ts @@ -82,5 +82,4 @@ export type StructuredAgentSessionRuntimeDeps = StructuredAgentSessionTransportO resolveAgentAccountHome?: RuntimeAgentAccountHomeResolver /** See `StructuredAgentSessionHostDeps.launchAccountHome`. */ launchAccountHome?: StructuredAgentSessionHostDeps['launchAccountHome'] - parentAccountWork?: StructuredAgentSessionHostDeps['parentAccountWork'] } & Pick diff --git a/src/main/runtime/structured-native-work-readers.ts b/src/main/runtime/structured-native-work-readers.ts deleted file mode 100644 index 2a586328814..00000000000 --- a/src/main/runtime/structured-native-work-readers.ts +++ /dev/null @@ -1,16 +0,0 @@ -import type { StructuredAgentSessionHostDeps } from '../native-chat/agent-session-wire/structured-agent-session-host-types' -import type { OrchestrationDb } from './orchestration/db' -import { structuredParentAccountWork } from './orchestration/structured-parent-account-work' -import { structuredWorkerOwesWork } from './structured-worker-custody' - -/** Both are re-read; assigned process custody remains separate from receiving-account ownership. */ -export function structuredNativeWorkReaders( - read: () => OrchestrationDb | null, - readReceiving: () => OrchestrationDb | null = read -): Pick { - return { - hasOpenDispatch: (record) => structuredWorkerOwesWork(read(), record), - parentAccountWork: (record, root, response, reader) => - structuredParentAccountWork(readReceiving(), record, root, response, reader) - } -} diff --git a/src/main/runtime/workspaces/workspace-process-listing.ts b/src/main/runtime/workspaces/workspace-process-listing.ts index 034c2849cb9..c810bdab85a 100644 --- a/src/main/runtime/workspaces/workspace-process-listing.ts +++ b/src/main/runtime/workspaces/workspace-process-listing.ts @@ -1,4 +1,3 @@ -import { structuredNativeWorkReaders } from '../structured-native-work-readers' import { getRepoHostIdentityForParts } from '../../../shared/repo-host-identity' import { createRepoRowExecutionHostLookup } from '../../../shared/worktree-execution-host-resolution' import { resolveWorktreeHostRouting } from '../worktree-launch-host-repo' @@ -44,7 +43,10 @@ import { getProfileUserDataPath } from '../../orca-profiles/profile-storage-path import { LOCAL_EXECUTION_HOST_ID } from '../../../shared/execution-host' import { chatWorkerTurnStopReporter } from '../orchestration/chat-worker-turn-stops' import { buildWorktreeListingPage } from '../worktree-listing-host-scope' -import { structuredWorkerOpenTaskTitle } from '../structured-worker-custody' +import { + structuredWorkerOpenTaskTitle, + structuredWorkerOwesWork +} from '../structured-worker-custody' import { preModeChatGetsFullAccess } from '../../../shared/agent-chat-permission-mode' import { isTuiAgent } from '../../../shared/tui-agent-config' import { nativeChatShellEnvironmentPolicy } from '../../../shared/native-chat/native-chat-shell-environment' @@ -306,10 +308,9 @@ export abstract class OrcaRuntimeWithGetWorktreePs extends OrcaRuntimeWithWorktr now: () => Date.now() }), onTurnAttention: chatWorkerTurnStopReporter(this.workerTurnStopReportDeps), - ...structuredNativeWorkReaders( - () => this.getOrchestrationDbIfAvailable?.() ?? null, - () => this.getExistingOrchestrationDb() - ) + // Re-read dispatch ownership each sweep; absence of a database cannot keep the worker alive. + hasOpenDispatch: (record) => + structuredWorkerOwesWork(this.getOrchestrationDbIfAvailable?.() ?? null, record) }) } }