Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
fix(codex): 隔离 Cindy AI 和自定义 API 任务对订阅 OAuth 的依赖 (#5091)
fmfsaisaid4489b81a34c
diff --git a/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts b/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.tsindex 7df1f30ea4..a0a2e11843 100644--- a/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts+++ b/apps/desktop/src/main/__tests__/sessionRuntimeControlWiring.test.ts@@ -758,14 +758,15 @@ describe('session runtime control wiring', () => {);});- it('resumes native Codex history across credentials and reserves window rebuilding for send', () => {- const body = handlerBody(- registerSource,- 'const handleSetModel = async (',- 'const recoverRemoteRuntimeAxisPersistence',- );- expect(body).not.toContain('forkSdkSession(');- expect(body).not.toContain('relinkCodexProviderThread(');+ it('only relinks retained cross-host writers without rewriting native history', () => {+ const body = handlerBody(registerSource, 'const handleSetModel = async (', 'const recoverRemoteRuntimeAxisPersistence');+ expect(body).toContain('requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer(');+ expect(body).toContain('...(canTransferThread ? {');+ expect(body).toContain('relinkCodexProviderThread(');+ expect(body).toContain('stripEncryptedReasoning: false');+ expect(body).toContain('commitCodexThreadTransfer(transferDb!.client, sourceSnapshot');+ expect(body).toMatch(/if \(result\.persistedRoute === true && isDeviceLinkInvoke\(\)\) \{\s*markRemoteSettingPersistedInsideHandler\(response\);/);+ expect(body).toContain('getCurrentDbClientSnapshot()?.clientEpoch !== transferDb.clientEpoch');expect(body).not.toContain('prepareNativeSessionRecovery(');expect(body).toContain('codexAuthInjection: getCodexProxyAuthInjectionState()');expect(body).toContain('confirmedTargetPressure:');@@ -899,7 +900,7 @@ describe('session runtime control wiring', () => {const retainedRecovery = handlerBody(setModel,'const reconcileRetainedLiveProfile = async (): Promise<void> => {',- 'try {\n const result = routeExplicit',+ 'const transferDb = getCurrentDbClientSnapshot();',);const capabilityLookup = retainedRecovery.indexOf('const retainedProviders = await getDesktopProviderService().listProviders({',diff --git a/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.tsindex 298dfd8d02..93a4e59cdc 100644--- a/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/codexAuthInvalidation.test.ts@@ -1,4 +1,6 @@import fs from 'node:fs';+import { createServer } from 'node:http';+import type { AddressInfo } from 'node:net';import os from 'node:os';import path from 'node:path';import { afterEach, describe, expect, it, vi } from 'vitest';@@ -2789,3 +2791,255 @@ describe('local Codex account display identity', () => {expect(JSON.stringify(result)).not.toContain('signature');});});++describe('deferred Codex OAuth dispatch proof', () => {+ it('matches the real HTTP reader account contract without widening workspace identity', async () => {+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-http-account-proof-'));+ dirs.push(root);+ h.userDataDir = path.join(root, 'data');+ h.dataOwnerId = 'http-reader-owner';+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));+ const home = path.join(h.userDataDir, 'codex-home');+ fs.mkdirSync(home, { recursive: true });+ const authPath = path.join(home, 'auth.json');+ const accessToken = idToken({ exp: Math.floor(Date.now() / 1000) + 3600, sub: 'same-user' });+ const workspaceToken = (workspace: string) => idToken({+ sub: 'same-user', 'https://api.openai.com/auth': { chatgpt_account_id: workspace },+ });+ const write = (tokens: { account_id?: string; id_token?: string }) => {+ const raw = JSON.stringify({ tokens: { access_token: accessToken, ...tokens } });+ fs.writeFileSync(authPath, raw);+ return raw;+ };+ const { bindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');+ const { desktopCodexAuthAdapter: adapter } = await import('../auth-adapters.js');+ const reader = await import('../anthropic-responses-bridge-host.js');+ const proxy = await import('../codex-proxy-host.js');+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);+ proxy.registerComposed('http-parent', 'http-parent-thread', 'fixture', {+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },+ });+ const transform = proxy.createModelRoutingTransform('env-key', []);+ const context = { reqId: 1, method: 'POST', url: '/responses', headers: {+ 'thread-id': 'http-child', 'x-openai-subagent': 'collab_spawn',+ 'x-codex-parent-thread-id': 'http-parent-thread',+ } };+ try {+ for (const { tokens, header, workspace } of [+ { tokens: { account_id: 'explicit', id_token: workspaceToken('other') }, header: 'explicit', workspace: 'explicit' },+ { tokens: { id_token: workspaceToken('workspace-a') }, header: 'workspace-a', workspace: 'workspace-a' },+ { tokens: { id_token: idToken({ sub: 'same-user' }) }, header: 'same-user', workspace: null },+ { tokens: { id_token: idToken({}) }, header: null, workspace: null },+ { tokens: {}, header: null, workspace: null },+ ]) {+ const raw = write(tokens);+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ reader.clearChatgptBridgeCredentialCache();+ expect((await reader.getChatgptBridgeAuth()).accountId).toBe(header);+ await expect(adapter.getAccountId()).resolves.toBe(workspace);+ const auth = await reader.getChatgptBridgeAuthForDispatch();+ expect(auth.accountId).toBe(header);+ expect(auth.canDispatch()).toBe(true);+ const decision = await transform({ model: 'gpt-5.4' }, context);+ expect(decision?.headerOverride?.authorization).toBe(`Bearer ${accessToken}`);+ expect(decision?.headerOverride?.['chatgpt-account-id'] ?? null).toBe(header);+ if (header === null) expect(decision?.headerDelete).toContain('chatgpt-account-id');+ expect(decision?.dispatchGenerationValid?.()).toBe(true);+ expect(fs.readFileSync(authPath, 'utf8')).toBe(raw);+ }++ // Same subject AND access token: only the workspace changes. Do not clear+ // the reader cache; the stale HTTP identity must fail proof and be reread.+ write({ id_token: workspaceToken('workspace-a') });+ const a = await reader.getChatgptBridgeAuthForDispatch();+ const oldDecision = await transform({ model: 'gpt-5.4' }, context);+ write({ id_token: workspaceToken('workspace-b') });+ expect(a.canDispatch()).toBe(false);+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(false);+ const b = await reader.getChatgptBridgeAuthForDispatch();+ expect(b.accountId).toBe('workspace-b');+ expect(b.canDispatch()).toBe(true);+ const nextDecision = await transform({ model: 'gpt-5.4' }, context);+ expect(nextDecision?.headerOverride?.['chatgpt-account-id']).toBe('workspace-b');+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(true);+ proxy.unregister('http-parent');+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(false);+ } finally {+ proxy.unregister('http-parent');+ reader.clearChatgptBridgeCredentialCache();+ }+ });++ it('binds an independent account child to its real credential and authorization record', async () => {+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-multi-reader-'));+ dirs.push(root);+ h.userDataDir = path.join(root, 'data');+ h.dataOwnerId = 'reader-owner';+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));+ const { buildUserProvider } = await import('@cindy/model-providers');+ const catalog = await import('../active-catalog.js');+ catalog.setCustomProviders([buildUserProvider({+ id: 'openai-child', name: 'Synthetic child account', auth: { method: 'oauth', native: 'codex' },+ runtimes: { codex: { baseUrl: 'https://chatgpt.com/backend-api/codex', models: [{ id: 'gpt-5.4', name: 'Fixture' }] } },+ })]);+ const accounts = await import('../codex-account-auth.js');+ const home = accounts.codexAccountHome('openai-child');+ fs.mkdirSync(home, { recursive: true });+ const expiry = Math.floor(Date.now() / 1000) + 3600;+ const write = (account: string) => {+ const raw = JSON.stringify({ tokens: { access_token: idToken({ exp: expiry, sub: account }), account_id: account } });+ fs.writeFileSync(path.join(home, 'auth.json'), raw);+ fs.writeFileSync(path.join(home, 'account.json'), JSON.stringify(accounts.parseCodexAccountIdentity(raw)));+ };+ const reader = await import('../anthropic-responses-bridge-host.js');+ const proxy = await import('../codex-proxy-host.js');+ const routes = await import('../provider-route.js');+ write('synthetic-a');+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);+ proxy.registerComposed('multi-parent', 'multi-parent-thread', 'fixture', {+ subagentRoute: { providerId: 'openai-child', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },+ });+ const transform = proxy.createModelRoutingTransform('env-key', []);+ const context = { reqId: 1, method: 'POST', url: '/responses', headers: {+ 'thread-id': 'multi-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'multi-parent-thread',+ } };+ try {+ const first = await transform({ model: 'gpt-5.4' }, context);+ expect(first?.headerOverride?.['chatgpt-account-id']).toBe('synthetic-a');+ expect(first?.dispatchGenerationValid?.()).toBe(true);+ write('synthetic-b');+ expect(first?.dispatchGenerationValid?.()).toBe(false);+ const next = await transform({ model: 'gpt-5.4' }, context);+ expect(next?.headerOverride?.['chatgpt-account-id']).toBe('synthetic-b');+ expect(next?.dispatchGenerationValid?.()).toBe(true);+ const finish = routes.beginProviderRouteMutation('openai-child');+ expect(next?.dispatchGenerationValid?.()).toBe(false);+ finish.commit(); finish();+ expect(next?.dispatchGenerationValid?.()).toBe(false);+ const current = await reader.getChatgptBridgeAuthForDispatch('openai-child');+ await accounts.invalidateCodexAccount('openai-child', 'synthetic-invalidated', current.accessToken);+ expect(current.canDispatch()).toBe(false);+ await expect(reader.getChatgptBridgeAuthForDispatch('openai-child')).rejects.toThrow();+ } finally {+ proxy.unregister('multi-parent');+ catalog.setCustomProviders([]);+ }+ });++ it('reads and freezes the real bridge credential across same-owner account replacement', async () => {+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-reader-proof-'));+ dirs.push(root);+ h.userDataDir = path.join(root, 'data');+ h.dataOwnerId = 'reader-owner';+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));+ const codexHome = path.join(h.userDataDir, 'codex-home');+ fs.mkdirSync(codexHome, { recursive: true });+ const fixtureExpiry = Math.floor(Date.now() / 1000) + 3600;+ const token = (account: string) => idToken({ exp: fixtureExpiry, sub: account });+ const write = (account: string) => fs.writeFileSync(path.join(codexHome, 'auth.json'), JSON.stringify({ tokens: { access_token: token(account), account_id: account } }));+ const { bindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');+ write('account-a');+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ const reader = await import('../anthropic-responses-bridge-host.js');+ reader.clearChatgptBridgeCredentialCache();+ const a = await reader.getChatgptBridgeAuthForDispatch();+ expect(a.accountId).toBe('account-a');+ expect(a.canDispatch()).toBe(true);+ const proxy = await import('../codex-proxy-host.js');+ proxy.setCodexSubagentOAuthReader(reader.getChatgptBridgeAuthForDispatch);+ proxy.registerComposed('reader-parent', 'reader-parent-thread', 'fixture', {+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },+ });+ const transform = proxy.createModelRoutingTransform('provider-oauth', []);+ const ctx = { reqId: 1, method: 'POST', url: '/responses', headers: {+ 'thread-id': 'reader-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'reader-parent-thread',+ } };+ const oldDecision = await transform({ model: 'gpt-5.4' }, ctx);+ expect(oldDecision?.headerOverride).toMatchObject({ 'chatgpt-account-id': 'account-a' });+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(true);+ write('account-b');+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ expect(a.canDispatch()).toBe(false);+ expect(oldDecision?.dispatchGenerationValid?.()).toBe(false);+ const nextDecision = await transform({ model: 'gpt-5.4' }, ctx);+ expect(nextDecision?.headerOverride).toMatchObject({ 'chatgpt-account-id': 'account-b' });+ const b = await reader.getChatgptBridgeAuthForDispatch();+ expect(b.accountId).toBe('account-b');+ expect(b.accessToken).toBe(token('account-b'));+ expect(b.canDispatch()).toBe(true);+ const { desktopCodexAuthAdapter } = await import('../auth-adapters.js');+ const { createAnthropicCompatProxy, createEncryptedContentRecoveryRule } = await import('@cindy/anthropic-compat-proxy');+ let childRequests = 0;+ const upstream = createServer(async (req, res) => {+ let body = '';+ for await (const chunk of req) body += chunk;+ if (JSON.parse(body).model === 'api-parent') {+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');+ return;+ }+ childRequests++;+ await desktopCodexAuthAdapter.invalidate('token_revoked', { credentialAttribution: 'unproven' });+ res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: {+ message: 'Encrypted content gAAA... could not be decrypted or parsed.', code: 'invalid_encrypted_content',+ } }));+ });+ await new Promise<void>((resolve) => upstream.listen(0, '127.0.0.1', resolve));+ const endpoint = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;+ const forwarding = await createAnthropicCompatProxy({+ upstream: endpoint, transformRequest: [],+ routingTransform: (body) => (body as { model?: string }).model === 'api-parent'+ ? null : { ...nextDecision, upstreamOverride: endpoint },+ recoveryRules: [createEncryptedContentRecoveryRule({ enabled: () => true })],+ });+ try {+ const send = (model: string) => fetch(`${forwarding.url}/responses`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model, input: [{ type: 'reasoning', encrypted_content: 'gAAA-fixture' }] }) });+ const rejected = await send('gpt-5.4');+ expect(rejected.status).toBe(503);+ await rejected.text();+ expect(childRequests).toBe(1);+ const parent = await send('api-parent');+ expect(parent.status).toBe(200);+ await parent.text();+ } finally {+ await forwarding.dispose();+ await new Promise<void>((resolve) => upstream.close(() => resolve()));+ }+ expect(b.canDispatch()).toBe(false);+ expect(nextDecision?.dispatchGenerationValid?.()).toBe(false);+ proxy.unregister('reader-parent');+ await expect(reader.getChatgptBridgeAuthForDispatch()).rejects.toThrow();+ reader.clearChatgptBridgeCredentialCache();+ });++ it('rejects same-owner account replacement and logout/relogin without reviving an old decision', async () => {+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-codex-dispatch-proof-'));+ dirs.push(root);+ h.userDataDir = path.join(root, 'data');+ h.dataOwnerId = 'same-owner';+ vi.spyOn(os, 'homedir').mockReturnValue(path.join(root, 'home'));+ const codexHome = path.join(h.userDataDir, 'codex-home');+ fs.mkdirSync(codexHome, { recursive: true });+ const authPath = path.join(codexHome, 'auth.json');+ const write = (token: string, account: string) => fs.writeFileSync(authPath, JSON.stringify({ tokens: { access_token: token, account_id: account } }));+ const { bindNativeProviderAuth, unbindNativeProviderAuth } = await import('../nativeProviderAuthBinding.js');+ const { DesktopCodexAuthAdapter } = await import('../auth-adapters.js');+ write('synthetic-a', 'account-a');+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ const adapter = new DesktopCodexAuthAdapter();+ const a = adapter.captureOAuthDispatchProof('synthetic-a', 'account-a');+ expect(a?.()).toBe(true);+ write('synthetic-b', 'account-b');+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ expect(a?.()).toBe(false);+ expect(adapter.captureOAuthDispatchProof('synthetic-a', 'account-a')).toBeNull();+ const b = adapter.captureOAuthDispatchProof('synthetic-b', 'account-b');+ expect(b?.()).toBe(true);+ unbindNativeProviderAuth('openai');+ expect(b?.()).toBe(false);+ bindNativeProviderAuth('openai', { instanceIsolated: true });+ expect(b?.()).toBe(false);+ expect(adapter.captureOAuthDispatchProof('synthetic-b', 'account-b')?.()).toBe(true);+ await adapter.invalidate('token_revoked', { credentialAttribution: 'unproven' });+ expect(adapter.captureOAuthDispatchProof('synthetic-b', 'account-b')).toBeNull();+ });+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.tsindex c9fd60b9cd..eb43dba565 100644--- a/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/codexCredentialSwitch.test.ts@@ -739,3 +739,23 @@ describe('prepareLocalCodexCredentialModeSwitch', () => {})).rejects.toThrow(/\(oauth-bearer\(registered: fallback\) -> gateway-key\).*busy-codex-1/);});});+++describe('Codex host-scoped credential coordination', () => {+ it.each(['local', 'local:external-auth'])('does not block or close a busy sibling when replacing %s', async (hostKey) => {+ const sibling = hostKey === 'local' ? 'local:external-auth' : 'local';+ const closeSession = vi.fn(async () => undefined);+ const result = await prepareLocalCodexCredentialModeSwitch({+ hostKey,+ maker: {+ listActiveSessions: () => [+ { id: 'target', agentKind: 'codex', codexHostKey: hostKey, isTurnRunning: () => false },+ { id: 'sibling', agentKind: 'codex', codexHostKey: sibling, isTurnRunning: () => true },+ ],+ closeSession,+ },+ });+ expect(result.closedSessionIds).toEqual(['target']);+ expect(closeSession).toHaveBeenCalledExactlyOnceWith('target', 'runtime-refresh');+ });+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.tsindex 547fc1b755..124297ff0c 100644--- a/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/codexCustomProviderRoute.test.ts@@ -16,6 +16,7 @@ import {isCodexCustomProviderNamespacePath,parseCodexCustomProviderPath,relativeProviderRequestPath,+ registerCodexScopedCustomProviderRoutes,resolveCodexCustomProviderModelProviderId,setCodexAppliedCustomProviderRoutes,toCodexCustomProviderHostRoutes,@@ -371,3 +372,23 @@ describe('Codex custom Provider identity', () => {expect(relativeProviderRequestPath('https://provider.example/v1', '//evil')).toBeNull();});});+++describe('scoped Host capabilities', () => {+ it('keeps capability snapshots until their own Host retires', () => {+ const routes = deriveCodexCustomProviderRoutes(catalog());+ const releaseOld = registerCodexScopedCustomProviderRoutes('external:1', routes);+ const releaseNew = registerCodexScopedCustomProviderRoutes('external:2', routes);+ try {+ setCodexAppliedCustomProviderRoutes([]);+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(true);+ releaseOld();+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(true);+ releaseNew();+ expect(hasCodexAppliedCustomProviderCapability('provider-alpha', 'imageGeneration')).toBe(false);+ } finally {+ releaseOld();+ releaseNew();+ }+ });+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.tsnew file mode 100644index 0000000000..63e510fd61--- /dev/null+++ b/apps/desktop/src/main/maker-host/__tests__/codexGatewayAuth.integration.test.ts@@ -0,0 +1,221 @@+import fs from 'node:fs';+import os from 'node:os';+import path from 'node:path';+import { createServer } from 'node:http';+import type { AddressInfo } from 'node:net';+import { describe, expect, it, vi } from 'vitest';+import { buildUserProvider } from '@cindy/model-providers';+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';+import type { AgentSessionHandle } from '../../../../../../packages/maker-core/src/agents/base-agent.js';+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';++const fixture = vi.hoisted(() => ({ userData: '', home: '', gatewayKey: 'synthetic-gateway-key' }));+vi.mock('electron', () => ({ app: {+ isPackaged: true,+ getPath: (name: string) => name === 'home' ? fixture.home : fixture.userData,+ getAppPath: () => fixture.userData,+}, safeStorage: { isEncryptionAvailable: () => false } }));+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));+vi.mock('../../secrets/providerSecretStore.js', () => ({ getProviderSecretStore: () => ({ get: () => fixture.gatewayKey }) }));+vi.mock('../../appSessionState.js', async (original) => ({+ ...await original<typeof import('../../appSessionState.js')>(),+ getActiveAppSession: () => ({ mode: 'cloud', dataOwnerId: 'synthetic-owner', generation: 1 }),+ activeOwnerScopeKey: () => 'cloud:synthetic-owner:1',+ isAppSessionBoundaryPending: () => false,+}));++const binary = process.env.CINDY_TEST_CODEX_BINARY;+const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };++describe.skipIf(!binary)('first-profile gateway/API startup with native Codex', () => {+ it.each(['none', 'fresh-revoked', 'expired-refreshable', 'expired-revoked', 'healthy-concurrent', 'revoked-concurrent', 'gated-concurrent'].flatMap((auth) =>+ ['xd', 'cprov-key'].flatMap((providerId) => (auth.endsWith('-concurrent') ? [false, true] : [false])+ .flatMap((seeded) => (auth === 'gated-concurrent' ? [false, true] : [true])+ .flatMap(officialFirst => (auth === 'gated-concurrent' && !seeded ? [false, true] : [false])+ .map(separateDb => ({ auth, providerId, seeded, officialFirst, separateDb }))))),+ ))('$providerId independent of $auth (seeded=$seeded officialFirst=$officialFirst separateDb=$separateDb)', async ({ auth, providerId, seeded, officialFirst, separateDb }) => {+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-gateway-native-'));+ fixture.home = path.join(root, 'home');+ fixture.userData = path.join(root, 'profile');+ fixture.gatewayKey = providerId === 'xd' ? 'synthetic-gateway-key' : '';+ fs.mkdirSync(path.join(fixture.home, '.codex'), { recursive: true });+ fs.mkdirSync(fixture.userData, { recursive: true });+ const homeSpy = vi.spyOn(os, 'homedir').mockReturnValue(fixture.home);+ const calls: string[] = [];+ let rejectApi = false;+ let officialAccessToken = '';+ const concurrent = auth.endsWith('-concurrent');+ let releaseOAuth!: () => void;+ const oauthGate = new Promise<void>(resolve => { releaseOAuth = resolve; });+ let refreshEntered!: () => void;+ const refreshRequested = new Promise<void>(resolve => { refreshEntered = resolve; });+ let sequence = 0;+ const server = createServer(async (req, res) => {+ for await (const chunk of req) void chunk;+ calls.push(`${req.method} ${req.url}`);+ if (auth === 'gated-concurrent' && req.url === '/oauth/token') {+ refreshEntered();+ await oauthGate;+ }+ if (auth === 'healthy-concurrent' && req.url?.startsWith('/models')) {+ res.writeHead(200, { 'content-type': 'application/json' }).end('{"models":[]}');+ return;+ }+ if (req.url?.endsWith('/responses')) {+ expect([`Bearer ${providerId === 'xd' ? fixture.gatewayKey : 'synthetic-custom-key'}`, ...(concurrent ? [`Bearer ${officialAccessToken}`] : [])]).toContain(req.headers.authorization);+ if (rejectApi && req.headers.authorization !== `Bearer ${officialAccessToken}`) {+ res.writeHead(401, { 'content-type': 'application/json' }).end('{"error":{"message":"synthetic API rejection"}}');+ return;+ }+ const id = `fixture-${++sequence}`;+ const events = [+ { type: 'response.created', response: { id } },+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: `msg-${id}`, content: [{ type: 'output_text', text: 'synthetic complete' }] } },+ { type: 'response.completed', response: { id, usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },+ ];+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));+ return;+ }+ if (req.url === '/oauth/token' && auth === 'expired-refreshable') {+ res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ access_token: 'synthetic-refreshed', refresh_token: 'synthetic-refresh' }));+ return;+ }+ if (auth === 'healthy-concurrent') {+ res.writeHead(404, { 'content-type': 'application/json' }).end('{"error":{"message":"No optional MCP endpoint in fixture"}}');+ return;+ }+ res.writeHead(401, { 'content-type': 'application/json' }).end('{"error":{"code":"refresh_token_invalidated","message":"synthetic revoked token"}}');+ });+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;+ const systemAuth = path.join(fixture.home, '.codex', 'auth.json');+ let originalAuth: string | undefined;+ if (auth !== 'none') {+ const claims = { sub: 'synthetic-user', exp: Math.floor(Date.now() / 1000) + (auth.startsWith('expired') ? -3600 : 3600), 'https://api.openai.com/auth': { chatgpt_plan_type: auth === 'healthy-concurrent' ? 'plus' : 'business', chatgpt_account_id: 'synthetic-account' } };+ const token = `eyJhbGciOiJub25lIn0.${Buffer.from(JSON.stringify(claims)).toString('base64url')}.synthetic`;+ officialAccessToken = token;+ originalAuth = JSON.stringify({ auth_mode: 'chatgpt', tokens: { access_token: token, id_token: token, refresh_token: 'synthetic-invalid-refresh', account_id: 'synthetic-account' }, last_refresh: new Date(auth.startsWith('expired') ? 0 : Date.now()).toISOString() });+ fs.writeFileSync(systemAuth, originalAuth, { mode: 0o600 });+ }+ const { DesktopCodexAuthAdapter, getCodexHome } = await import('../auth-adapters.js');+ const { captureCodexLocalAuthPolicy } = await import('../provider-route.js');+ const { setCustomProviders } = await import('../active-catalog.js');+ const { buildCodexProxySpawnArgs } = await import('../codex-gateway-config.js');+ const diagnostics: unknown[] = [];+ const nativePids: number[] = [];+ const testLogger: Logger = { ...logger, debug: (...args) => { diagnostics.push(args); }, warn: (...args) => { diagnostics.push(args); }, error: (...args) => { diagnostics.push(args); }, child: () => testLogger };+ const adapter = new DesktopCodexAuthAdapter();+ const taskRpcs: string[] = [];+ const originalRequest = AppServerHost.prototype.request;+ const rpcSpy = vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, options) {+ if (['thread/start', 'thread/resume', 'thread/fork'].includes(method)) taskRpcs.push(method);+ return originalRequest.call(this, method, params, options);+ });+ let authEnvSpy: { mockRestore(): void } | undefined;+ let agent: CodexAgent | undefined;+ try {+ // This is the production first-profile reconcile, not an auth-state stub.+ const detected = await adapter.getState();+ if (originalAuth) expect(detected).toMatchObject({ authenticated: true, authSource: 'oauth' });+ const codexHome = getCodexHome();+ fs.mkdirSync(codexHome, { recursive: true });+ if (originalAuth) expect(fs.readFileSync(path.join(codexHome, 'auth.json'), 'utf8')).toBe(originalAuth);+ fs.writeFileSync(path.join(codexHome, 'config.toml'), `chatgpt_base_url="${endpoint}"\ncheck_for_update_on_startup=false\n[analytics]\nenabled=false\n[mcp_servers.cindy_memory]\ncommand="/usr/bin/false"\nenabled=false\n`);+ if (separateDb) {+ const officialHome = path.join(root, 'official-native-home');+ fs.mkdirSync(officialHome);+ fs.writeFileSync(path.join(officialHome, 'auth.json'), originalAuth!);+ fs.copyFileSync(path.join(codexHome, 'config.toml'), path.join(officialHome, 'config.toml'));+ const getEnv = adapter.getAuthEnv.bind(adapter);+ authEnvSpy = vi.spyOn(adapter, 'getAuthEnv').mockImplementation(async opts => {+ const env = await getEnv(opts);+ return opts?.credentialMode === 'oauth-bearer' ? { ...env, CODEX_HOME: officialHome } : env;+ });+ }+ setCustomProviders([buildUserProvider({ id: 'cprov-key', name: 'Synthetic', runtimes: { codex: { baseUrl: endpoint, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);+ const modes: string[] = [];+ agent = new CodexAgent({+ binaryPath: binary!, auth: adapter, logger: testLogger,+ registerLocalCodexAppServerProcess: ({ pid }) => { nativePids.push(pid); },+ isolateCodexAccountSessions: true,+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,+ runtimeConfig: { behaviorFlags: { HOME: fixture.home, TMPDIR: root, CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`, HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost' } },+ prepareCodexExtraSpawnConfig: async (_providers, ctx) => {+ modes.push(ctx.credentialMode ?? 'fallback');+ if (ctx.credentialMode !== 'oauth-bearer') expect(ctx.localAuthPolicy).toBe('isolated');+ return { extraArgs: buildCodexProxySpawnArgs(endpoint, ctx.credentialMode === 'oauth-bearer' ? 'oauth-bearer' : ctx.credentialMode === 'gateway-key' ? 'env-key' : 'provider-oauth'), extraEnv: { ...(providerId !== 'xd' ? { XDT_CODEX_API_KEY: 'synthetic-custom-key' } : {}) }, codexProxyActive: true };+ },+ });+ const send = async (handle: AgentSessionHandle, fail = false) => {+ const events = (async () => {+ for await (const event of handle.events()) {+ if (event.type === 'error') { if (fail) return 'error'; throw new Error('unexpected synthetic turn failure'); }+ if (event.type === 'done') return 'done';+ }+ })();+ await handle.send({ type: 'user', content: 'return synthetic complete' }, { throwOnStartFailure: true });+ expect(await events).toBe(fail ? 'error' : 'done');+ };+ const options = { sessionId: 'same-task', providerId, model: 'fixture-model', workingDir: root };+ if (seeded) {+ // Exercise concurrent hosts against an existing native history database.+ // The paired unseeded case covers truly empty-database startup.+ const seed = await agent.startSession({ ...options, sessionId: 'initial-native-profile' });+ await seed.close();+ }+ const startOfficial = () => agent!.startSession({ ...options, sessionId: 'official-task', providerId: 'openai' }).then((handle) => ({ handle }), (error: unknown) => ({ error }));+ const firstOfficial = concurrent && officialFirst ? startOfficial() : undefined;+ const parentStart = agent.startSession(options);+ const officialStart = concurrent+ ? firstOfficial ?? startOfficial()+ : undefined;+ if (auth === 'gated-concurrent') await refreshRequested;+ const handle = await parentStart;+ const official = auth === 'gated-concurrent' ? undefined : await officialStart;+ if (auth === 'healthy-concurrent') expect(official).toHaveProperty('handle');+ if (auth === 'revoked-concurrent') expect(official).toHaveProperty('error');+ const oauthCalls = calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'));+ if (official && 'handle' in official) await send(official.handle);+ await send(handle); await send(handle);+ const threadId = handle.id;+ await handle.close();+ const resumed = await agent.startSession({ ...options, resumeSessionId: threadId });+ expect(resumed.id).toBe(threadId);+ await send(resumed);+ rejectApi = true;+ await send(resumed, true);+ await resumed.close();+ if (official && 'handle' in official) { await send(official.handle); await official.handle.close(); }+ expect(modes.filter(mode => mode !== 'oauth-bearer').every((mode) => mode === (providerId === 'xd' ? 'gateway-key' : 'provider-oauth'))).toBe(true);+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(oauthCalls);+ if (auth === 'gated-concurrent') {+ // All parent startup, turns, resume and API-401 handling completed while+ // the official refresh response was withheld, not after its timeout.+ expect(calls.filter(call => call === 'POST /oauth/token')).toHaveLength(1);+ releaseOAuth();+ expect(await officialStart).toHaveProperty('error');+ }+ if (!concurrent) expect(oauthCalls).toEqual([]);+ if (auth === 'revoked-concurrent') expect(oauthCalls.length).toBeGreaterThan(0);+ if (originalAuth) expect(fs.readFileSync(systemAuth, 'utf8')).toBe(originalAuth);+ expect(taskRpcs.filter(method => method === 'thread/start')).toHaveLength(1 + Number(concurrent) + Number(seeded));+ expect(taskRpcs.filter(method => method === 'thread/resume')).toHaveLength(1);+ expect(taskRpcs).not.toContain('thread/fork');+ expect(nativePids.length).toBeLessThanOrEqual(3 * (2 + Number(concurrent) + Number(seeded)));+ } catch (error) {+ throw new Error(`${String(error)}\n${JSON.stringify(diagnostics)}`, { cause: error });+ } finally {+ releaseOAuth();+ await agent?.dispose();+ rpcSpy.mockRestore();+ authEnvSpy?.mockRestore();+ setCustomProviders([]);+ await new Promise<void>((resolve) => server.close(() => resolve()));+ homeSpy.mockRestore();+ fs.rmSync(root, { recursive: true, force: true });+ for (const pid of nativePids) expect(() => process.kill(pid, 0)).toThrow();+ }+ }, 60_000);+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.ts b/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.tsnew file mode 100644index 0000000000..b8e4e806bf--- /dev/null+++ b/apps/desktop/src/main/maker-host/__tests__/codexPickerHarness.ts@@ -0,0 +1,137 @@+import fs from 'node:fs';+import path from 'node:path';+import vm from 'node:vm';+import ts from 'typescript';+import { eq } from 'drizzle-orm';+import type { Maker } from '../../../../../../packages/maker-core/src/maker.js';+import type { DbClient } from '../../localDb/client/DbClient.js';+import { sessions } from '../../localDb/schema.js';+import * as providers from '../session-provider-store.js';+import * as efforts from '../session-effort-store.js';+import * as routeGuard from '../model-route-guard.js';+import * as control from '../../maker-ipc/sessionRuntimeControl.js';+import * as axes from '../../maker-ipc/runtimeSelectionAxes.js';+import * as relink from '../../maker-ipc/codexProviderThreadRelink.js';+import * as windowGate from '../../../shared/runtimeModelSwitchGate.js';+import * as overflow from '../../maker-ipc/contextOverflowRollover.js';+import { applyRuntimeSetModelChange } from '../../maker-ipc/runtimeSetModel.js';+import { normalizeDeviceLinkSetModelWireArgs } from '../../maker-ipc/setModelWireArgs.js';+import { CredentialModeSwitchBusyError } from '../codex-credential-switch.js';+import { createPendingAgentSwitchRegistry, applyPendingAgentSwitchIfIdle, projectPendingAgentSwitchIntent, type MakerSessionAgentSwitchHandlerDeps } from '../../maker-ipc/sessionAgentSwitchHandler.js';+import { registerSessionSetModelHandler } from '../../maker-ipc/sessionSetModelHandler.js';+import { registerMakerSessionSendHandler } from '../../maker-ipc/sessionSendHandler.js';+import { createMakerSendTransaction, type MakerSendTransactionDeps } from '../../maker-ipc/makerSendTransaction.js';+import { acquireSendToSessionLock, withSendToSessionLock } from '../../maker-ipc/sendToSessionLock.js';+import type { IpcHandler } from '../../maker-ipc/ipcHandlerRegistry.js';+import { MAKER_INVOKE } from '../../maker-ipc/channels.js';+import { createSharedTaskSettingGuard } from '../../maker-ipc/sharedTaskSetting.js';++// Execute the full production closures, not copied branches or source assertions.+// Electron ingress, owner, catalog metadata and UI broadcasts are fixture inputs;+// pending selection, runtime replacement, native fork and SQLite CAS stay real.+const source = fs.readFileSync(path.resolve(__dirname, '../../maker-ipc/register.ts'), 'utf8');+const ast = ts.createSourceFile('register.ts', source, ts.ScriptTarget.Latest, true);+function closure(name: string): string {+ let expression: ts.Expression | undefined;+ const visit = (node: ts.Node) => {+ if (ts.isVariableDeclaration(node) && node.name.getText(ast) === name) expression = node.initializer;+ if (ts.isPropertyAssignment(node) && node.name.getText(ast) === name && ts.isArrowFunction(node.initializer)) expression = node.initializer;+ if (ts.isBinaryExpression(node) && node.left.getText(ast) === name && ts.isArrowFunction(node.right)) expression = node.right;+ ts.forEachChild(node, visit);+ };+ visit(ast);+ if (!expression) throw new Error(`Missing production closure ${name}`);+ return ts.transpileModule(`(${expression.getText(ast)})`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText;+}++export function createCodexPickerHarness(input: {+ maker: Maker;+ db: Pick<DbClient, 'drizzle'>;+ workingDir: string;+ createMessage(id: string, message: { clientId: string; content: unknown }): Promise<unknown>;+}) {+ const { maker, db, workingDir } = input;+ const pending = createPendingAgentSwitchRegistry();+ const noop = () => {};+ const asyncNoop = async () => {};+ const log = { info: noop, warn: noop, debug: noop, error: noop };+ const readRow = async (id: string) => (await db.drizzle.select().from(sessions).where(eq(sessions.id, id)).limit(1))[0];+ const bootstrap = async (id: string) => {+ const row = await readRow(id);+ return maker.createSession({ id, agentKind: 'codex', model: row.model!, providerId: row.providerId,+ resumeSessionId: row.sdkSessionId ?? undefined, workingDir });+ };+ const env: Record<string, unknown> = {+ ...providers, ...efforts, ...routeGuard, ...control, ...axes, ...relink, ...windowGate, ...overflow,+ maker, sessions, eq, log, agentSwitchPending: pending,+ // Ordinary local picker has no shared-task invocation context.+ captureSharedTaskSettingGuard: (id: string) => createSharedTaskSettingGuard(undefined, id, { admitted: false }),+ normalizeDeviceLinkSetModelWireArgs, applyRuntimeSetModelChange, CredentialModeSwitchBusyError,+ projectPendingAgentSwitchIntent, acquireSendToSessionLock, withSendToSessionLock, applyPendingAgentSwitchIfIdle,+ getDbClient: () => db, getCurrentDbClientSnapshot: () => ({ client: db, clientEpoch: 1 }),+ captureDataOwnerBroadcastScope: () => 'synthetic-owner', isDataOwnerBroadcastScopeCurrent: () => true,+ assertReviewSettingsUnlocked: asyncNoop, isDeviceLinkInvoke: () => false,+ deviceLinkInvokeControllerSupports: () => false, CONTROLLER_CAPABILITY_SET_MODEL_EXPLICIT_PROVIDER_NULL_V1: 'fixture',+ throwIpcError: (code: string, message: string) => { throw new Error(`${code}: ${message}`); },+ dbToMakerAgentKind: (kind: string) => kind, getSessionDbAgentKind: () => 'codex',+ assertModelRouteUsable: asyncNoop, shouldApplyExclusiveProviderRerouteLive: () => false,+ clearPendingCredentialSwitchForSession: noop, registerPendingCredentialSwitchForSession: noop,+ getPendingCredentialSwitchTarget: () => undefined, pendingCredentialSwitchHolder: null,+ wakeSessionInputAfterCredentialSwitch: noop, broadcastSessionPatched: noop,+ broadcastSessionRuntimeProjection: asyncNoop, recordSessionContextSnapshot: asyncNoop,+ isSessionInTurn: (id: string) => maker.getSession(id)?.isTurnRunning() ?? false,+ getCodexProxyAuthInjectionState: () => 'oauth-bearer',+ getActiveCatalog: () => ({}), resolveConfiguredContextWindow: () => 258400,+ getDesktopProviderService: () => ({ listProviders: async () => ['openai', 'xd', 'cprov-fixture'].map(id => ({ id, connected: true })) }),+ findCatalogModel: () => ({ id: 'fixture-model', efforts: ['high'], contextWindow: 258400, supportsFastMode: false }),+ reconcileBotModelRoute: asyncNoop, contextOverflowRolloverHolder: null,+ withRehydrateCloseSuppressed: async (_id: string, run: () => Promise<unknown>) => run(),+ persistSessionFields: async (id: string, patch: Partial<typeof sessions.$inferInsert>) => db.drizzle.update(sessions).set(patch).where(eq(sessions.id, id)),+ };+ const context = vm.createContext(env);+ type Apply = (id: string, model: string, providerId: string | null | undefined, revision: unknown, selection: unknown, options: Record<string, unknown>) => Promise<{ deferred?: boolean; superseded?: boolean }>;+ const apply = vm.runInContext(closure('handleSetModel'), context) as Apply;+ env.applySessionRuntimeSelection = (id: string, model: string, providerId: string | null | undefined, selection: unknown, options: Record<string, unknown>) => apply(id, model, providerId, undefined, selection, options);+ const switchDeps = {+ pendingSwitches: pending, getLiveSession: (id: string) => maker.getSession(id),+ bootstrapSwitchedSession: bootstrap, log,+ selectSameAgentModel: vm.runInContext(closure('selectSameAgentModel'), context),+ } as unknown as MakerSessionAgentSwitchHandlerDeps;+ env.agentSwitchDeps = switchDeps;+ const beforeSend = vm.runInContext(closure('pendingAgentSwitchApplyHolder'), context) as (id: string) => Promise<{ release(): void }>;+ const transactionDeps: MakerSendTransactionDeps = {+ getSession: id => maker.getSession(id), closeSession: id => maker.closeSession(id), getSessionMeta: id => maker.getSessionMeta(id),+ preflightBotRuntimeResources: asyncNoop, ensureRemoteReadyForSessionStart: asyncNoop,+ checkWorkDirExists: async () => true, readSessionWorkingDirFromDb: async () => workingDir,+ readWorkingDirectoryRecoveryCreateOpts: async id => {+ const row = await readRow(id);+ return { id, agentKind: 'codex', model: row.model ?? undefined, providerId: row.providerId,+ resumeSessionId: row.sdkSessionId ?? undefined, workingDir };+ },+ isOrcaMcpHydrated: () => true, buildCreateOptsWithStderr: opts => opts,+ synthesizeOrcaVendorOptionsFromDb: async () => false, readSessionExtraDirsFromDb: async () => [],+ withRehydrateCloseSuppressed: async (_id, run) => run(),+ bootstrapSession: async opts => ({ session: await bootstrap(opts.id!), didInjectOrcaInstructions: false, didInjectProjectContext: false }),+ markOrcaRoleIfNeeded: asyncNoop, broadcastSessionCreated: noop,+ prepareSendUserMessage: async (_id, message) => message as string,+ createDbMessage: input.createMessage, isSessionRunningError: () => false, log,+ };+ const transaction = createMakerSendTransaction(transactionDeps);+ const handlers = new Map<string, IpcHandler>();+ const registry = { handle: (channel: string, handler: IpcHandler) => { handlers.set(channel, handler); } };+ registerSessionSetModelHandler(registry, { isDeviceLinkInvoke: () => false, assertTrustedSender: noop,+ apply: (id, model, providerId, revision, selection) => apply(id as string, model as string, providerId as string, revision, selection, { source: 'user' }),+ });+ registerMakerSessionSendHandler(registry, { sendToAgentAccepted: async (id, message, opts, sendOpts) => {+ const lease = await beforeSend(id);+ try { return await transaction.sendToAgentAccepted(id, message, opts, sendOpts); }+ finally { lease.release(); }+ } });+ return {+ pending,+ pick: (id: string, providerId: string, model = 'fixture-model') => handlers.get(MAKER_INVOKE.SET_MODEL)!(null, id, model, providerId),+ send: (id: string, clientId: string) => handlers.get(MAKER_INVOKE.SEND)!(null, id, 'picker fixture',+ { id, agentKind: 'codex', model: 'fixture-model', workingDir },+ { messageUuid: clientId, persistUserMessage: { clientId, content: 'picker fixture' } }),+ };+}diff --git a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.tsindex 4eb1034a42..7184742fc5 100644--- a/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/codexProxyHost.test.ts@@ -8135,6 +8135,233 @@ describe('createModelRoutingTransform —— custom Provider native imagegen pre}});+ it('selects namespaced smart children before routing, preserving lineage and frozen authorization', async () => {+ const received: Array<{ path: string; body: Record<string, unknown>; key: string; account: unknown }> = [];+ const upstream = createServer(async (req, res) => {+ const chunks: Buffer[] = [];+ for await (const chunk of req) chunks.push(Buffer.from(chunk));+ received.push({ path: req.url ?? '', body: JSON.parse(Buffer.concat(chunks).toString()),+ key: String(req.headers.authorization), account: req.headers['chatgpt-account-id'] });+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');+ });+ await new Promise<void>(resolve => upstream.listen(0, '127.0.0.1', resolve));+ const host = await freshCodexProxyHost();+ const actual = await vi.importActual<typeof import('@cindy/anthropic-compat-proxy')>('@cindy/anthropic-compat-proxy');+ mockState.createAnthropicCompatProxy.mockImplementationOnce(actual.createAnthropicCompatProxy);+ const { BUNDLED_CATALOG, buildUserProvider } = await import('@cindy/model-providers');+ const { setActiveCatalog } = await import('../active-catalog.js');+ const routing = await import('../provider-route.js');+ const sessions = await import('../session-provider-store.js');+ const { deriveCodexCustomProviderRoutes } = await import('../codex-custom-provider-route.js');+ const endpoint = `http://127.0.0.1:${(upstream.address() as AddressInfo).port}`;+ const providers = ['parent', 'child', 'nested'].map(id => buildUserProvider({+ id: `cprov-${id}`, name: id, runtimes: { codex: {+ baseUrl: `${endpoint}/${id}`, wireProtocol: 'openai-responses', supportsImageGeneration: true,+ models: [{ id: `${id}-model`, name: id, reasoning: true, reasoningEfforts: ['high'] }],+ } },+ }));+ const catalog = { ...BUNDLED_CATALOG, providers: [...BUNDLED_CATALOG.providers, ...providers] };+ setActiveCatalog(catalog);+ const readKey = vi.fn((id: string) => `synthetic-${id}`);+ routing.setCustomProviderKeyReader(readKey);+ const routes = deriveCodexCustomProviderRoutes(catalog);+ const parent = routes.find(route => route.providerId === 'cprov-parent')!;+ const candidates = providers.map(provider => ({ providerId: provider.id,+ catalogModel: provider.models.codex![0]!.id, reasoningEffort: 'high' as const }));+ sessions.setSessionProvider('smart-source', 'cprov-parent');+ const register = (fixed = false) => host.registerComposed('smart-source', 'root', 'fixture', {+ smartSubagentRoutes: candidates,+ ...(fixed ? { subagentRoute: candidates[1] } : {}),+ });+ register();+ try {+ await host.ensureCodexCustomContextProxyReady('smart-namespace', 'provider-oauth', routes);+ const proxy = host.getCodexCustomContextProxyEndpoint('smart-namespace');+ const post = async (model: string, thread: string, parentThread?: string, kind = 'collab_spawn', routeId = parent.routeId) => {+ const response = await fetch(`${proxy}/_cindy/custom-provider/${routeId}/responses`, {+ method: 'POST', headers: { 'content-type': 'application/json', 'thread-id': thread,+ 'chatgpt-account-id': 'must-not-leak',+ ...(parentThread ? { 'x-codex-parent-thread-id': parentThread, 'x-openai-subagent': kind } : {}) },+ body: JSON.stringify({ model, input: [], vendor_field: 'retain', reasoning: { effort: 'low', summary: 'auto' } }),+ });+ await response.text();+ return response.status;+ };+ // Before any thread notification: the genuine first collab request selects its candidate.+ expect(await post('child-model', 'child', 'root')).toBe(200);+ expect(received.at(-1)).toMatchObject({ path: '/child/responses', key: 'Bearer synthetic-cprov-child',+ account: undefined, body: { model: 'child-model', vendor_field: 'retain', reasoning: { effort: 'high', summary: 'auto' } } });+ expect(host.registerChildThread('root', 'child')).toBe(true);+ expect(await post('nested-model', 'grandchild', 'child')).toBe(200);+ expect(host.registerChildThread('child', 'grandchild')).toBe(true);+ expect(await post('nested-model', 'grandchild', 'child')).toBe(200);+ expect(received.at(-1)).toMatchObject({ path: '/nested/responses', key: 'Bearer synthetic-cprov-nested', body: { model: 'nested-model' } });+ expect(await post('parent-model', 'same-provider', 'root')).toBe(200);+ expect(received.at(-1)?.path).toBe('/parent/responses');+ expect(await post('parent-model', 'root')).toBe(200);+ expect(received.at(-1)?.body).toMatchObject({ model: 'parent-model', vendor_field: 'retain' });+ const before = received.length;+ readKey.mockClear();+ expect(await post('child-model', 'unknown-child', 'unknown-parent')).toBe(403);+ expect(await post('child-model', 'guardian', 'root', 'guardian')).toBe(403);+ expect(await post('child-model', 'unmarked')).toBe(403);+ expect(await post('foreign-model', 'unselected', 'root')).toBe(403);+ expect(await post('child-model', 'forged', 'root', 'collab_spawn', 'bbbbbbbbbbbbbbbbbbbb')).toBe(403);+ expect(readKey).not.toHaveBeenCalled();+ const finish = routing.beginProviderRouteMutation('cprov-child');+ try { expect(await post('child-model', 'child', 'root')).toBe(503); }+ finally { finish.commit(); finish(); }+ expect(await post('child-model', 'child', 'root')).toBe(503);+ expect(received).toHaveLength(before);+ expect(readKey).not.toHaveBeenCalled();+ host.unregister('smart-source');+ expect(await post('child-model', 'child', 'root')).toBe(403);+ // A legacy locked route still overrides native inheritance, even with smart candidates present.+ register(true);+ expect(await post('parent-model', 'locked', 'root')).toBe(200);+ expect(received.at(-1)).toMatchObject({ path: '/child/responses', body: { model: 'child-model', reasoning: { effort: 'high' } } });+ expect(await post('nested-model', 'locked-nested', 'locked')).toBe(200);+ expect(received.at(-1)?.body.model).toBe('child-model');+ // A credential read is an await boundary in route resolution: neither a+ // committed mutation nor unregister may dispatch the captured old decision.+ for (const change of ['mutation', 'unregister'] as const) {+ host.unregister('smart-source');+ register();+ const count = received.length;+ readKey.mockImplementationOnce((id) => {+ if (change === 'mutation') {+ const done = routing.beginProviderRouteMutation(id); done.commit(); done();+ } else host.unregister('smart-source');+ return `synthetic-${id}`;+ });+ expect(await post('child-model', `read-race-${change}`, 'root')).toBe(503);+ expect(received).toHaveLength(count);+ }+ } finally {+ host.unregister('smart-source');+ sessions.clearSessionProvider('smart-source');+ await host.releaseCodexCustomContextProxy('smart-namespace');+ routing.setCustomProviderKeyReader(() => null);+ setActiveCatalog(BUNDLED_CATALOG);+ upstream.closeAllConnections();+ await new Promise<void>(resolve => upstream.close(() => resolve()));+ }+ });++ it('runs the existing xAI outbound chain once for authorized namespace escapes, like ordinary Responses', async () => {+ const received: Array<{ body: Record<string, unknown>; auth: unknown; account: unknown }> = [];+ const server = createServer(async (req, res) => {+ const chunks: Buffer[] = [];+ for await (const chunk of req) chunks.push(Buffer.from(chunk));+ received.push({ body: JSON.parse(Buffer.concat(chunks).toString()), auth: req.headers.authorization,+ account: req.headers['chatgpt-account-id'] });+ res.writeHead(200, { 'content-type': 'application/json' }).end('{}');+ });+ await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));+ const host = await freshCodexProxyHost();+ const actual = await vi.importActual<typeof import('@cindy/anthropic-compat-proxy')>('@cindy/anthropic-compat-proxy');+ mockState.createAnthropicCompatProxy.mockImplementationOnce(actual.createAnthropicCompatProxy);+ const { BUNDLED_CATALOG, buildUserProvider } = await import('@cindy/model-providers');+ const catalog = await import('../active-catalog.js');+ const routing = await import('../provider-route.js');+ const sessions = await import('../session-provider-store.js');+ const { deriveCodexCustomProviderRoutes } = await import('../codex-custom-provider-route.js');+ const { selectCodexSmartSubagentCandidates } = await import('../codex-smart-subagent-routing.js');+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;+ const parent = buildUserProvider({ id: 'cprov-wire', name: 'Synthetic parent', runtimes: { codex: {+ baseUrl: endpoint, wireProtocol: 'openai-responses', supportsImageGeneration: true,+ models: [{ id: 'api-parent', name: 'Parent', reasoningEfforts: ['high'] }],+ } } });+ // Use the bundled contract, changing only the network destination to loopback.+ const xai = structuredClone(BUNDLED_CATALOG.providers.find(provider => provider.id === 'xai')!);+ xai.routing.codex!.upstream = endpoint;+ catalog.setActiveCatalog({ ...BUNDLED_CATALOG, providers: [parent, xai] });+ routing.setCustomProviderKeyReader(() => 'synthetic-parent');+ const readOAuth = vi.fn(async () => 'synthetic-xai');+ routing.setProviderOAuthTokenReader(readOAuth);+ const candidates = selectCodexSmartSubagentCandidates([parent, xai].map(provider => ({ ...provider, connected: true, agents: ['codex'] })),+ { allowChatGptOAuth: true, oauthProviderId: parent.id });+ expect(candidates.some(candidate => candidate.providerId === 'xai' && candidate.model.id === 'xai/grok-4.7')).toBe(true);+ const routes = deriveCodexCustomProviderRoutes(catalog.getActiveCatalog());+ const route = routes.find(item => item.providerId === parent.id)!;+ sessions.setSessionProvider('wire-source', parent.id);+ const register = () => host.registerComposed('wire-source', 'wire-root', 'synthetic', {+ smartSubagentRoutes: candidates.map(candidate => ({ providerId: candidate.providerId, catalogModel: candidate.model.id, reasoningEffort: 'high' })),+ });+ register();+ let release = () => {};+ try {+ await host.ensureCodexCustomContextProxyReady('wire-scope', 'provider-oauth', routes);+ const proxy = host.getCodexCustomContextProxyEndpoint('wire-scope');+ const namespace = `/_cindy/custom-provider/${route.routeId}/responses`;+ const body = { model: 'xai/grok-4.7', input: [], instructions: 'synthetic instructions',+ reasoning: { effort: 'low' }, tools: [{ type: 'namespace', name: 'multi_agent_v1', tools: [] }] };+ const post = async (url: string, payload = body, thread = 'wire-child', parentThread = 'wire-root') => {+ const response = await fetch(proxy + url, { method: 'POST', headers: {+ 'content-type': 'application/json', 'thread-id': thread, 'chatgpt-account-id': 'must-not-leak',+ ...(parentThread ? { 'x-codex-parent-thread-id': parentThread, 'x-openai-subagent': 'collab_spawn' } : {}),+ }, body: JSON.stringify(payload) });+ await response.text(); return response.status;+ };+ expect(await post(namespace)).toBe(200);+ const escaped = received.at(-1)!;+ expect(escaped).toMatchObject({ auth: 'Bearer synthetic-xai', account: undefined,+ body: { model: 'grok-4.7', reasoning: { effort: 'high' }, tools: [{ type: 'x_search' }],+ input: [{ type: 'message', role: 'system', content: 'synthetic instructions' }] } });+ expect(escaped.body.tools).toEqual([{ type: 'x_search' }]);+ expect(escaped.body.input).toHaveLength(1);+ expect(readOAuth).toHaveBeenCalledTimes(1);+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(1);+ expect(await post('/responses')).toBe(200);+ expect(received.at(-1)).toEqual(escaped);+ expect(readOAuth).toHaveBeenCalledTimes(2);+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);+ // Same-provider namespace children and parent requests must not inherit the+ // previous request's authorization to run the ordinary outbound chain.+ const parentBody = { ...body, model: 'api-parent', reasoning: { effort: 'high' } };+ expect(await post(namespace, parentBody, 'wire-root', '')).toBe(200);+ expect(received.at(-1)?.body).toEqual(parentBody);+ expect(await post(namespace, parentBody, 'same-provider')).toBe(200);+ expect(received.at(-1)?.body).toEqual(parentBody);+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);+ // Changing ownership or routing during the token read must not enable the chain.+ for (const change of ['mutation', 'unregister'] as const) {+ host.unregister('wire-source'); register();+ let entered!: () => void;+ const reading = new Promise<void>(resolve => { entered = resolve; });+ const gate = new Promise<void>(resolve => { release = resolve; });+ readOAuth.mockImplementationOnce(async () => { entered(); await gate; return 'synthetic-xai'; });+ const count = received.length;+ const pending = post(namespace, body, `race-${change}`);+ await reading;+ if (change === 'mutation') {+ const finish = routing.beginProviderRouteMutation('xai'); finish.commit(); finish();+ } else host.unregister('wire-source');+ release();+ expect(await pending).toBe(503);+ expect(received).toHaveLength(count);+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(2);+ }+ // Authorization remains checked after the newly enabled transform chain.+ host.unregister('wire-source'); register();+ mockState.injectionTransform.mockImplementationOnce(() => {+ const finish = routing.beginProviderRouteMutation('xai'); finish.commit(); finish();+ return null;+ });+ const count = received.length;+ expect(await post(namespace, body, 'transform-race')).toBe(503);+ expect(received).toHaveLength(count);+ expect(mockState.injectionTransform).toHaveBeenCalledTimes(3);+ expect(readOAuth).toHaveBeenCalledTimes(5);+ } finally {+ release(); host.unregister('wire-source'); sessions.clearSessionProvider('wire-source');+ await host.releaseCodexCustomContextProxy('wire-scope');+ catalog.setActiveCatalog(BUNDLED_CATALOG); routing.setCustomProviderKeyReader(() => null);+ routing.setProviderOAuthTokenReader(async () => null);+ server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()));+ }+ });+it('owns every private custom Provider prefix before opaque body transforms', async () => {const host = await freshCodexProxyHost();mockState.createAnthropicCompatProxy.mockResolvedValueOnce({@@ -8168,3 +8395,104 @@ describe('createModelRoutingTransform —— custom Provider native imagegen preexpect(options.routeOpaqueRequestBody({ url: '/images/edits' })).toBe(false);});});++describe('official Subagents on external credential Hosts', () => {+ it('invalidates a captured official child decision when its scoped proxy retires', async () => {+ const host = await freshCodexProxyHost();+ mockState.createAnthropicCompatProxy.mockResolvedValueOnce({ url: 'http://127.0.0.1:43210', dispose: vi.fn(async () => undefined) });+ await host.ensureCodexCustomContextProxyReady('external-scope', 'provider-oauth', []);+ host.setCodexSubagentOAuthReader(async () => ({ accessToken: 'synthetic-child', accountId: 'fixture', canDispatch: () => true }));+ host.registerComposed('scoped-parent', 'scoped-parent-thread', 'fixture', {+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },+ });+ try {+ const route = mockState.createAnthropicCompatProxy.mock.calls[0]?.[0]?.routingTransform;+ if (!route) throw new Error('missing scoped routing transform');+ const decision = await route({ model: 'gpt-5.4' }, { reqId: 1, method: 'POST', url: '/responses', headers: {+ 'thread-id': 'scoped-child', 'x-openai-subagent': 'collab_spawn', 'x-codex-parent-thread-id': 'scoped-parent-thread',+ } });+ expect(decision?.dispatchGenerationValid?.()).toBe(true);+ await host.releaseCodexCustomContextProxy('external-scope');+ expect(decision?.dispatchGenerationValid?.()).toBe(false);+ } finally { await host.disposeCodexProxy(); }+ });++ it.each(['env-key', 'provider-oauth'].flatMap((mode) => [false, true].map((revoked) => ({ mode, revoked }))))('reads host OAuth only for an explicit official child ($mode revoked=$revoked)', async ({ mode, revoked }) => {+ const host = await freshCodexProxyHost();+ mockState.createAnthropicCompatProxy.mockResolvedValueOnce({+ url: 'http://127.0.0.1:43210', dispose: vi.fn(async () => undefined),+ });+ await host.ensureCodexProxyReady();+ const canDispatch = vi.fn(() => true);+ const reader = vi.fn(async () => {+ if (revoked) throw new Error('synthetic revoked OAuth');+ return { accessToken: 'synthetic-child-token', accountId: 'fixture-account', canDispatch };+ });+ host.setCodexSubagentOAuthReader(reader);+ const { setSessionProvider, clearSessionProvider } = await import('../session-provider-store.js');+ setSessionProvider('external-parent-session', 'external-fixture');+ host.registerComposed('external-parent-session', 'external-parent-thread', 'fixture', {+ subagentRoute: { providerId: 'openai', catalogModel: 'gpt-5.4', reasoningEffort: 'high' },+ });+ try {+ const parentRoutes = [{+ providerId: 'external-fixture', routeId: 'aaaaaaaaaaaaaaaaaaaa', modelProviderId: 'fixture',+ capabilities: {}, responseModels: ['custom-parent-model'], credentialRevision: 0,+ routing: { upstream: 'https://example.invalid', authStrategy: 'api-key-header' as const }, responseRoutingByModel: {}, responseEffortsByModel: {},+ }];+ const transform = host.createModelRoutingTransform(mode as 'env-key' | 'provider-oauth', parentRoutes);+ await transform({ model: 'custom-parent-model' }, {+ reqId: 1, method: 'POST', url: '/responses', headers: { 'thread-id': 'external-parent-thread' },+ });+ expect(reader).not.toHaveBeenCalled();+ const decision = await transform({ model: 'gpt-5.4' }, {+ reqId: 2, method: 'POST', url: '/_cindy/custom-provider/aaaaaaaaaaaaaaaaaaaa/responses', headers: {+ 'thread-id': 'official-child-thread', 'x-openai-subagent': 'collab_spawn',+ 'x-codex-parent-thread-id': 'external-parent-thread',+ },+ });+ expect(reader).toHaveBeenCalledOnce();+ if (revoked) {+ expect(decision).toHaveProperty('localHandler');+ } else {+ expect(decision).toMatchObject({+ upstreamOverride: 'https://chatgpt.com/backend-api/codex',+ pathOverride: '/responses',+ headerOverride: { authorization: 'Bearer synthetic-child-token', 'chatgpt-account-id': 'fixture-account' },+ dispatchGenerationValid: expect.any(Function),+ });+ expect(decision?.dispatchGenerationValid?.()).toBe(true);+ host.unregister('external-parent-session');+ expect(decision?.dispatchGenerationValid?.()).toBe(false);+ }+ } finally {+ clearSessionProvider('external-parent-session');+ await host.disposeCodexProxy();+ }+ });+});+++describe('external host proxy isolation', () => {+ it('keeps subscription WebSocket routing when an external HTTP host starts and retires', async () => {+ const host = await freshCodexProxyHost();+ mockState.createAnthropicCompatProxy+ .mockResolvedValueOnce({ url: 'http://127.0.0.1:41011', dispose: vi.fn(async () => undefined) })+ .mockResolvedValueOnce({ url: 'http://127.0.0.1:41012', dispose: vi.fn(async () => undefined) });+ host.setCodexProxyAuthInjection('oauth-bearer');+ await host.ensureCodexProxyReady();+ try {+ await host.ensureCodexCustomContextProxyReady('local:external-auth:1', 'provider-oauth', []);+ const official = mockState.createAnthropicCompatProxy.mock.calls[0][0];+ const external = mockState.createAnthropicCompatProxy.mock.calls[1][0];+ const context = { url: '/responses', headers: { 'thread-id': 'official-parent' } };+ expect(host.getCodexProxyAuthInjection()).toBe('oauth-bearer');+ expect(official.resolveWebSocketUpstream?.(context)).toBe('https://chatgpt.com/backend-api/codex');+ expect(external.resolveWebSocketUpstream?.(context)).toBeNull();+ await host.releaseCodexCustomContextProxy('local:external-auth:1');+ expect(official.resolveWebSocketUpstream?.(context)).toBe('https://chatgpt.com/backend-api/codex');+ } finally {+ await host.disposeCodexProxy();+ }+ });+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.tsnew file mode 100644index 0000000000..1d3a458499--- /dev/null+++ b/apps/desktop/src/main/maker-host/__tests__/codexRouteTransaction.integration.test.ts@@ -0,0 +1,599 @@+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';+import { createServer } from 'node:http';+import type { AddressInfo } from 'node:net';+import { tmpdir } from 'node:os';+import path from 'node:path';+import { describe, expect, it, vi } from 'vitest';+import Database from 'better-sqlite3';+import { drizzle } from 'drizzle-orm/better-sqlite3';+import { getTableColumns } from 'drizzle-orm';+import { createCodexPickerHarness } from './codexPickerHarness.js';+import type { DbClient } from '../../localDb/client/DbClient.js';+import { sessions } from '../../localDb/schema.js';+import { commitCodexThreadTransfer, relinkCodexProviderThread, type CodexThreadTransferSnapshot } from '../../maker-ipc/codexProviderThreadRelink.js';+import { applyRuntimeSetModelChange } from '../../maker-ipc/runtimeSetModel.js';+import { clearSessionProvider, setSessionProvider } from '../session-provider-store.js';+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';+import { Maker } from '../../../../../../packages/maker-core/src/maker.js';+import type { SessionMeta, SessionStorage } from '../../../../../../packages/maker-core/src/interfaces/session-storage.js';+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';+import { buildUserProvider } from '@cindy/model-providers';+import { setCustomProviders } from '../active-catalog.js';+import { beginProviderRouteMutation, captureCodexLocalAuthPolicy } from '../provider-route.js';+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));++// Explicit opt-in: never discover a user's installed runtime or credentials.+const binaryPath = process.env.CINDY_TEST_CODEX_BINARY;+const logger: Logger = {+ trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {},+ child: () => logger,+};++describe.skipIf(!binaryPath)('Desktop route transactions with real Codex app-server', () => {+ it.each([...['A', 'B', 'C', 'initialize', 'capability', 'resume', 'transfer'].flatMap((window) => [false, true].map((reviewMode) => ({ window, reviewMode }))), ...['skills', 'config'].map((window) => ({ window, reviewMode: true })), ...['restricted', 'bot', 'local-skill', 'transfer-fork-failure', 'transfer-cas-failure', 'transfer-resume-failure', 'transfer-busy', 'transfer-retire-resolve-success', 'transfer-retire-resolve-failure', 'transfer-retire-list-success', 'transfer-retire-list-failure', 'transfer-picker', 'transfer-picker-shared', 'transfer-picker-resume-failure', 'transfer-picker-shared-resume-failure', 'transfer-picker-cold-task', 'transfer-picker-cold-control', 'transfer-picker-shared-cold-task', 'transfer-picker-shared-cold-control'].map((window) => ({ window, reviewMode: false }))])('waits for Desktop window $window with Review=$reviewMode before start and switch', async ({ window, reviewMode }) => {+ const releases: Array<() => void> = [];+ const beginMutation = () => { const finish = beginProviderRouteMutation('cprov-fixture'); releases.push(finish); return finish; };+ const lateWindow = ['initialize', 'capability', 'resume', 'skills', 'config', 'restricted', 'bot', 'local-skill'].includes(window);+ const revoked = !lateWindow && !window.startsWith('transfer');+ const root = await mkdtemp(path.join(tmpdir(), 'cindy-codex-host-auth-'));+ const home = path.join(root, 'codex');+ const coldHome = path.join(root, 'cold-official');+ const coldWindow = window.includes('cold-');+ let releaseOAuth = () => {};+ const oauthGate = new Promise<void>(resolve => { releaseOAuth = resolve; });+ let refreshEntered = () => {};+ const refreshRequested = new Promise<void>(resolve => { refreshEntered = resolve; });+ let coldStart: Promise<unknown> | undefined;+ let coldHost: AppServerHost | undefined;+ let coldSettled = false;+ let coldShutdown: { mockRestore: () => void } | undefined;+ const workingDir = path.join(root, 'work');+ await mkdir(home);+ await mkdir(workingDir);+ const calls: string[] = [];+ let responseGate: Promise<void> | undefined;+ let releaseResponse = () => {};+ const server = createServer(async (req, res) => {+ for await (const chunk of req) void chunk;+ calls.push(`${req.method} ${req.url}`);+ if (coldWindow && req.url === '/oauth/token') { refreshEntered(); await oauthGate; }+ if (req.url === '/provider/responses') {+ expect(req.headers.authorization).toBe('Bearer synthetic-invalid-api-key');+ await responseGate;+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });+ const events = [+ { type: 'response.created', response: { id: 'response-fixture' } },+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: 'message-fixture', content: [{ type: 'output_text', text: 'fixture complete' }] } },+ { type: 'response.completed', response: { id: 'response-fixture', usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },+ ];+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));+ } else {+ res.writeHead(401, { 'content-type': 'application/json' });+ res.end(JSON.stringify({ error: { code: req.url === '/oauth/token' ? 'refresh_token_invalidated' : 'unauthorized', message: 'synthetic revoked token' } }));+ }+ });+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;+ const authPath = path.join(home, 'auth.json');+ let authFixture: string | undefined;+ if (revoked) {+ const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url');+ authFixture = JSON.stringify({+ auth_mode: 'chatgpt', OPENAI_API_KEY: null,+ tokens: {+ id_token: `${encode({ alg: 'none', typ: 'JWT' })}.${encode({ email: '[email protected]', 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_user_id: 'fixture-user', chatgpt_account_id: 'fixture-account' } })}.c3ludGhldGlj`,+ access_token: 'synthetic-invalid-access-token', refresh_token: 'synthetic-invalid-refresh-token', account_id: 'fixture-account',+ }, last_refresh: new Date().toISOString(),+ });+ await writeFile(authPath, authFixture, { mode: 0o600 });+ }+ await writeFile(path.join(home, 'config.toml'), [+ 'model="fixture-model"', 'model_provider="fixture"', 'cli_auth_credentials_store="file"',+ `chatgpt_base_url="${endpoint}"`, 'check_for_update_on_startup=false',+ '[analytics]', 'enabled=false',+ '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',+ '[model_providers.fixture]', 'name="Fixture"', `base_url="${endpoint}/provider"`,+ 'wire_api="responses"', 'env_key="FIXTURE_API_KEY"', 'requires_openai_auth=false', 'supports_websockets=false', 'request_max_retries=0',+ ].join('\n'));+ if (coldWindow) {+ await mkdir(coldHome);+ await writeFile(path.join(coldHome, 'config.toml'), `sqlite_home=${JSON.stringify(home)}\n` + (await readFile(path.join(home, 'config.toml'), 'utf8')));+ const claims = { exp: 1, 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_account_id: 'cold-official' } };+ const token = `eyJhbGciOiJub25lIn0.${Buffer.from(JSON.stringify(claims)).toString('base64url')}.synthetic`;+ await writeFile(path.join(coldHome, 'auth.json'), JSON.stringify({ auth_mode: 'chatgpt', tokens: {+ id_token: token, access_token: token, refresh_token: 'synthetic-cold-refresh', account_id: 'cold-official',+ }, last_refresh: '2000-01-01T00:00:00Z' }), { mode: 0o600 });+ }+ setCustomProviders([buildUserProvider({ id: 'cprov-fixture', name: 'Fixture', runtimes: { codex: { baseUrl: `${endpoint}/provider`, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);+ const spawnConfigs: string[] = [];+ let preparationGate: Promise<void> | undefined;+ const preparationEntered = vi.fn();+ let latePreparation: (() => Promise<void>) | undefined;+ let rejectResumeRequest = false;+ const agent = new CodexAgent({+ binaryPath: binaryPath!, logger, runtimeConfig: {},+ ...(window.includes('picker') && !window.includes('shared') ? { isolateCodexAccountSessions: true } : {}),+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,+ isCodexAccountProvider: providerId => providerId === 'account-cold',+ ...(window === 'restricted' ? { capabilityRouting: { overrides: [{ capabilityId: 'computer-use', source: { kind: 'harness-plugin' as const, harness: 'codex' as const, surface: 'skill' as const, id: 'computer-use:computer-use', artifactId: 'computer-use', containerId: 'computer-use@openai-bundled' }, invocation: 'disabled' as const }] } } : {}),+ ...(window === 'local-skill' ? { getDisabledSkillPaths: () => [path.join(root, 'disabled-skill')] } : {}),+ resolveCapabilityRouting: async () => { if (window === 'capability') await latePreparation?.(); return undefined; },+ prepareCodexResumeSession: async () => { preparationEntered(); if (window === 'resume') await latePreparation?.(); await preparationGate; return undefined; },+ prepareCodexExtraSpawnConfig: async (_providers, ctx) => { spawnConfigs.push(ctx?.localAuthPolicy ?? 'legacy-shared'); return { extraArgs: [], extraEnv: {}, codexProxyActive: true }; },+ auth: {+ getState: async () => ({ authenticated: true }),+ triggerLogin: async () => ({ authenticated: true }), logout: async () => {},+ getAuthEnv: async (opts) => ({+ HOME: root, CODEX_HOME: opts?.providerId === 'account-cold' ? coldHome : home, TMPDIR: root, FIXTURE_API_KEY: 'synthetic-invalid-api-key',+ OPENAI_API_KEY: '', CODEX_API_KEY: '',+ CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`,+ HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost',+ }),+ },+ });+ const spies: Array<{ mockRestore: () => void }> = [];+ try {+ if (window.startsWith('transfer')) {+ const sqlite = new Database(':memory:');+ sqlite.exec('CREATE TABLE sessions (id TEXT PRIMARY KEY, status TEXT, agent_kind TEXT, remote_host_id TEXT, sdk_session_id TEXT, model TEXT, provider_id TEXT, effort TEXT, fast_mode INTEGER, updated_at INTEGER)');+ if (window.includes('picker')) {+ const existing = new Set((sqlite.prepare('PRAGMA table_info(sessions)').all() as Array<{ name: string }>).map(column => column.name));+ for (const column of Object.values(getTableColumns(sessions))) {+ if (!existing.has(column.name)) sqlite.exec(`ALTER TABLE sessions ADD COLUMN "${column.name}" ${column.getSQLType()}`);+ }+ sqlite.exec('CREATE TABLE picker_messages (client_id TEXT PRIMARY KEY, session_id TEXT, content TEXT)');+ }+ const db = { drizzle: drizzle(sqlite) } as unknown as Pick<DbClient, 'drizzle'>;+ const rows = new Map<string, SessionMeta>();+ const storage: SessionStorage = {+ create: async (meta) => {+ const row = { ...meta, createdAt: 1, updatedAt: 1 }; rows.set(row.id, row);+ sqlite.prepare('INSERT INTO sessions (id,status,agent_kind,remote_host_id,sdk_session_id,model,provider_id,effort,fast_mode,updated_at) VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?, ?)').run(row.id, 'active', 'codex', row.sdkSessionId ?? null, row.model, 'openai', 'high', 0, 1);+ if (window.includes('picker')) sqlite.prepare('UPDATE sessions SET working_dir = ?, context_tokens = 1, context_window = 258400 WHERE id = ?').run(workingDir, row.id);+ return row;+ },+ get: async (id) => {+ const persisted = sqlite.prepare('SELECT sdk_session_id AS sdkSessionId, model FROM sessions WHERE id = ?').get(id) as { sdkSessionId: string; model: string } | undefined;+ return rows.has(id) ? { ...rows.get(id)!, ...persisted } : null;+ },+ list: async () => [...rows.values()],+ update: async (id, patch) => {+ const row = { ...rows.get(id)!, ...patch }; rows.set(id, row);+ if (patch.sdkSessionId) sqlite.prepare('UPDATE sessions SET sdk_session_id = ? WHERE id = ?').run(patch.sdkSessionId, id);+ return row;+ },+ compareAndClearSdkSessionId: async () => false,+ delete: async (id) => { rows.delete(id); },+ };+ const maker = new Maker({ agents: { codex: agent }, storage, logger });+ const send = async (session: NonNullable<ReturnType<Maker['getSession']>>) => {+ let off: () => void = () => {};+ const done = new Promise<void>((resolve, reject) => {+ off = session.onEvent((event) => {+ if (event.type === 'error') { off(); reject(new Error(JSON.stringify(event))); }+ if (event.type === 'done') { off(); resolve(); }+ });+ });+ const result = await session.send('fixture transfer');+ if (!result.accepted) { off(); return; }+ await done;+ };+ const acceptedForks: AppServerHost[] = [];+ const request = AppServerHost.prototype.request;+ const requestSpy = vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {+ if (method === 'thread/resume' && rejectResumeRequest) {+ rejectResumeRequest = false;+ params = { ...params as object, modelProvider: 'missing-fixture-provider' };+ }+ return request.call(this, method, params, { ...opts, beforeDispatch: () => {+ opts?.beforeDispatch?.(); if (method === 'thread/fork') acceptedForks.push(this);+ } });+ });+ spies.push(requestSpy);+ try {+ setSessionProvider('source', 'openai');+ const retirementWindow = window.startsWith('transfer-retire');+ const sibling = await maker.createSession({ id: 'unrelated', agentKind: 'codex', providerId: retirementWindow ? 'cprov-fixture' : 'openai', model: 'fixture-model', workingDir });+ let source = await maker.createSession({ id: 'source', agentKind: 'codex', providerId: 'openai', model: 'fixture-model', workingDir, ...(reviewMode ? { reviewMode: true as const } : {}) });+ await send(source);+ const hostMap = (agent as unknown as { hosts: Map<string, AppServerHost> }).hosts;+ const siblingHost = hostMap.get(sibling.codexHostKey ?? (retirementWindow ? 'local:external-auth' : 'local'))!;+ const connection = siblingHost.getConnectionId();+ if (window.includes('picker')) {+ const picker = createCodexPickerHarness({ maker, db, workingDir, createMessage: async (id, message) => {+ sqlite.prepare('INSERT INTO picker_messages VALUES (?, ?, ?)').run(message.clientId, id, JSON.stringify(message.content));+ } });+ const routes = coldWindow ? ['xd', 'xd', 'openai', 'cprov-fixture', 'cprov-fixture', 'openai'] : ['xd', 'openai', 'cprov-fixture', 'openai'];+ for (const [index, providerId] of routes.entries()) {+ if (coldWindow && index === 1) {+ const start = window.endsWith('control')+ ? agent.readAccountRateLimits('account-cold')+ : agent.startSession({ sessionId: 'cold-official', providerId: 'account-cold', model: 'fixture-model', workingDir });+ coldStart = start.then(() => { coldSettled = true; }, () => { coldSettled = true; });+ await refreshRequested;+ coldHost = [...hostMap].find(([key]) => key.includes('account-cold'))![1];+ coldShutdown = vi.spyOn(coldHost, 'shutdown');+ spies.push(coldShutdown);+ }+ const sameHostModelChange = coldWindow && routes[index - 1] === providerId;+ const previousSession = source;+ const original = (await storage.get('source'))!.sdkSessionId;+ const originalPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(original!);+ const originalHistory = await readFile(originalPath, 'utf8');+ const forksBefore = acceptedForks.length;+ const requestsBefore = calls.filter(call => call === 'POST /provider/responses').length;+ expect(await picker.pick('source', providerId, coldWindow && (index === 1 || index === 4) ? 'fixture-model-two' : 'fixture-model')).toMatchObject({ deferred: true, pendingUntilSend: true });+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);+ expect(maker.getSession('source')).toBe(source);+ expect(acceptedForks).toHaveLength(forksBefore);+ expect(sqlite.prepare('SELECT orca_role FROM sessions WHERE id = ?').get('source')).toEqual({ orca_role: null });+ if (window.endsWith('resume-failure') && index === 0) {+ rejectResumeRequest = true;+ await expect(picker.send('source', `picker-${index}`)).rejects.toThrow(/provider/i);+ expect(sqlite.prepare('SELECT count(*) AS n FROM picker_messages').get()).toEqual({ n: 0 });+ expect(calls.filter(call => call === 'POST /provider/responses')).toHaveLength(requestsBefore);+ }+ expect(await picker.send('source', `picker-${index}`)).toMatchObject({ accepted: true });+ source = maker.getSession('source')!;+ if (sameHostModelChange) {+ expect(source.codexHostKey).toBe(previousSession.codexHostKey);+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);+ expect((await storage.get('source'))!.model).toBe('fixture-model-two');+ }+ await expect.poll(() => source.isTurnRunning()).toBe(false);+ expect(calls.filter(call => call === 'POST /provider/responses')).toHaveLength(requestsBefore + 1);+ expect(sqlite.prepare('SELECT count(*) AS n FROM picker_messages').get()).toEqual({ n: index + 1 });+ expect(picker.pending.get('source')).toBeUndefined();+ expect(sqlite.prepare('SELECT provider_id FROM sessions WHERE id = ?').get('source')).toEqual({ provider_id: providerId });+ expect(acceptedForks.length - forksBefore).toBe(window.includes('shared') && routes[index - 1] !== providerId ? 1 : 0);+ const currentHistory = await readFile(originalPath, 'utf8');+ if (acceptedForks.length > forksBefore) expect(currentHistory).toBe(originalHistory);+ else expect(currentHistory.startsWith(originalHistory)).toBe(true);+ expect([...hostMap.keys()].some(key => key.startsWith('local-fork:'))).toBe(false);+ expect(siblingHost.getConnectionId()).toBe(connection);+ await send(sibling);+ if (coldHost) {+ expect(coldSettled).toBe(false);+ expect(coldShutdown).not.toHaveBeenCalled();+ expect(coldHost.hasStarted).toBe(true);+ expect(coldHost.writerCandidate).toBeNull();+ expect(requestSpy.mock.contexts.some((host, i) => host === coldHost && requestSpy.mock.calls[i][0] === 'thread/loaded/list')).toBe(false);+ }+ }+ return;+ }+ if (retirementWindow) {+ await maker.closeSession('source');+ const sourceRow = (await db.drizzle.select({ id: sessions.id, sdkSessionId: sessions.sdkSessionId, model: sessions.model, providerId: sessions.providerId, effort: sessions.effort, fastMode: sessions.fastMode, updatedAt: sessions.updatedAt }).from(sessions)).find((row) => row.id === 'source')!;+ const sourceHost = hostMap.get('local')!;+ const internals = agent as unknown as {+ resolveLocalAuthSelection(providerId: string | null | undefined, model: string): Promise<{ policy: 'isolated' | 'legacy-shared'; isCurrent(): boolean }>;+ retireHostKey(key: string, reason: string, opts: { failIfActive: boolean; logPrefix: string }): Promise<void>;+ };+ let queryEntered = false;+ let releaseQuery = () => {};+ let releaseExit = () => {};+ let rejectExit: (error: Error) => void = () => {};+ const queryGate = new Promise<void>((resolve) => { releaseQuery = resolve; });+ const exitGate = new Promise<void>((resolve, reject) => { releaseExit = resolve; rejectExit = reject; });+ const retire = sourceHost.retire.bind(sourceHost);+ const retireSpy = vi.spyOn(sourceHost, 'retire').mockImplementation(async (...args) => { await exitGate; return retire(...args); });+ spies.push(retireSpy);+ const originalResolve = internals.resolveLocalAuthSelection.bind(internals);+ const queryHook = window.includes('resolve')+ ? vi.spyOn(internals, 'resolveLocalAuthSelection').mockImplementationOnce(async (...args) => {+ queryEntered = true; await queryGate; return originalResolve(...args);+ })+ : vi.spyOn(sourceHost, 'request').mockImplementationOnce(async (method, params, options) => {+ expect(method).toBe('thread/loaded/list'); queryEntered = true; await queryGate;+ return request.call(sourceHost, method, params, options);+ });+ spies.push(queryHook);+ const target = { model: 'fixture-model', providerId: 'cprov-fixture', effort: 'high', fastMode: false };+ const commit = vi.fn(async ({ newSdkSessionId }: { newSdkSessionId: string }) => commitCodexThreadTransfer(db, sourceRow as CodexThreadTransferSnapshot, { ...target, sdkSessionId: newSdkSessionId, effort: 'high' }));+ const fork = vi.fn();+ let settled = false;+ const transfer = relinkCodexProviderThread({+ readSource: async () => ({ ...sourceRow, model: sourceRow.model!, workingDir }),+ needsFork: (threadId) => maker.requiresCodexThreadHostTransfer({ sessionId: 'source', threadId, model: target.model, providerId: target.providerId }),+ fork, commit,+ }, { sessionId: 'source', target });+ void transfer.then(() => { settled = true; }, () => { settled = true; });+ try {+ await expect.poll(() => queryEntered).toBe(true);+ const retirement = internals.retireHostKey('local', 'fixture retirement race', { failIfActive: false, logPrefix: 'fixture' });+ await expect.poll(() => retireSpy.mock.calls.length).toBe(1);+ releaseQuery();+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(settled).toBe(false);+ expect(commit).not.toHaveBeenCalled();+ if (window.endsWith('failure')) {+ rejectExit(new Error('fixture writer exit failed'));+ await retirement;+ await expect(transfer).rejects.toThrow('fixture writer exit failed');+ expect(commit).not.toHaveBeenCalled();+ } else {+ releaseExit(); await retirement;+ await expect(transfer).resolves.toMatchObject({ newSdkSessionId: sourceRow.sdkSessionId });+ expect(commit).toHaveBeenCalledTimes(1);+ const resumed = await maker.createSession({ id: 'source', agentKind: 'codex', model: target.model, providerId: target.providerId, workingDir, resumeSessionId: sourceRow.sdkSessionId! });+ await send(resumed);+ }+ const persisted = sqlite.prepare('SELECT sdk_session_id, provider_id FROM sessions WHERE id = ?').get('source');+ expect(persisted).toEqual({ sdk_session_id: sourceRow.sdkSessionId, provider_id: window.endsWith('failure') ? sourceRow.providerId : target.providerId });+ expect(fork).not.toHaveBeenCalled();+ expect((await storage.get('source'))!.sdkSessionId).toBe(sourceRow.sdkSessionId);+ expect(siblingHost.getConnectionId()).toBe(connection);+ await send(sibling);+ } finally { releaseQuery(); releaseExit(); retireSpy.mockRestore(); await retire('fixture cleanup'); }+ return;+ }+ if (window === 'transfer-busy') {+ responseGate = new Promise<void>((resolve) => { releaseResponse = resolve; });+ const inFlight = send(source);+ await expect.poll(() => source.isTurnRunning()).toBe(true);+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length).toBe(2);+ const relink = vi.fn(async () => {});+ await expect(applyRuntimeSetModelChange({+ maker, sessionId: 'source', model: 'fixture-model', providerId: 'cprov-fixture',+ requiresCodexThreadRelink: true, relinkCodexThread: relink,+ })).rejects.toThrow(/busy/);+ expect(relink).not.toHaveBeenCalled();+ expect(maker.getSession('source')).toBe(source);+ expect(acceptedForks).toHaveLength(0);+ await source.abort();+ releaseResponse();+ await inFlight;+ expect(siblingHost.getConnectionId()).toBe(connection);+ await send(sibling);+ return;+ }+ for (const providerId of ['cprov-fixture', 'openai']) {+ const sourceRow = (await db.drizzle.select({ id: sessions.id, sdkSessionId: sessions.sdkSessionId, model: sessions.model, providerId: sessions.providerId, effort: sessions.effort, fastMode: sessions.fastMode, updatedAt: sessions.updatedAt }).from(sessions)).find((row) => row.id === 'source')!;+ const original = sourceRow.sdkSessionId!;+ const rolloutPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(original);+ const history = await readFile(rolloutPath, 'utf8');+ const target = { sessionId: 'source', model: 'fixture-model', providerId, ...(reviewMode ? { reviewMode: true as const } : {}) };+ const required = await maker.requiresCodexThreadHostTransfer({ ...target, threadId: original });+ expect(required).toBe(true);+ const before = acceptedForks.length;+ const switching = applyRuntimeSetModelChange({+ maker, sessionId: 'source', model: target.model, providerId,+ requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer({ ...target, threadId: original }),+ relinkCodexThread: async () => {+ await relinkCodexProviderThread({+ readSource: async () => ({ ...sourceRow, model: sourceRow.model!, workingDir }),+ needsFork: (threadId) => maker.requiresCodexThreadHostTransfer({ ...target, threadId }),+ fork: ({ sourceSdkSessionId }) => maker.forkSdkSession('codex', { sourceSdkSessionId: window === 'transfer-fork-failure' ? '00000000-0000-4000-8000-000000000000' : sourceSdkSessionId, model: target.model, providerId, workingDir, stripEncryptedReasoning: false, upToMessageId: undefined }),+ commit: ({ newSdkSessionId }) => {+ if (window === 'transfer-cas-failure') sqlite.exec("UPDATE sessions SET model = 'newer', updated_at = 2 WHERE id = 'source'");+ return commitCodexThreadTransfer(db, sourceRow as CodexThreadTransferSnapshot, { sdkSessionId: newSdkSessionId, model: target.model, providerId, effort: 'high', fastMode: false });+ },+ }, { sessionId: 'source', target: { model: target.model, providerId, effort: 'high', fastMode: false } });+ },+ });+ if (window === 'transfer-fork-failure' || window === 'transfer-cas-failure') {+ await expect(switching).rejects.toThrow();+ expect((await storage.get('source'))!.sdkSessionId).toBe(original);+ if (window === 'transfer-cas-failure') expect((await storage.get('source'))!.model).toBe('newer');+ expect(acceptedForks.length - before).toBeLessThanOrEqual(1);+ expect([...hostMap.keys()].some((key) => key.startsWith('local-fork:'))).toBe(false);+ expect(await readFile(rolloutPath, 'utf8')).toBe(history);+ expect(siblingHost.getConnectionId()).toBe(connection);+ await send(sibling);+ return;+ }+ expect(await switching).toEqual({ status: 'applied', persistedRoute: true });+ const replacement = (await storage.get('source'))!.sdkSessionId!;+ // Review's dedicated host may exit at close, so no fork is needed then.+ expect(acceptedForks.length - before).toBe(reviewMode ? 0 : 1);+ if (!reviewMode) expect(replacement).not.toBe(original);+ expect(await readFile(rolloutPath, 'utf8')).toBe(history);+ expect([...hostMap.keys()].some((key) => key.startsWith('local-fork:'))).toBe(false);+ const resumeOptions = { id: 'source', agentKind: 'codex' as const, providerId, model: target.model, workingDir, resumeSessionId: replacement, ...(reviewMode ? { reviewMode: true as const } : {}) };+ if (window === 'transfer-resume-failure') {+ rejectResumeRequest = true;+ await expect(maker.createSession(resumeOptions)).rejects.toThrow(/provider/i);+ expect((await storage.get('source'))!.sdkSessionId).toBe(replacement);+ expect(acceptedForks.length - before).toBe(1);+ }+ source = await maker.createSession(resumeOptions);+ expect(source.codexHostKey?.includes('external-auth')).toBe(providerId === 'cprov-fixture');+ await send(source);+ expect(hostMap.get('local')).toBe(siblingHost);+ expect(siblingHost.getConnectionId()).toBe(connection);+ await send(sibling);+ }+ } finally {+ await maker.shutdown();+ clearSessionProvider('source');+ sqlite.close();+ }+ return;+ }+ if (lateWindow) {+ // Start a shared sibling first; the target will initially select that host+ // from an unknown route, then the real Desktop transaction installs API auth.+ setCustomProviders([]);+ const sibling = await agent.startSession({ sessionId: 'sibling', model: 'fixture-model', providerId: 'cprov-fixture', workingDir });+ let resumeThreadId: string | undefined;+ if (window === 'resume') {+ const source = await agent.startSession({ sessionId: 'source', model: 'fixture-model', providerId: 'cprov-fixture', workingDir });+ const done = (async () => { for await (const event of source.events()) { if (event.type === 'error') throw new Error(JSON.stringify(event)); if (event.type === 'done') return; } })();+ await source.send({ type: 'user', content: 'persist fixture' }, { throwOnStartFailure: true });+ await done;+ await source.close();+ // 0.153 retains source's writer after unsubscribe. Resume preparation+ // starts with a released native child; the unrelated sibling stays live.+ resumeThreadId = (await agent.forkSdkSession({ sourceSdkSessionId: source.id, upToMessageId: undefined, model: 'fixture-model', providerId: 'cprov-fixture', stripEncryptedReasoning: false })).newSdkSessionId;+ }+ const hostMap = (agent as unknown as { hosts: Map<string, AppServerHost> }).hosts;+ const siblingHost = hostMap.get('local')!;+ const siblingConnection = siblingHost.getConnectionId();+ const accepted: Array<{ host: AppServerHost; method: string }> = [];+ const request = AppServerHost.prototype.request;+ spies.push(vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {+ const result = request.call(this, method, params, { ...opts, beforeDispatch: () => {+ opts?.beforeDispatch?.();+ if (['thread/start', 'thread/resume'].includes(method)) accepted.push({ host: this, method });+ } });+ const pauseMethod = ['skills', 'restricted'].includes(window) ? 'skills/list'+ : ['config', 'bot', 'local-skill'].includes(window) ? 'config/read' : undefined;+ return pauseMethod === method ? result.then(async (response) => { await latePreparation?.(); return response; }) : result;+ }));+ let entered!: () => void;+ let release!: () => void;+ const waiting = new Promise<void>((resolve) => { entered = resolve; });+ const gate = new Promise<void>((resolve) => { release = resolve; });+ let once = false;+ latePreparation = async () => { if (!once) { once = true; entered(); await gate; } };+ const initialize = AppServerHost.prototype.ensureStartedWithTimeout;+ if (window === 'initialize') spies.push(vi.spyOn(AppServerHost.prototype, 'ensureStartedWithTimeout').mockImplementation(async function (this: AppServerHost, ...args) {+ const result = await initialize.apply(this, args);+ await latePreparation?.();+ return result;+ }));+ const rows = new Map<string, SessionMeta>();+ const storage: SessionStorage = {+ create: async (meta) => { const row = { ...meta, createdAt: 0, updatedAt: 0 }; rows.set(row.id, row); return row; },+ get: async (id) => rows.get(id) ?? null,+ list: async () => [...rows.values()],+ update: async (id, patch) => { const row = { ...rows.get(id)!, ...patch }; rows.set(id, row); return row; },+ compareAndClearSdkSessionId: async () => false,+ delete: async (id) => { rows.delete(id); },+ };+ let startupGuard = false;+ const failed = vi.fn();+ const maker = new Maker({ agents: { codex: agent }, storage, logger, lifecycleHooks: {+ onBeforeStart: async () => { startupGuard = true; },+ onStartSucceeded: async () => { startupGuard = false; }, onStartFailed: failed,+ } });+ const target = maker.createSession({ id: 'late-target', agentKind: 'codex', providerId: 'cprov-fixture', model: 'fixture-model', workingDir,+ ...(window === 'bot' ? { botRuntimeProfile: { botId: 'fixture', profileVersion: 1, skillPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] }, toolsetPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] }, mcpPolicy: { mode: 'allowlist' as const, configured: [], catalog: [] } } } : {}),+ ...(reviewMode ? { reviewMode: true as const } : {}), ...(resumeThreadId ? { resumeSessionId: resumeThreadId } : {}),+ });+ try {+ await waiting;+ const finish = beginMutation();+ setCustomProviders([buildUserProvider({ id: 'cprov-fixture', name: 'Fixture', runtimes: { codex: { baseUrl: `${endpoint}/provider`, wireProtocol: 'openai-responses', models: [{ id: 'fixture-model', name: 'Fixture' }] } } })]);+ release();+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(accepted).toEqual([]);+ finish.commit(); finish();+ const handle = await target;+ expect(handle.codexHostKey).toContain('external-auth');+ expect(startupGuard).toBe(false);+ expect(failed).not.toHaveBeenCalled();+ expect(accepted).toHaveLength(1);+ expect(accepted[0].host).not.toBe(siblingHost);+ if (reviewMode) expect(hostMap.has('local-review:late-target')).toBe(false);+ expect(spawnConfigs.at(-1)).toBe('isolated');+ // No forced retirement or cleanup of the live sibling on the shared host.+ expect(hostMap.get('local')).toBe(siblingHost);+ expect(siblingHost.getConnectionId()).toBe(siblingConnection);+ await maker.closeSession('late-target');+ await sibling.close();+ } finally { release(); }+ return;+ }+ const finish = beginMutation();+ let guard: Awaited<ReturnType<typeof agent.beginLocalHostCredentialChange>> | undefined;+ if (window === 'C') { guard = await agent.beginLocalHostCredentialChange(); await guard.finalize(); }+ let settled = false;+ const pending = agent.startSession({ sessionId: `fixture-${window}`, ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-fixture', model: 'fixture-model', workingDir })+ .then((handle) => { settled = true; return handle; });+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(settled).toBe(false);+ expect(spawnConfigs).toEqual([]);+ if (window === 'A') { guard = await agent.beginLocalHostCredentialChange(); await guard.finalize(); }+ finish.commit(); finish();+ const handle = await pending;+ expect(handle.codexHostKey).toBe(reviewMode ? `local-review:fixture-${window}:external-auth` : 'local:external-auth');+ expect(spawnConfigs.every((policy) => policy === 'isolated')).toBe(true);+ const switchFinish = beginMutation();+ let switchSettled = false;+ const switching = Promise.resolve(handle.requiresModelSwitchRebuild!('fixture-model', { providerId: 'cprov-fixture' }))+ .then((result) => { switchSettled = true; return result; });+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(switchSettled).toBe(false);+ switchFinish();+ expect(await switching).toBe(false);+ const cloudCallsBeforeCustom: string[] = [];+ const events = (async () => {+ for await (const event of handle.events()) {+ if (event.type === 'error') throw new Error(JSON.stringify(event));+ if (event.type === 'done') return;+ }+ })();+ await handle.send({ type: 'user', content: 'return fixture complete' }, { throwOnStartFailure: true });+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length, { timeout: 10_000 }).toBe(1);+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(cloudCallsBeforeCustom);+ if (authFixture) expect(await readFile(authPath, 'utf8')).toBe(authFixture);+ await events;+ await handle.close();+ if (!reviewMode && window === 'B') {+ const rolloutPath = await (agent as unknown as { findRolloutPath(id: string): Promise<string> }).findRolloutPath(handle.id);+ const originalRollout = await readFile(rolloutPath, 'utf8');+ await expect(agent.forkSdkSession({ sourceSdkSessionId: handle.id, upToMessageId: undefined, providerId: 'cprov-fixture', model: 'fixture-model', stripEncryptedReasoning: true })).rejects.toMatchObject({ name: 'CodexHistoryRecoveryRequiredError' });+ expect(await readFile(rolloutPath, 'utf8')).toBe(originalRollout);+ const acceptedForks: AppServerHost[] = [];+ const forkRequest = AppServerHost.prototype.request;+ spies.push(vi.spyOn(AppServerHost.prototype, 'request').mockImplementation(function (this: AppServerHost, method, params, opts) {+ return forkRequest.call(this, method, params, { ...opts, beforeDispatch: () => {+ opts?.beforeDispatch?.();+ if (method === 'thread/fork') acceptedForks.push(this);+ } });+ }));+ for (const delay of ['none', 'after-start']) {+ const acceptedBefore = acceptedForks.length;+ const delayPreparation = delay !== 'none';+ let releasePreparation: () => void = () => {};+ if (delayPreparation) preparationGate = new Promise<void>((resolve) => { releasePreparation = resolve; });+ preparationEntered.mockClear();+ let finishFork = delayPreparation ? undefined : beginMutation();+ let forkSettled = false;+ const forking = agent.forkSdkSession({ sourceSdkSessionId: handle.id, upToMessageId: undefined, providerId: 'cprov-fixture', model: 'fixture-model', stripEncryptedReasoning: false })+ .then((result) => { forkSettled = true; return result; });+ try {+ if (delayPreparation) await expect.poll(() => preparationEntered.mock.calls.length).toBeGreaterThanOrEqual(1);+ const pausedForkHost = delayPreparation+ ? [...(agent as unknown as { hosts: Map<string, AppServerHost> }).hosts].find(([key]) => key.startsWith('local-fork:'))?.[1]+ : undefined;+ if (delayPreparation) expect(pausedForkHost).toBeDefined();+ if (delayPreparation) finishFork = beginMutation();+ releasePreparation();+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(forkSettled).toBe(false);+ finishFork?.();+ const fork = await forking;+ expect(fork.newSdkSessionId).not.toBe(handle.id);+ expect(acceptedForks).toHaveLength(acceptedBefore + 1);+ if (delayPreparation) expect(acceptedForks.at(-1)).not.toBe(pausedForkHost);+ expect(await readFile(rolloutPath, 'utf8')).toBe(originalRollout);+ expect(spawnConfigs.every((policy) => policy === 'isolated')).toBe(true);+ } finally { releasePreparation(); finishFork?.(); }+ }+ }+ if (!reviewMode && window === 'B') {+ const finishCancel = beginMutation();+ const cancelled = agent.startSession({ sessionId: 'cancelled-route', providerId: 'cprov-fixture', model: 'fixture-model', workingDir });+ const rejection = expect(cancelled).rejects.toThrow(/cancelled/);+ await new Promise((resolve) => setTimeout(resolve, 20));+ await agent.dispose();+ await rejection;+ finishCancel();+ }+ } finally {+ releaseOAuth();+ await coldStart;+ releaseResponse();+ for (const spy of spies) spy.mockRestore();+ for (const release of releases) release();+ setCustomProviders([]);+ await agent.dispose();+ await new Promise<void>((resolve) => server.close(() => resolve()));+ await rm(root, { recursive: true, force: true });+ }+ }, 45_000);+});diff --git a/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.ts b/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.tsnew file mode 100644index 0000000000..2516bba47a--- /dev/null+++ b/apps/desktop/src/main/maker-host/__tests__/codexSmartNamespace.integration.test.ts@@ -0,0 +1,167 @@+import fs from 'node:fs';+import os from 'node:os';+import path from 'node:path';+import { createServer } from 'node:http';+import type { AddressInfo } from 'node:net';+import { describe, expect, it, vi } from 'vitest';+import { buildUserProvider, type ProviderView } from '@cindy/model-providers';+import { CodexAgent } from '../../../../../../packages/maker-core/src/agents/codex/index.js';+import { AppServerHost } from '../../../../../../packages/maker-core/src/agents/codex/app-server/host.js';+import type { AgentSessionHandle } from '../../../../../../packages/maker-core/src/agents/base-agent.js';+import type { Logger } from '../../../../../../packages/maker-core/src/interfaces/logger.js';++const fixture = vi.hoisted(() => ({ root: '' }));+vi.mock('electron', () => ({ app: {+ isPackaged: true, getPath: () => fixture.root, getAppPath: () => fixture.root,+}, safeStorage: { isEncryptionAvailable: () => false } }));+vi.mock('../../appCapabilities.js', () => ({ getAppCapabilities: () => ({ canUseCindyGateway: true }) }));++const binary = process.env.CINDY_TEST_CODEX_BINARY;+const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };++// Explicit runtime opt-in; no installed binary discovery or real account access.+describe.skipIf(!binary)('native smart child inherited Provider namespace', () => {+ it('completes a selected child turn, then continues the parent with its original key', async () => {+ fixture.root = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-smart-native-'));+ const home = path.join(fixture.root, 'home');+ const codex = path.join(fixture.root, 'codex');+ const work = path.join(fixture.root, 'work');+ for (const dir of [home, codex, work]) fs.mkdirSync(dir);+ const homeSpy = vi.spyOn(os, 'homedir').mockReturnValue(home);+ const wires: Array<{ path: string; model: string; thread: string; parent: string; key: string; effort: unknown }> = [];+ const registrations: Array<{ parentThreadId: string; childThreadId: string }> = [];+ const completions = new Map<string, string>();+ const issued = new Set<string>();+ const failures: unknown[] = [];+ let rootThread = '';+ let agent: CodexAgent | undefined;+ let handle: AgentSessionHandle | undefined;+ const hostPrototype = AppServerHost.prototype as unknown as { routeNotification(method: string, params: unknown): void };+ const notify = hostPrototype.routeNotification;+ const notifications = vi.spyOn(hostPrototype, 'routeNotification').mockImplementation(function (this: AppServerHost, method, params) {+ const event = params as { threadId?: string; turn?: { status?: string } };+ if (method === 'turn/completed' && event.threadId) completions.set(event.threadId, event.turn?.status ?? 'unknown');+ return notify.call(this, method, params);+ });+ const server = createServer(async (req, res) => {+ try {+ const chunks: Buffer[] = [];+ for await (const chunk of req) chunks.push(Buffer.from(chunk));+ if (!req.url?.endsWith('/responses')) { res.writeHead(404).end(); return; }+ const body = JSON.parse(Buffer.concat(chunks).toString());+ const thread = String(req.headers['thread-id'] ?? '');+ const parent = String(req.headers['x-codex-parent-thread-id'] ?? '');+ const child = parent !== '';+ wires.push({ path: req.url, model: body.model, thread, parent,+ key: String(req.headers.authorization), effort: body.reasoning?.effort });+ expect(req.headers.authorization).toBe(`Bearer synthetic-${child ? 'cprov-child' : 'cprov-parent'}`);+ expect(req.headers['chatgpt-account-id']).toBeUndefined();+ expect(body.model).toBe(child ? 'gpt-6-astra' : 'api-parent');+ if (child) expect(req.headers['x-openai-subagent']).toBe('collab_spawn');+ // Use the actual tool schema emitted by this exact native runtime.+ const namespace = body.tools?.find((tool: { type: string; name: string }) => tool.type === 'namespace' && tool.name === 'multi_agent_v1');+ const spawn = namespace?.tools?.find((tool: { name: string }) => tool.name === 'spawn_agent');+ let item: unknown;+ if (!issued.has(thread) && thread === rootThread) {+ expect(spawn).toBeTruthy();+ if (thread === rootThread) expect(spawn.parameters.properties.model).toBeTruthy();+ issued.add(thread);+ item = { id: `fc-${wires.length}`, type: 'function_call', call_id: `call-${wires.length}`,+ namespace: namespace.name, name: spawn.name, arguments: JSON.stringify({+ message: 'Synthetic child task. Nested delegation is authorized.', fork_context: false,+ ...(spawn.parameters.properties.model ? { model: 'gpt-6-astra' } : {}),+ }) };+ } else {+ item = { id: `m-${wires.length}`, type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'synthetic complete' }] };+ }+ const id = `r-${wires.length}`;+ const events = [{ type: 'response.created', response: { id } },+ { type: 'response.output_item.done', item },+ { type: 'response.completed', response: { id, status: 'completed', output: [item], usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } }];+ res.writeHead(200, { 'content-type': 'text/event-stream' }).end(events.map(event => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));+ } catch (error) { failures.push(error); res.writeHead(500).end(); }+ });+ await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;+ const catalog = await import('../active-catalog.js');+ const routing = await import('../provider-route.js');+ const proxy = await import('../codex-proxy-host.js');+ const sessions = await import('../session-provider-store.js');+ const { deriveCodexCustomProviderRoutes, buildCodexCustomProviderArgs } = await import('../codex-custom-provider-route.js');+ const { selectCodexSmartSubagentCandidates } = await import('../codex-smart-subagent-routing.js');+ try {+ const providers = ['parent', 'child'].map(id => buildUserProvider({ id: `cprov-${id}`, name: id, runtimes: { codex: {+ baseUrl: `${endpoint}/${id}`, wireProtocol: 'openai-responses', supportsImageGeneration: id === 'parent',+ models: [{ id: id === 'parent' ? 'api-parent' : 'gpt-6-astra', name: id, contextWindow: 200_000, reasoningEfforts: ['high'] }],+ } } }));+ catalog.setCustomProviders(providers);+ routing.setCustomProviderKeyReader(id => `synthetic-${id}`);+ const candidates = selectCodexSmartSubagentCandidates(providers.map(provider => ({ ...provider, connected: true, agents: ['codex'] })) as ProviderView[],+ { allowChatGptOAuth: true, oauthProviderId: 'cprov-parent' });+ expect(candidates.some(candidate => candidate.providerId === 'cprov-child' && candidate.model.id === 'gpt-6-astra')).toBe(true);+ expect(candidates.some(candidate => candidate.providerId === 'openai')).toBe(false);+ const routes = deriveCodexCustomProviderRoutes(catalog.getActiveCatalog());+ const parentRoute = routes.find(route => route.providerId === 'cprov-parent')!;+ await proxy.ensureCodexCustomContextProxyReady('native-smart', 'provider-oauth', routes);+ const proxyEndpoint = proxy.getCodexCustomContextProxyEndpoint('native-smart');+ fs.writeFileSync(path.join(codex, 'config.toml'), [+ 'model="api-parent"', `model_provider=${JSON.stringify(parentRoute.modelProviderId)}`,+ 'check_for_update_on_startup=false', `chatgpt_base_url=${JSON.stringify(endpoint)}`,+ '[analytics]', 'enabled=false', '[features]', 'plugins=false', 'remote_plugin=false',+ '[agents]', 'max_depth=2', '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',+ ].join('\n'));+ const env = { HOME: home, USERPROFILE: home, CODEX_HOME: codex, TMPDIR: fixture.root,+ OPENAI_API_KEY: '', CODEX_API_KEY: '', XDT_CODEX_API_KEY: 'synthetic-placeholder',+ HTTP_PROXY: 'http://127.0.0.1:9', HTTPS_PROXY: 'http://127.0.0.1:9', ALL_PROXY: 'http://127.0.0.1:9', NO_PROXY: '127.0.0.1,localhost' };+ sessions.setSessionProvider('native-smart-task', 'cprov-parent');+ agent = new CodexAgent({ binaryPath: binary!, logger,+ auth: { getState: async () => ({ authenticated: true }), triggerLogin: async () => ({ authenticated: true }),+ logout: async () => {}, getAuthEnv: async () => env },+ runtimeConfig: { behaviorFlags: env }, resolveCodexLocalAuthPolicy: routing.captureCodexLocalAuthPolicy,+ prepareCodexExtraSpawnConfig: async () => ({+ ...buildCodexCustomProviderArgs(proxyEndpoint, 'provider-oauth', routes), codexProxyActive: true,+ extraArgs: [...buildCodexCustomProviderArgs(proxyEndpoint, 'provider-oauth', routes).extraArgs,+ '-c', 'features.multi_agent_v2.expose_spawn_agent_model_overrides=true'],+ smartSubagentRoutes: candidates.map(candidate => ({ providerId: candidate.providerId, catalogModel: candidate.model.id, reasoningEffort: 'high' })),+ }),+ registerCodexSystemPromptForThread: ({ sessionId, threadId, text, ...options }) => proxy.registerComposed(sessionId, threadId, text, options),+ registerCodexChildThreadForParent: ({ parentThreadId, childThreadId }) => {+ registrations.push({ parentThreadId, childThreadId }); proxy.registerChildThread(parentThreadId, childThreadId);+ },+ getCodexSubagentIdentity: ({ childThreadId }) => proxy.getObservedCodexSubagentIdentity(childThreadId),+ });+ handle = await agent.startSession({ sessionId: 'native-smart-task', providerId: 'cprov-parent', model: 'api-parent', workingDir: work });+ rootThread = handle.id;+ const send = async () => {+ const done = (async () => { for await (const event of handle!.events()) {+ if (event.type === 'error') throw new Error(JSON.stringify(event));+ if (event.type === 'done') return;+ } })();+ await handle!.send({ type: 'user', content: 'synthetic delegation and completion' }, { throwOnStartFailure: true });+ await done;+ };+ await send();+ await vi.waitFor(() => {+ expect(failures).toEqual([]);+ expect(registrations).toHaveLength(1);+ for (const { childThreadId } of registrations) expect(completions.get(childThreadId)).toBe('completed');+ }, { timeout: 20_000 });+ expect(registrations[0]?.parentThreadId).toBe(rootThread);+ expect(wires.filter(wire => wire.parent)).toHaveLength(1);+ expect(wires.filter(wire => wire.parent).every(wire => wire.path === '/child/responses' && wire.model === 'gpt-6-astra' && wire.effort === 'high')).toBe(true);+ const before = wires.length;+ await send();+ expect(wires.slice(before)).toHaveLength(1);+ expect(wires.at(-1)).toMatchObject({ thread: rootThread, path: '/parent/responses', model: 'api-parent' });+ expect(failures).toEqual([]);+ } finally {+ await handle?.close(); await agent?.dispose();+ proxy.unregister('native-smart-task'); sessions.clearSessionProvider('native-smart-task');+ await proxy.releaseCodexCustomContextProxy('native-smart');+ routing.setCustomProviderKeyReader(() => null); catalog.setCustomProviders([]);+ notifications.mockRestore(); homeSpy.mockRestore();+ server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()));+ fs.rmSync(fixture.root, { recursive: true, force: true });+ }+ }, 60_000);+});diff --git a/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts b/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.tsindex ac1c165cbc..5bab8d816a 100644--- a/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts+++ b/apps/desktop/src/main/maker-host/__tests__/providerRoute.test.ts@@ -23,6 +23,8 @@ import {getProviderRouteCredentialRevision,getSessionRoutingDescriptor,resolveSessionRoute,+ resolveCodexLocalAuthPolicy,+ captureCodexLocalAuthPolicy,resolveSessionRouteDecision,resolveFrozenProviderRouteDecision,resolveImplicitLocalBridgeRoute,@@ -93,6 +95,62 @@ afterEach(() => {setCustomProviderHeaderReader(() => null);});+describe('Codex local auth policy', () => {+ it('uses the actual custom route even without image generation capabilities', async () => {+ setCustomProviders([buildUserProvider({+ id: 'plain-key', name: 'Plain API',+ runtimes: { codex: { baseUrl: 'https://example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: 'plain-model', name: 'Plain' }] } },+ })]);+ try {+ expect(await resolveCodexLocalAuthPolicy('plain-key', 'plain-model')).toBe('isolated');+ expect(await resolveCodexLocalAuthPolicy(undefined, 'plain-model')).toBe('isolated');+ expect(await resolveCodexLocalAuthPolicy('missing-provider', 'plain-model')).toBe('legacy-shared');+ } finally {+ setCustomProviders([]);+ }+ });++ it('waits through nested route mutations before selecting an API key policy', async () => {+ setCustomProviders([buildUserProvider({+ id: 'pending-key', name: 'Pending API',+ runtimes: { codex: { baseUrl: 'https://example.invalid/v1', wireProtocol: 'openai-responses', models: [{ id: 'pending-model', name: 'Pending' }] } },+ })]);+ const finish = beginProviderRouteMutation('pending-key');+ const nested = beginProviderRouteMutation('pending-key');+ let settled = false;+ const policy = resolveCodexLocalAuthPolicy('pending-key', 'pending-model').then((value) => { settled = true; return value; });+ await Promise.resolve();+ expect(settled).toBe(false);+ finish.commit();+ finish();+ await Promise.resolve();+ expect(settled).toBe(false);+ nested();+ await expect(policy).resolves.toBe('isolated');+ });++ it('invalidates a captured selection when a Desktop mutation starts, even without a core guard', async () => {+ const before = await captureCodexLocalAuthPolicy('pending-key', 'pending-model');+ expect(before.isCurrent()).toBe(true);+ const finish = beginProviderRouteMutation('pending-key');+ try {+ expect(before.isCurrent()).toBe(false);+ const abort = new AbortController();+ const pending = captureCodexLocalAuthPolicy('pending-key', 'pending-model', abort.signal);+ abort.abort(new Error('fixture cancelled'));+ await expect(pending).rejects.toThrow('fixture cancelled');+ } finally { finish(); }+ expect(before.isCurrent()).toBe(false);+ expect((await captureCodexLocalAuthPolicy('pending-key', 'pending-model')).isCurrent()).toBe(true);+ });++ it('isolates gateway routes while retaining official and third-party OAuth compatibility', async () => {+ expect(await resolveCodexLocalAuthPolicy('openai', 'gpt-5.4')).toBe('legacy-shared');+ expect(await resolveCodexLocalAuthPolicy('xd', 'gpt-5.4')).toBe('isolated');+ expect(await resolveCodexLocalAuthPolicy('xai', 'xai/grok-4.3')).toBe('legacy-shared');+ });+});+describe('Pi per-model protocol routing', () => {const provider = buildUserProvider({id: 'pi-overrides',diff --git a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.tsindex c953f2fa5e..f2e227ecb7 100644--- a/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts+++ b/apps/desktop/src/main/maker-host/anthropic-responses-bridge-host.ts@@ -40,7 +40,7 @@ import { getActiveCatalog } from './active-catalog.js';import { outboundFetch } from './outbound-fetch.js';import { getGrokAccessToken, peekGrokAccessToken } from './grok-oauth-login.js';import { invalidateXaiBridgeAuth } from './xai-auth-invalidation-host.js';-import { chatgptAccountIdFromIdToken, desktopCodexAuthAdapter } from './auth-adapters.js';+import { chatgptAccountIdFromTokens, desktopCodexAuthAdapter } from './auth-adapters.js';import { codexAccountHome, codexAccountState, invalidateCodexAccount, isOpenAiSubscriptionProviderId } from './codex-account-auth.js';import {bearerAccessTokenFromHeaders,@@ -113,12 +113,6 @@ function jwtExpSec(token: string | undefined): number | null {}}-/** tokens.account_id 优先;回落解 id_token(复用 auth-adapters 的 claim 解析,单点维护)。 */-function accountIdFrom(tokens: NonNullable<CodexAuthFile['tokens']>): string | null {- if (typeof tokens.account_id === 'string' && tokens.account_id.length > 0) return tokens.account_id;- return typeof tokens.id_token === 'string' ? chatgptAccountIdFromIdToken(tokens.id_token) : null;-}-function isExpired(accessToken: string | undefined): boolean {const exp = jwtExpSec(accessToken);if (exp == null) return false; // 解不出 exp → 不主动刷,靠上游 401 暴露@@ -276,7 +270,7 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ accconst refreshed = await refreshIfNeeded(authPath, current);throwIfOwnerBoundDispatchUnsafe(scopeAtStart);if (!codexAccountState(providerId).authenticated || !refreshed.tokens?.access_token) throw new Error('OpenAI account changed during authentication');- return { accessToken: refreshed.tokens.access_token, accountId: accountIdFrom(refreshed.tokens) };+ return { accessToken: refreshed.tokens.access_token, accountId: chatgptAccountIdFromTokens(refreshed.tokens) };}const now = Date.now();if (_authCache && now - _authCache.readAt < AUTH_CACHE_TTL_MS && !isExpired(_authCache.accessToken)) {@@ -303,7 +297,7 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ accobj = await refreshIfNeeded(authPath, obj);throwIfOwnerBoundDispatchUnsafe(scopeAtStart);const accessToken = obj.tokens?.access_token;- const accountId = obj.tokens ? accountIdFrom(obj.tokens) : null;+ const accountId = chatgptAccountIdFromTokens(obj.tokens);if (!accessToken) {_authCache = null;throw new Error('codex auth.json 缺 access_token');@@ -312,6 +306,27 @@ export async function getChatgptBridgeAuth(providerId = 'openai'): Promise<{ accreturn _authCache;}+/** A deferred child request must revalidate both credential and authorization at dispatch/retry. */+export async function getChatgptBridgeAuthForDispatch(providerId = 'openai'): Promise<{+ accessToken: string; accountId: string | null; canDispatch(): boolean;+}> {+ const ownerScope = activeOwnerScopeKey();+ for (let attempt = 0; attempt < 2; attempt++) {+ const auth = await getChatgptBridgeAuth(providerId);+ throwIfOwnerBoundDispatchUnsafe(ownerScope);+ const proof = desktopCodexAuthAdapter.captureOAuthDispatchProof(auth.accessToken, auth.accountId, providerId);+ if (proof) return {+ ...auth,+ canDispatch: () => ownerScope === activeOwnerScopeKey()+ && !isAppSessionBoundaryPending() && proof(),+ };+ // The existing cache can straddle native account replacement. Only a fresh,+ // proven credential may produce a new decision; the old decision stays invalid.+ clearChatgptBridgeCredentialCache();+ }+ throw new Error('OpenAI authorization changed while preparing the child request');+}+/** codex(ChatGPT 订阅)provider 配置:chatgpt/ 前缀 → codex 后端,注入订阅 OAuth + codex 专属头。 */function codexProviderConfig(providerId = 'openai'): BridgeProviderConfig {return {diff --git a/apps/desktop/src/main/maker-host/auth-adapters.ts b/apps/desktop/src/main/maker-host/auth-adapters.tsindex 78ecd90658..06df66b5b4 100644--- a/apps/desktop/src/main/maker-host/auth-adapters.ts+++ b/apps/desktop/src/main/maker-host/auth-adapters.ts@@ -105,6 +105,7 @@ import {bindNativeProviderAuth,claimDetectedNativeProviderAuth,isNativeProviderAuthBound,+ captureNativeProviderAuthorizationGeneration,isNativeProviderAuthRevoked,isNativeProviderAuthSelfAuthorized,isNativeProviderAuthSharedSystemCredential,@@ -266,6 +267,14 @@ export function chatgptAccountIdFromIdToken(idToken: string): string | null {return typeof sub === 'string' && sub.length > 0 ? sub : null;}+/** HTTP header identity only; workspace/recovery checks must keep the strict parser. */+export function chatgptAccountIdFromTokens(+ tokens: { account_id?: unknown; id_token?: unknown } | undefined,+): string | null {+ if (typeof tokens?.account_id === 'string' && tokens.account_id.length > 0) return tokens.account_id;+ return typeof tokens?.id_token === 'string' ? chatgptAccountIdFromIdToken(tokens.id_token) : null;+}+/*** Codex 一次性轻任务(起会话标题 oneShot)直连 ChatGPT 后端所需的凭证。* 读 xdt-maker 自管 codex-home 的 auth.json:`tokens.access_token` 作 Bearer、`account_id`@@ -1710,6 +1719,39 @@ export class DesktopCodexAuthAdapter implements AuthAdapter {return fingerprint ? JSON.stringify(fingerprint) : null;}+ /** Bind a host-owned request to the same credential and durable authorization as native Codex. */+ captureOAuthDispatchProof(accessToken: string, accountId: string | null, providerId = 'openai'): (() => boolean) | null {+ const independent = providerId !== 'openai';+ const authenticated = () => independent+ ? codexAccountState(providerId).authenticated : this.hasCodexOAuthLoginReadOnly();+ if (!authenticated()) return null;+ const home = independent ? codexAccountHome(providerId) : this.codexHome;+ const authPath = path.join(home, 'auth.json');+ const credential = () => {+ const value = currentCodexCredentialGeneration(authPath);+ return value ? JSON.stringify(value) : null;+ };+ // Independent accounts authorize against their existing account record;+ // inherited OpenAI uses the native provider authorization record.+ const authorization = () => independent+ ? JSON.stringify(currentCodexCredentialGeneration(path.join(home, 'account.json')))+ : captureNativeProviderAuthorizationGeneration('openai');+ const credentialGeneration = credential();+ const authorizationGeneration = authorization();+ if (!credentialGeneration || !authorizationGeneration || authorizationGeneration === 'null') return null;+ try {+ const raw = fs.readFileSync(authPath, 'utf8');+ const auth = JSON.parse(raw) as { tokens?: { access_token?: unknown; account_id?: unknown; id_token?: unknown } };+ if (auth.tokens?.access_token !== accessToken || chatgptAccountIdFromTokens(auth.tokens) !== accountId) return null;+ } catch {+ return null;+ }+ const isCurrent = () => authenticated()+ && credential() === credentialGeneration+ && authorization() === authorizationGeneration;+ return isCurrent() ? isCurrent : null;+ }+/** Bracket one account-level RPC with compare-and-commit recovery confirmation. */async verifyRecoveryWithAccountRpc<T>(read: () => Promise<T>): Promise<T> {const proof = this.captureRecoveryVerificationProof();diff --git a/apps/desktop/src/main/maker-host/codex-credential-switch.ts b/apps/desktop/src/main/maker-host/codex-credential-switch.tsindex a4511839ff..28ab8bf81d 100644--- a/apps/desktop/src/main/maker-host/codex-credential-switch.ts+++ b/apps/desktop/src/main/maker-host/codex-credential-switch.ts@@ -71,6 +71,7 @@ function credentialFamilyFromAuthInjection(}interface LocalAgentSession {+ codexHostKey?: string;id: string;agentKind: AgentKind;remoteHostId?: string | null;@@ -83,6 +84,8 @@ interface LocalCredentialModeSwitchMaker {}export interface PrepareLocalCodexCredentialModeSwitchInput {+ /** Restrict arbitration to the host being replaced, preserving sibling hosts. */+ hostKey?: string;maker: LocalCredentialModeSwitchMaker;isSessionInTurn?: (sessionId: string) => boolean;signal?: AbortSignal;@@ -447,7 +450,10 @@ export async function prepareLocalCodexCredentialModeSwitch(input: PrepareLocalCodexCredentialModeSwitchInput,): Promise<PrepareLocalCodexCredentialModeSwitchResult> {throwIfCredentialSwitchAborted(input.signal);- const localCodexSessions = input.maker.listActiveSessions().filter(isLocalCodexSession);+ const localCodexSessions = input.maker.listActiveSessions().filter((session) =>+ isLocalCodexSession(session) &&+ (input.hostKey === undefined || (session.codexHostKey ?? 'local') === input.hostKey),+ );const busySessions = localCodexSessions.filter((session) =>isSessionBusy(session, input.isSessionInTurn),);diff --git a/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts b/apps/desktop/src/main/maker-host/codex-custom-provider-route.tsindex 9f66d2ccb4..c24c41fc40 100644--- a/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts+++ b/apps/desktop/src/main/maker-host/codex-custom-provider-route.ts@@ -55,6 +55,21 @@ export interface CodexCustomProviderRoute {/** Routes actually frozen into the currently running local Codex Host. */let appliedCustomProviderRoutes: readonly CodexCustomProviderRoute[] = [];+const scopedAppliedCustomProviderRoutes = new Map<string, readonly CodexCustomProviderRoute[]>();++/** Publish capability snapshots for independently owned Hosts without changing proxy dispatch. */+export function registerCodexScopedCustomProviderRoutes(+ scopeKey: string,+ routes: readonly CodexCustomProviderRoute[],+): () => void {+ const snapshot = [...routes];+ scopedAppliedCustomProviderRoutes.set(scopeKey, snapshot);+ return () => {+ if (scopedAppliedCustomProviderRoutes.get(scopeKey) === snapshot) {+ scopedAppliedCustomProviderRoutes.delete(scopeKey);+ }+ };+}export function setCodexAppliedCustomProviderRoutes(routes: readonly CodexCustomProviderRoute[],@@ -73,7 +88,7 @@ export function hasCodexAppliedCustomProviderCapability(capability: keyof CodexCustomProviderCapabilities,): boolean {const storedProviderId = storedCustomProviderId(providerId);- return appliedCustomProviderRoutes.some(+ return [...appliedCustomProviderRoutes, ...Array.from(scopedAppliedCustomProviderRoutes.values()).flat()].some((route) =>storedCustomProviderId(route.providerId) === storedProviderId &&route.capabilities[capability] === true,@@ -269,12 +284,13 @@ export function crossesCodexAppliedCustomProviderIdentity(}const actual = input.currentThreadModelProviderId?.trim() || null;+ const appliedRoutes = [...appliedCustomProviderRoutes, ...Array.from(scopedAppliedCustomProviderRoutes.values()).flat()];const target = resolveCodexCustomProviderModelProviderId(- appliedCustomProviderRoutes,+ appliedRoutes,input.targetProviderId?.trim() || null,input.targetModel?.trim() || null,);- const actualIsAppliedCustomProviderIdentity = appliedCustomProviderRoutes.some(+ const actualIsAppliedCustomProviderIdentity = appliedRoutes.some((route) => route.modelProviderId === actual,);const actualIsRetiredPrototypeIdentity =diff --git a/apps/desktop/src/main/maker-host/codex-proxy-host.ts b/apps/desktop/src/main/maker-host/codex-proxy-host.tsindex 9fa4bbb9ff..b5cfbcbb34 100644--- a/apps/desktop/src/main/maker-host/codex-proxy-host.ts+++ b/apps/desktop/src/main/maker-host/codex-proxy-host.ts@@ -104,6 +104,8 @@ import {buildRouteDecision,inferProviderIdForModel,isHostInjectedAuthSession,+ getProviderRouteCredentialRevision,+ isProviderRouteMutationInProgress,isUserProviderSession,getUserProviderIdForSession,readProviderOAuthToken,@@ -163,6 +165,7 @@ const sessionToThreads = new Map<string, Set<string>>();const threadToSession = new Map<string, string>();const subagentRouteByParentThread = new Map<string, CodexSubagentRouteSnapshot>();const subagentRouteByThread = new Map<string, CodexSubagentRouteSnapshot>();+const subagentCredentialRevisions = new WeakMap<CodexSubagentRouteSnapshot, number>();const smartSubagentRoutesByParentThread = new Map<string,ReadonlyMap<string, CodexSubagentRouteSnapshot>@@ -365,6 +368,18 @@ export function getCodexProxyAuthInjection(): CodexProxyAuthInjection {// gateway api key reader —— 由 host 注入(readClaudeApiKey), 避免 codex-proxy-host 直接 import// auth-adapters(重模块, 会拖累单测加载 / 埋循环依赖)。proxy 给折扣 / api 流量换 gateway key 时调它。+type CodexSubagentOAuth = {+ accessToken: string;+ accountId: string | null;+ canDispatch(): boolean;+};+let readSubagentOAuth: ((providerId?: string) => Promise<CodexSubagentOAuth>) | undefined;++/** Only an explicitly routed official child may request host-owned OAuth credentials. */+export function setCodexSubagentOAuthReader(reader: (providerId?: string) => Promise<CodexSubagentOAuth>): void {+ readSubagentOAuth = reader;+}+let _readGatewayKey: () => string | null = () => null;export function setCodexProxyGatewayKeyReader(fn: () => string | null): void {_readGatewayKey = fn;@@ -2747,8 +2762,61 @@ function resolveCodexCustomProviderRoutingDecision(export function createModelRoutingTransform(frozenAuthInjection?: CodexProxyAuthInjection,frozenCustomProviderRoutes?: readonly CodexCustomProviderRoute[],+ sourceHostAlive: () => boolean = () => true,+ onCrossProviderChildAuthorized?: (ctx: RequestTransformCtx) => void,): RoutingTransform {return (body, ctx) => {+ const inheritedPath = parseCodexCustomProviderPath(ctx.url);+ if (inheritedPath.kind === 'route' && inheritedPath.pathKind === 'responses' && ctx.method === 'POST') {+ // Select the first smart child before validating the inherited parent URL.+ // Only registered collab lineage and this parent's frozen namespace can escape.+ const sessionId = sessionIdFromHeaders(ctx.headers);+ const parentRoute = customProviderRouteSnapshot(inheritedPath.routeId, frozenCustomProviderRoutes);+ if (isCollabSpawnRequest(ctx.headers) && sessionId && parentRoute+ && getSessionProvider(sessionId) === parentRoute.providerId) {+ const transformed = createForcedSubagentRequestTransform()(body, ctx) ?? body;+ const childRoute = subagentRouteFromHeaders(ctx.headers);+ if (childRoute) {+ const threadId = selectedThreadIdFromHeaders(ctx.headers);+ const current = () => sourceHostAlive()+ && threadToSession.get(threadId) === sessionId+ && getSessionProvider(sessionId) === parentRoute.providerId+ && subagentRouteByThread.get(threadId) === childRoute+ && !isProviderRouteMutationInProgress(parentRoute.providerId)+ && getProviderRouteCredentialRevision(parentRoute.providerId) === parentRoute.credentialRevision+ && !isProviderRouteMutationInProgress(childRoute.providerId)+ && getProviderRouteCredentialRevision(childRoute.providerId) === subagentCredentialRevisions.get(childRoute);+ if (!current()) return unresolvedCollabSpawnRouteDecision();+ const crossesProvider = childRoute.providerId !== parentRoute.providerId;+ const decision = crossesProvider+ ? createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes, sourceHostAlive)(+ body, { ...ctx, url: '/responses' },+ )+ : resolveCodexCustomProviderRoutingDecision(transformed, ctx, frozenCustomProviderRoutes);+ return Promise.resolve(decision).then((resolved) => {+ if (!resolved || !current()) return unresolvedCollabSpawnRouteDecision();+ const useProviderTransforms = crossesProvider && Boolean(onCrossProviderChildAuthorized);+ if (useProviderTransforms) onCrossProviderChildAuthorized!(ctx);+ return {+ ...(crossesProvider ? { pathOverride: '/responses' } : {}),+ ...resolved,+ dispatchGenerationValid: () => current() && (resolved.dispatchGenerationValid?.() ?? true),+ // Cross-provider HTTP requests use the ordinary outbound chain exactly+ // once. Never overwrite its wire model with the catalog identity afterward.+ // Same-provider frozen namespaces keep their dedicated identity transform.+ ...(useProviderTransforms ? {} : { transformRequestBody: async (raw, transformCtx) => {+ const parsed: unknown = JSON.parse(raw.toString('utf8'));+ const routed = createForcedSubagentRequestTransform()(parsed, ctx) ?? parsed;+ const bytes = Buffer.from(JSON.stringify(routed));+ return resolved.transformRequestBody+ ? resolved.transformRequestBody(bytes, transformCtx)+ : { body: bytes };+ } }),+ } satisfies RoutingDecision;+ });+ }+ }+ }const customProviderRoute = resolveCodexCustomProviderRoutingDecision(body,ctx,@@ -2817,7 +2885,26 @@ export function createModelRoutingTransform(selectedRouting?.authStrategy === 'oauth-passthrough'&& authInjection !== 'oauth-bearer') {- return unresolvedCollabSpawnRouteDecision();+ if (!readSubagentOAuth) {+ return unresolvedCollabSpawnRouteDecision();+ }+ // The parent stays ephemeral. Fetch subscription credentials only when+ // an explicit child route actually dispatches to the official backend.+ const credentialRevision = getProviderRouteCredentialRevision(subagentRoute.providerId);+ return readSubagentOAuth(subagentRoute.providerId).then((auth) => ({+ upstreamOverride: CODEX_OAUTH_UPSTREAM,+ headerOverride: {+ authorization: `Bearer ${auth.accessToken}`,+ ...(auth.accountId ? { 'chatgpt-account-id': auth.accountId } : {}),+ },+ ...(!auth.accountId ? { headerDelete: ['chatgpt-account-id'] } : {}),+ dispatchGenerationValid: () => sourceHostAlive()+ && !isProviderRouteMutationInProgress(subagentRoute.providerId)+ && getProviderRouteCredentialRevision(subagentRoute.providerId) === credentialRevision+ && threadToSession.get(threadId) === sessionId+ && subagentRouteByThread.get(threadId) === subagentRoute+ && auth.canDispatch(),+ })).catch(() => unresolvedCollabSpawnRouteDecision());}if (selectedUsesLocalBridge) {return resolveProviderRouteById(@@ -3138,13 +3225,20 @@ export function withCodexUpstreamRecording(};}-function createCodexProxyHandle(+async function createCodexProxyHandle(frozenAuthInjection?: CodexProxyAuthInjection,frozenCustomProviderRoutes?: readonly CodexCustomProviderRoute[],): Promise<ProxyHandle> {const execAdapter = createCodexResponsesCompatibilityAdapter();+ let alive = true;const pricing: XaiRequestPricing = new Map();- const route = createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes);+ // requestCtx and transformCtx share this request-owned headers object. A weak+ // identity marker cannot be forged by header values or leak into the next request;+ // it also needs no settlement bookkeeping for cancelled/local-handler requests.+ const crossProviderRequests = new WeakSet<Readonly<Record<string, string>>>();+ const route = createModelRoutingTransform(frozenAuthInjection, frozenCustomProviderRoutes, () => alive,+ ctx => { crossProviderRequests.add(ctx.headers); });+ const frozenReasoning = createCustomProviderReasoningTransform(frozenCustomProviderRoutes);const routeWithUsageEncoding: RoutingTransform = (body, ctx) => {const uncompressed = (decision: RoutingDecision | null): RoutingDecision | null => {if (decision?.localHandler || !isXaiUpstream(decision?.upstreamOverride ?? '')@@ -3156,7 +3250,7 @@ function createCodexProxyHandle(const decision = route(body, ctx);return decision instanceof Promise ? decision.then(uncompressed) : uncompressed(decision);};- return createAnthropicCompatProxy({+ const handle = await createAnthropicCompatProxy({// 默认上游 = gateway(含 /v1);普通模型 + oauth 由 routingTransform 覆盖到 ChatGPT。upstream: () => buildCodexGatewayBaseUrl(),transformRequest: createTransformRequestChain(frozenAuthInjection, execAdapter, pricing).map(@@ -3164,15 +3258,19 @@ function createCodexProxyHandle(// Namespaced Responses use a frozen Provider route. Preserve its native// fields and model. The dedicated transform below reconciles effort// against that same snapshot; ordinary session/catalog transforms stay out.- if (transform === normalizeResponsesToolItemIds) return transform;- const scoped: RequestTransform = (body, ctx) =>- isCodexCustomProviderNamespacePath(ctx.url) ? null : transform(body, ctx);+ const scoped: RequestTransform = (body, ctx) => {+ if (crossProviderRequests.has(ctx.headers)) {+ return transform(body, { ...ctx, url: '/responses' });+ }+ return isCodexCustomProviderNamespacePath(ctx.url) && transform !== normalizeResponsesToolItemIds+ ? null : transform(body, ctx);+ };// Keep adapter rejection and request-state cleanup on ordinary routes.scoped.errorMode = transform.errorMode;scoped.onRequestSettled = transform.onRequestSettled;return scoped;},- ).concat(createCustomProviderReasoningTransform(frozenCustomProviderRoutes)),+ ).concat((body, ctx) => crossProviderRequests.has(ctx.headers) ? null : frozenReasoning(body, ctx)),routeOpaqueRequestBody: (ctx) => isCodexCustomProviderNamespacePath(ctx.url),bypassRequestTransforms: (_body, ctx) => {const path = parseCodexCustomProviderPath(ctx.url);@@ -3279,6 +3377,12 @@ function createCodexProxyHandle(return CODEX_OAUTH_UPSTREAM;},});+ const dispose = handle.dispose.bind(handle);+ handle.dispose = async () => {+ alive = false;+ await dispose();+ };+ return handle;}/**@@ -3535,11 +3639,9 @@ export function registerComposed(const providerId = opts.subagentRoute?.providerId.trim();const catalogModel = opts.subagentRoute?.catalogModel.trim();if (providerId && catalogModel) {- subagentRouteByParentThread.set(threadId, {- providerId,- catalogModel,- reasoningEffort: opts.subagentRoute?.reasoningEffort ?? null,- });+ const route = { providerId, catalogModel, reasoningEffort: opts.subagentRoute?.reasoningEffort ?? null };+ subagentCredentialRevisions.set(route, getProviderRouteCredentialRevision(providerId));+ subagentRouteByParentThread.set(threadId, route);} else {subagentRouteByParentThread.delete(threadId);}@@ -3556,7 +3658,11 @@ export function registerComposed(: {}),});}- if (smartRoutes.size > 0) smartSubagentRoutesByParentThread.set(threadId, smartRoutes);+ for (const route of smartRoutes.values()) {+ subagentCredentialRevisions.set(route, getProviderRouteCredentialRevision(route.providerId));+ }+ // Legacy locked selection wins over optional smart candidates.+ if (!providerId && smartRoutes.size > 0) smartSubagentRoutesByParentThread.set(threadId, smartRoutes);else smartSubagentRoutesByParentThread.delete(threadId);log.debug('registered codex prompt for thread', {sessionId,@@ -3629,6 +3735,10 @@ export function registerChildThread(parentThreadId: string, childThreadId: strinreturn false;}+ // Notification and the first request can register the same child in either order.+ // Never replace its resolved selection with a parent's route on the second call.+ if (previousSessionId === sessionId && registry.get(childThreadId) !== undefined) return true;+const threads = sessionToThreads.get(sessionId) ?? new Set<string>();threads.add(childThreadId);sessionToThreads.set(sessionId, threads);@@ -3637,14 +3747,14 @@ export function registerChildThread(parentThreadId: string, childThreadId: strinconst inheritedSubagentRoute =subagentRouteByThread.get(parentThreadId)?? subagentRouteByParentThread.get(parentThreadId);- if (inheritedSubagentRoute) {+ const inheritedSmartRoutes =+ smartSubagentRoutesByThread.get(parentThreadId)+ ?? smartSubagentRoutesByParentThread.get(parentThreadId);+ if (inheritedSubagentRoute && !inheritedSmartRoutes) {subagentRouteByThread.set(childThreadId, inheritedSubagentRoute);} else {subagentRouteByThread.delete(childThreadId);}- const inheritedSmartRoutes =- smartSubagentRoutesByThread.get(parentThreadId)- ?? smartSubagentRoutesByParentThread.get(parentThreadId);if (inheritedSmartRoutes) smartSubagentRoutesByThread.set(childThreadId, inheritedSmartRoutes);else smartSubagentRoutesByThread.delete(childThreadId);log.debug('registered codex child thread route', {diff --git a/apps/desktop/src/main/maker-host/index.ts b/apps/desktop/src/main/maker-host/index.tsindex de009ef972..825e25fda2 100644--- a/apps/desktop/src/main/maker-host/index.ts+++ b/apps/desktop/src/main/maker-host/index.ts@@ -16,7 +16,7 @@ import { clearCodexAccountUsageSnapshot } from '../usageBroadcaster.js';import { createMediaDownloadContext } from '../cindy-media/mediaDownloadApproval.js';import { isCodexAccountProvider, codexAccountHome, setCodexAccountRetirement } from './codex-account-auth.js';import { CodexThreadLocations } from './codex-thread-locations.js';-import { getActiveAppSession } from '../appSessionState.js';+import { getActiveAppSession, activeOwnerScopeKey, isAppSessionBoundaryPending } from '../appSessionState.js';import { remoteCodexProvider } from './ssh-codex-models.js';import { getActiveAuthRealm } from '../authManager.js';import { getCustomProvider, updateCustomProviderIfUnchanged } from './custom-provider-store.js';@@ -107,8 +107,6 @@ import { remoteInvoke } from '../device-link/index.js';import { WorktreePool } from '../worktree/index.js';import { getReadyBinaryPath, getCachedBinaryStatus } from '../agent-binaries/index.js';import {- activeOwnerScopeKey,- isAppSessionBoundaryPending,ownerScopedUserDataPath,} from '../appSessionState.js';import { getIOSSimulatorPluginAccessDecision } from '../cindy-brain/index.js';@@ -135,7 +133,7 @@ import {import { createToolResultImageDescriptor } from '../vision-bridge/tool-result-image-descriptor.js';import * as blobStore from '../cindy-media/blobStore.js';import { buildPiVisionBridgeEnv } from '../vision-bridge/pi-vision-bridge-env.js';-import { resolveVisionBackendRoute, setVisionGatewayKeyReader } from './provider-route.js';+import { captureCodexLocalAuthPolicy, resolveVisionBackendRoute, setVisionGatewayKeyReader } from './provider-route.js';import { resolveSessionCcDebugFile, trackSessionCcDebugFile } from '../logger.js';import { resetProviderModelAutoRefreshCooldowns } from './provider-model-auto-refresh.js';import { getThinkingEnabledFromMemory } from './newMakerDefaultsCache.js';@@ -183,7 +181,7 @@ import {settleLocalPiPackageRuntimeSnapshot,type PiPackageRuntimeInvalidationSnapshot,} from './pi-package-runtime-invalidation.js';-import { clearChatgptBridgeCredentialCache } from './anthropic-responses-bridge-host.js';+import { clearChatgptBridgeCredentialCache, getChatgptBridgeAuthForDispatch } from './anthropic-responses-bridge-host.js';import {getDesktopSelectableCatalog,getDesktopProviderService,@@ -229,6 +227,7 @@ import {releaseCodexCustomContextProxy,setCodexProxyAuthInjection,setCodexProxyGatewayKeyReader,+ setCodexSubagentOAuthReader,registerComposed as registerCodexProxyComposed,registerChildThread as registerCodexProxyChildThread,setCodexAppliedCustomProviderRoutes,@@ -312,6 +311,7 @@ import {import {buildCodexCustomProviderArgs,deriveCodexCustomProviderRoutes,+ registerCodexScopedCustomProviderRoutes,toCodexCustomProviderHostRoutes,} from './codex-custom-provider-route.js';import {@@ -1458,7 +1458,7 @@ export function getMaker(): Maker {const providerViews: ProviderView[] =await getDesktopProviderService().listProviders({ allowSideEffects: false });const candidates = selectCodexSmartSubagentCandidates(providerViews, {- allowChatGptOAuth: ctx.credentialMode === 'oauth-bearer',+ allowChatGptOAuth: ctx.credentialMode !== undefined,oauthProviderId: ctx.providerId,});return codexSmartSubagentRoutingSignature(candidates, getActiveCatalogRevision())@@ -1543,6 +1543,7 @@ export function getMaker(): Maker {resolveDesktopModelContextProviderId(getDesktopSelectableCatalog(), 'codex', providerId, modelId), modelId),resolveCodexContextWindowInfo: (modelId, config, reportedUsableWindow, codexHome) =>readCodexContextWindowInfo({ codexHome: codexHome ?? getCodexHome(), binaryPath: codexPath, modelId, config, reportedUsableWindow }),+ resolveCodexLocalAuthPolicy: captureCodexLocalAuthPolicy,resolveCodexThreadContextWindow: (providerId, modelId) => {const source = resolveDesktopModelContextProviderId(getDesktopSelectableCatalog(), 'codex', providerId, modelId);const override = source ? readModelContextLimit('codex', source, modelId) : null;@@ -1596,6 +1597,7 @@ export function getMaker(): Maker {await prepareLocalCodexCredentialModeSwitch({maker,isSessionInTurn,+ hostKey: ctx.hostKey,fromMode: ctx.fromMode,fromModeEffective: ctx.fromModeEffective,toMode: ctx.toMode,@@ -1625,17 +1627,18 @@ export function getMaker(): Maker {const isControlPlane = ctx.hostPurpose === 'control-plane';const isReview = ctx.hostPurpose === 'review';const isCustomContext = ctx.hostPurpose === 'custom-context';- const customContextHostKey = isCustomContext- ? ctx.customContextHostKey?.trim() ?? ''+ const needsContextScope = isCustomContext || ctx.localAuthPolicy === 'isolated';+ const customContextHostKey = needsContextScope+ ? (ctx.hostScopeKey ?? ctx.customContextHostKey)?.trim() ?? '': '';- if (isCustomContext && !customContextHostKey) {+ if (needsContextScope && !customContextHostKey) {const error = new Error('custom-context Codex host is missing its runtime scope key');(error as { codexSpawnConfigFatal?: boolean }).codexSpawnConfigFatal = true;throw error;}const accountProxyKey = ctx.accountHostKey;+ const usesScopedProxy = needsContextScope || !!accountProxyKey;const scopedProxyKey = accountProxyKey || customContextHostKey;- const usesScopedProxy = isCustomContext || !!accountProxyKey;const usesIsolatedProxy = isControlPlane || isReview || usesScopedProxy;const effectiveCodexHome = ctx.codexHome ?? getCodexHome();let mcpExtraArgs: string[] = [];@@ -1707,6 +1710,8 @@ export function getMaker(): Maker {await broadcastCodexRuntimeRoute();}setCodexProxyGatewayKeyReader(readClaudeApiKey);+ setCodexSubagentOAuthReader(getChatgptBridgeAuthForDispatch);+const customContextProviderRoutes = usesScopedProxy? deriveCodexCustomProviderRoutes(getActiveCatalog()): [];@@ -1778,7 +1783,7 @@ export function getMaker(): Maker {smartSubagentConfig = prepareCodexSmartSubagentConfig({codexHome: effectiveCodexHome,providerViews,- allowChatGptOAuth: authInjection === 'oauth-bearer',+ allowChatGptOAuth: true,oauthProviderId: ctx.providerId,catalogRevision: getActiveCatalogRevision(),}) ?? undefined;@@ -1830,6 +1835,9 @@ export function getMaker(): Maker {storedSubagentModelSettings,smartSubagentConfig,);+ const releaseScopedCapabilities = usesScopedProxy+ ? registerCodexScopedCustomProviderRoutes(scopedProxyKey, codexCustomProviderRoutes)+ : undefined;return {// 默认不碰 Codex 原生 Sol/Terra 调配。用户开启智能调配后才为这个本地// app-server 冻结扩展目录与逐模型 Provider 路由。@@ -1873,8 +1881,10 @@ export function getMaker(): Maker {: {}),...(usesScopedProxy? {- onHostRetired: () =>- releaseCodexCustomContextProxy(scopedProxyKey),+ onHostRetired: async () => {+ releaseScopedCapabilities?.();+ await releaseCodexCustomContextProxy(scopedProxyKey);+ },}: {}),};@@ -2069,7 +2079,7 @@ export function getMaker(): Maker {resetProviderModelAutoRefreshCooldowns('openai');// auth 边界变了:「清单已在场」和「试过几次」都不再适用于下一个账号。resetCodexModelBackfillState();- await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth logout');+ await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth logout', { preserveExternalAuth: true });clearCodexProxyAuthInjection();await broadcastCodexRuntimeRoute();// 轮 27 HIGH-1:认证边界变更必须失效 PI MCP bridge —— 否则其 server@@ -2088,7 +2098,7 @@ export function getMaker(): Maker {// 必须在新 app-server 首次 model/list / Responses 请求之前清:bridge 的旧账号// accessToken/accountId 有 30s 内存缓存,晚清会让新 host 短暂带旧账号凭证请求。clearChatgptBridgeCredentialCache();- await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth login');+ await codexAgent.forceDisposeLocalHostForAuthChange('Codex desktop auth login', { preserveExternalAuth: true });await broadcastCodexRuntimeRoute();// 轮 27 HIGH-1:登录也是认证边界, 与登出对称失效 PI bridge。invalidatePiEnvironment();@@ -2128,6 +2138,7 @@ export function getMaker(): Maker {// 只是这条路径从没让那个校验生效过。退役即补齐对称性,不需要在写入侧再加一层闸门。await codexAgent.forceDisposeLocalHostForAuthChange(`Codex credential invalidated: ${reason}`,+ { preserveExternalAuth: true },);clearChatgptBridgeCredentialCache();await refreshDiscoveredCodexModels(false);@@ -3030,6 +3041,7 @@ export async function prepareCodexForCustomProviderHostChange(): Promise<void> {const guard = _codexAgent? await _codexAgent.beginLocalHostCredentialChange('Codex custom Provider route or credential changed',+ { allLocalHosts: true, forceRetire: true },): null;let prepared = false;diff --git a/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts b/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.tsindex 0c8dd94f7c..81f84a7e63 100644--- a/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts+++ b/apps/desktop/src/main/maker-host/nativeProviderAuthBinding.ts@@ -1,5 +1,5 @@import { app } from 'electron';-import { randomUUID } from 'node:crypto';+import { createHash, randomUUID } from 'node:crypto';import fs from 'node:fs';import { platform as hostPlatform } from 'node:os';import path from 'node:path';@@ -481,6 +481,21 @@ export function isNativeProviderAuthBound(provider: NativeProviderId): boolean {return bindings[provider] === owner;}+/** Identity of the existing durable authorization record; no separate credential epoch. */+export function captureNativeProviderAuthorizationGeneration(provider: NativeProviderId): string | null {+ if (!isNativeProviderAuthBound(provider)) return null;+ let fd: number | undefined;+ try {+ fd = fs.openSync(bindingPath(), 'r');+ const stat = fs.fstatSync(fd, { bigint: true });+ return `${stat.dev}:${stat.ino}:${stat.mtimeNs}:${createHash('sha256').update(fs.readFileSync(fd)).digest('hex')}`;+ } catch {+ return null;+ } finally {+ if (fd !== undefined) fs.closeSync(fd);+ }+}+/** Whether an explicit durable revocation currently suppresses this provider credential. */export function isNativeProviderAuthRevoked(provider: NativeProviderId): boolean {const read = readBindingsOrFail();diff --git a/apps/desktop/src/main/maker-host/provider-route.ts b/apps/desktop/src/main/maker-host/provider-route.tsindex 064b522fb0..aa13dd952f 100644--- a/apps/desktop/src/main/maker-host/provider-route.ts+++ b/apps/desktop/src/main/maker-host/provider-route.ts@@ -60,6 +60,7 @@ let customProviderHeaderReader: CustomProviderHeaderReader = () => null;const providerRouteMutationCounts = new Map<string, number>();const providerRouteCredentialRevisions = new Map<string, number>();let nextProviderRouteCredentialRevision = 1;+const providerRouteMutationWaiters = new Map<string, Set<() => void>>();export type ProviderRouteMutationRelease = (() => void) & {/** Publish the new non-sensitive route/capability/credential dispatch generation. */@@ -96,7 +97,12 @@ export function beginProviderRouteMutation(providerId: string): ProviderRouteMutif (finished) return;finished = true;const remaining = (providerRouteMutationCounts.get(providerId) ?? 1) - 1;- if (remaining <= 0) providerRouteMutationCounts.delete(providerId);+ if (remaining <= 0) {+ providerRouteMutationCounts.delete(providerId);+ const waiters = providerRouteMutationWaiters.get(providerId);+ providerRouteMutationWaiters.delete(providerId);+ for (const resolve of waiters ?? []) resolve();+ }else providerRouteMutationCounts.set(providerId, remaining);}) as ProviderRouteMutationRelease;finish.commit = () => {@@ -625,6 +631,58 @@ export function getProviderRoutingDescriptor(return routing;}+/** Choose process isolation from routing metadata without loading any credentials. */+export async function captureCodexLocalAuthPolicy(+ providerId: string | null | undefined,+ modelId: string,+ signal?: AbortSignal,+): Promise<{ policy: 'isolated' | 'legacy-shared'; isCurrent: () => boolean }> {+ // With an inferred source the transaction may temporarily remove the model+ // from the catalog. Wait before inference, rather than freezing an unknown route.+ while (true) {+ signal?.throwIfAborted();+ const pending = providerId+ ? [runtimeCustomProviderId(providerId)].filter(isProviderRouteMutationInProgress)+ : [...providerRouteMutationCounts.keys()];+ if (pending.length === 0) break;+ await Promise.all(pending.map((id) => new Promise<void>((resolve, reject) => {+ const waiters = providerRouteMutationWaiters.get(id) ?? new Set<() => void>();+ const done = () => {+ signal?.removeEventListener('abort', cancel);+ waiters.delete(done);+ if (waiters.size === 0) providerRouteMutationWaiters.delete(id);+ resolve();+ };+ const cancel = () => {+ signal?.removeEventListener('abort', cancel);+ waiters.delete(done);+ if (waiters.size === 0) providerRouteMutationWaiters.delete(id);+ reject(signal?.reason);+ };+ signal?.addEventListener('abort', cancel, { once: true });+ waiters.add(done);+ providerRouteMutationWaiters.set(id, waiters);+ })));+ }+ const source = providerId ?? inferProviderIdForModel(modelId, 'codex');+ const routing = getProviderRoutingDescriptor(source, 'codex', modelId);+ // Keep legacy reuse for third-party OAuth and unknown routes. This+ // is compatibility policy, not a claim that they need official Codex OAuth.+ const revision = nextProviderRouteCredentialRevision;+ return {+ policy: routing?.authStrategy === 'api-key-header' || routing?.authStrategy === 'gateway-key'+ ? 'isolated' : 'legacy-shared',+ isCurrent: () => revision === nextProviderRouteCredentialRevision,+ };+}++export async function resolveCodexLocalAuthPolicy(+ providerId: string | null | undefined,+ modelId: string,+): Promise<'isolated' | 'legacy-shared'> {+ return (await captureCodexLocalAuthPolicy(providerId, modelId)).policy;+}+export interface ResolvedSessionRoute {providerId: string;providerSource: ProviderSource;diff --git a/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.tsindex 85c81ad3eb..839a44cba3 100644--- a/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts+++ b/apps/desktop/src/main/maker-ipc/__tests__/codexProviderThreadRelink.test.ts@@ -1,9 +1,13 @@import { describe, expect, it, vi } from 'vitest';+import Database from 'better-sqlite3';+import { drizzle } from 'drizzle-orm/better-sqlite3';+import type { DbClient } from '../../localDb/client/DbClient.js';import {decideCodexProviderThreadRelink,isXdOpenAiCodexProviderTransition,relinkCodexProviderThread,+ commitCodexThreadTransfer,} from '../codexProviderThreadRelink.js';const source = {@@ -43,7 +47,47 @@ describe('isXdOpenAiCodexProviderTransition', () => {});});+describe('Codex writer transfer SQLite commit', () => {+ it.each(['unchanged', 'sdk', 'model', 'provider', 'archived', 'revision'])('preserves task identity and rejects stale %s snapshots', async (change) => {+ const sqlite = new Database(':memory:');+ sqlite.exec(`CREATE TABLE sessions (id TEXT PRIMARY KEY, status TEXT, agent_kind TEXT, remote_host_id TEXT, sdk_session_id TEXT, model TEXT, provider_id TEXT, effort TEXT, fast_mode INTEGER, updated_at INTEGER);+ INSERT INTO sessions VALUES ('S', 'active', 'codex', NULL, 'old', 'model', 'openai', 'high', 0, 1);+ INSERT INTO sessions VALUES ('U', 'active', 'codex', NULL, 'unrelated', 'model', 'openai', 'high', 0, 1);+ CREATE TABLE messages (session_id TEXT, content TEXT);+ INSERT INTO messages VALUES ('S', 'retained history');`);+ const db = { drizzle: drizzle(sqlite) } as unknown as Pick<DbClient, 'drizzle'>;+ const snapshot = { id: 'S', sdkSessionId: 'old', model: 'model', providerId: 'openai', effort: 'high' as const, fastMode: false, updatedAt: 1 };+ try {+ const updates: Record<string, string> = {+ sdk: "sdk_session_id = 'newer'", model: "model = 'newer'", provider: "provider_id = 'newer'",+ archived: "status = 'archived'", revision: 'updated_at = 2',+ };+ if (updates[change]) sqlite.exec(`UPDATE sessions SET ${updates[change]} WHERE id = 'S'`);+ const before = sqlite.prepare('SELECT * FROM sessions ORDER BY id').all();+ expect(await commitCodexThreadTransfer(db, snapshot, { sdkSessionId: 'child', model: 'target', providerId: 'cprov-fixture', fastMode: true })).toBe(change === 'unchanged');+ const after = sqlite.prepare('SELECT * FROM sessions ORDER BY id').all();+ expect(after[1]).toEqual(before[1]);+ if (change !== 'unchanged') expect(after).toEqual(before);+ else expect(after[0]).toMatchObject({ id: 'S', sdk_session_id: 'child', model: 'target', provider_id: 'cprov-fixture', effort: 'high', fast_mode: 1 });+ expect(sqlite.prepare('SELECT * FROM messages').all()).toEqual([{ session_id: 'S', content: 'retained history' }]);+ } finally { sqlite.close(); }+ });+});+describe('relinkCodexProviderThread', () => {+ it('keeps the native thread when closing the source has already released its writer', async () => {+ const fork = vi.fn();+ const commit = vi.fn(async () => true);+ const result = await relinkCodexProviderThread({+ readSource: async () => source,+ needsFork: async () => false,+ fork, commit,+ }, { sessionId: 'released', target });+ expect(fork).not.toHaveBeenCalled();+ expect(result?.newSdkSessionId).toBe(source.sdkSessionId);+ expect(commit).toHaveBeenCalledWith(expect.objectContaining({ newSdkSessionId: source.sdkSessionId, target }));+ });+it.each([{name: 'implicit XD to OpenAI',diff --git a/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts b/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.tsindex 2d19f3f330..1f656f4001 100644--- a/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts+++ b/apps/desktop/src/main/maker-ipc/__tests__/runtimeSetModelCodexRelink.test.ts@@ -52,6 +52,63 @@ const routeCases = ['codex/gpt-5.6-sol', 'codex/gpt-5.6-luna'].flatMap((discount},]);+describe('Codex writer decision freshness', () => {+ it.each(['released', 'moved', 'failed'])('rechecks the writer after close: %s', async (state) => {+ const sessionId = rememberSession(`post-close-${state}`);+ setSessionProvider(sessionId, 'cprov-source');+ let closed = false;+ const relink = vi.fn(async () => {});+ const restore = vi.fn();+ const pending = { model: 'earlier', providerId: 'cprov-earlier' };+ const maker: RuntimeSetModelMaker = {+ getSession: () => ({ agentKind: 'codex', model: 'source', setModel: vi.fn(), requiresModelSwitchRebuild: async () => true }),+ listActiveSessions: () => [{ id: sessionId, agentKind: 'codex', isTurnRunning: () => false }],+ closeSession: async () => { closed = true; },+ };+ const result = applyRuntimeSetModelChange({ maker, sessionId, model: 'target', providerId: 'cprov-target',+ requiresCodexThreadRelink: async () => {+ if (closed && state === 'failed') throw new Error('writer lookup failed');+ return closed && state === 'moved';+ }, relinkCodexThread: relink, getPendingCredentialSwitch: () => pending,+ clearPendingCredentialSwitch: vi.fn(), registerPendingCredentialSwitch: restore });+ if (state === 'failed') {+ await expect(result).rejects.toThrow('writer lookup failed');+ expect(restore).toHaveBeenCalledWith(sessionId, pending);+ expect(getSessionProvider(sessionId)).toBe('cprov-source');+ } else {+ await expect(result).resolves.toEqual(state === 'moved' ? { status: 'applied', persistedRoute: true } : { status: 'applied' });+ }+ expect(relink).toHaveBeenCalledTimes(state === 'moved' ? 1 : 0);+ });++ it.each([false, true])('rechecks after asynchronous model inspection with busy=%s', async (busy) => {+ const sessionId = rememberSession('route-changes-during-inspection');+ setSessionProvider(sessionId, 'cprov-source');+ let requiresTransfer = false;+ const relink = vi.fn(async () => {});+ const closeSession = vi.fn(async () => {});+ const registerPendingCredentialSwitch = vi.fn();+ const maker: RuntimeSetModelMaker = {+ getSession: () => ({ agentKind: 'codex', model: 'source', remoteHostId: null,+ setModel: vi.fn(), requiresModelSwitchRebuild: async () => { requiresTransfer = true; return true; } }),+ listActiveSessions: () => [{ id: sessionId, agentKind: 'codex', isTurnRunning: () => busy }],+ closeSession,+ };+ const switching = applyRuntimeSetModelChange({ maker, sessionId, model: 'target', providerId: 'cprov-target',+ requiresCodexThreadRelink: async () => requiresTransfer, relinkCodexThread: relink, registerPendingCredentialSwitch });+ if (busy) {+ await expect(switching).rejects.toThrow(/busy/);+ expect(closeSession).not.toHaveBeenCalled();+ expect(relink).not.toHaveBeenCalled();+ expect(registerPendingCredentialSwitch).not.toHaveBeenCalled();+ } else {+ await expect(switching).resolves.toEqual({ status: 'applied', persistedRoute: true });+ expect(closeSession).toHaveBeenCalledOnce();+ expect(relink).toHaveBeenCalledOnce();+ }+ });+});+describe.each(routeCases)('Codex route: $sourceModel → $targetModel', (route) => {const { sourceProvider, sourceModel, targetProvider, targetModel } = route;it('closes, relinks, then publishes the idle target route', async () => {diff --git a/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts b/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.tsindex 52b20f81f1..fbc2a54236 100644--- a/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts+++ b/apps/desktop/src/main/maker-ipc/codexProviderThreadRelink.ts@@ -1,11 +1,40 @@/**- * Rebuild a local Codex native thread before crossing the XD/OpenAI credential boundary.+ * Transfer a local Codex native writer before changing hosts.*- * Fork authentication belongs to the source thread. The replacement thread id and the+ * The caller selects the native fork route. The replacement thread id and the* complete target runtime route are then committed by one caller-provided CAS.*/import { resolveAgentCredentialMode } from '@cindy/maker-core';+import { and, eq, isNull } from 'drizzle-orm';+import type { DbClient } from '../localDb/client/DbClient.js';+import { sessions } from '../localDb/schema.js';++export type CodexThreadTransferSnapshot = Pick<typeof sessions.$inferSelect,+ 'id' | 'sdkSessionId' | 'model' | 'providerId' | 'effort' | 'fastMode' | 'updatedAt'>;++export function codexThreadTransferSourcePredicate(source: CodexThreadTransferSnapshot) {+ return and(+ eq(sessions.id, source.id), eq(sessions.status, 'active'),+ eq(sessions.agentKind, 'codex'), isNull(sessions.remoteHostId),+ source.sdkSessionId === null ? isNull(sessions.sdkSessionId) : eq(sessions.sdkSessionId, source.sdkSessionId),+ source.model === null ? isNull(sessions.model) : eq(sessions.model, source.model),+ source.providerId === null ? isNull(sessions.providerId) : eq(sessions.providerId, source.providerId),+ eq(sessions.effort, source.effort), eq(sessions.fastMode, source.fastMode),+ eq(sessions.updatedAt, source.updatedAt),+ );+}++export async function commitCodexThreadTransfer(+ db: Pick<DbClient, 'drizzle'>,+ source: CodexThreadTransferSnapshot,+ target: Pick<typeof sessions.$inferSelect, 'sdkSessionId' | 'model' | 'providerId' | 'fastMode'> &+ { effort?: typeof sessions.$inferSelect.effort; contextWindow?: number },+): Promise<boolean> {+ const result = await db.drizzle.update(sessions).set({ ...target, updatedAt: Date.now() })+ .where(codexThreadTransferSourcePredicate(source)).run();+ return result.changes === 1;+}export interface CodexProviderThreadRoute {model: string;@@ -21,6 +50,7 @@ export interface CodexProviderThreadRelinkSource extends CodexProviderThreadRoutexport interface CodexProviderThreadRelinkDeps {readSource(sessionId: string): Promise<CodexProviderThreadRelinkSource | null>;+ needsFork?(threadId: string): Promise<boolean>;fork(input: {sourceSdkSessionId: string;sourceModel: string;@@ -79,7 +109,9 @@ export async function relinkCodexProviderThread(if (!source?.sdkSessionId) return null;const sourceWithThread = { ...source, sdkSessionId: source.sdkSessionId };- const forked = await deps.fork({+ const forked = deps.needsFork && !await deps.needsFork(sourceWithThread.sdkSessionId)+ ? { newSdkSessionId: sourceWithThread.sdkSessionId }+ : await deps.fork({sourceSdkSessionId: sourceWithThread.sdkSessionId,sourceModel: sourceWithThread.model,sourceProviderId: sourceWithThread.providerId,diff --git a/apps/desktop/src/main/maker-ipc/register.ts b/apps/desktop/src/main/maker-ipc/register.tsindex 11013458b5..126f652659 100644--- a/apps/desktop/src/main/maker-ipc/register.ts+++ b/apps/desktop/src/main/maker-ipc/register.ts@@ -980,6 +980,7 @@ import {closeRejectedRuntimeAndRestoreControlStores,isRemoteModelSwitchRouteChangeError,} from './runtimeSetModel.js';+import { codexThreadTransferSourcePredicate, commitCodexThreadTransfer, relinkCodexProviderThread } from './codexProviderThreadRelink.js';import {codexCustomProviderConfigSignature,hasCodexAppliedCustomProviderCapability,@@ -16180,6 +16181,7 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)providerId: sessions.providerId,effort: sessions.effort,fastMode: sessions.fastMode,+ updatedAt: sessions.updatedAt,workingDir: sessions.workingDir,contextTokens: sessions.contextTokens,contextWindow: sessions.contextWindow,@@ -16927,6 +16929,103 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)});};try {+ const transferDb = getCurrentDbClientSnapshot();+ const transferOwner = captureDataOwnerBroadcastScope();+ // A completed, owner-fenced window handoff may have already replaced the+ // native thread during this same locked selection.+ const transferStatus = modelWindowRebuilt && runtimeAgentKind === 'codex'+ ? (await transferDb!.client.drizzle.select().from(sessions).where(eq(sessions.id, sessionId)).limit(1))[0]+ : runtimeStatus;+ assertRuntimeOwnerCurrent();+ if (!transferStatus || transferStatus.status !== 'active') {+ throw new Error('Codex writer transfer task changed');+ }+ const transferMeta = runtimeAgentKind === 'codex' ? await maker.getSessionMeta(sessionId) : null;+ const transferTarget = {+ sessionId,+ model,+ providerId: targetRouteProviderId,+ remoteHostId: transferStatus.remoteHostId ?? undefined,+ ...(transferMeta?.reviewMode ? { reviewMode: true as const } : {}),+ };+ const canTransferThread = routeExplicit && runtimeAgentKind === 'codex' &&+ !transferStatus.remoteHostId && !!transferStatus.sdkSessionId;+ const assertTransferOwner = () => {+ assertRuntimeOwnerCurrent();+ if (!transferDb || !isDataOwnerBroadcastScopeCurrent(transferOwner) ||+ getCurrentDbClientSnapshot()?.clientEpoch !== transferDb.clientEpoch) {+ throw new Error('Codex writer transfer owner changed');+ }+ };+ const relinkCodexThread = async () => {+ assertTransferOwner();+ const sourceSnapshot = { ...transferStatus, id: sessionId };+ const sourcePredicate = codexThreadTransferSourcePredicate(sourceSnapshot);+ const transferred = await relinkCodexProviderThread({+ readSource: async () => {+ assertTransferOwner();+ const [source] = await transferDb!.client.drizzle.select({ id: sessions.id })+ .from(sessions).where(sourcePredicate).limit(1);+ assertTransferOwner();+ if (!source) throw new Error('Codex writer transfer source changed');+ return {+ sdkSessionId: transferStatus.sdkSessionId,+ model: transferStatus.model ?? currentRuntimeModel ?? model,+ providerId: transferStatus.providerId,+ effort: transferStatus.effort,+ fastMode: transferStatus.fastMode,+ workingDir: transferStatus.workingDir,+ };+ },+ needsFork: async (threadId) => {+ assertTransferOwner();+ return maker.requiresCodexThreadHostTransfer({ ...transferTarget, threadId });+ },+ fork: async ({ sourceSdkSessionId, workingDir }) => {+ assertTransferOwner();+ // Native fork never rewrites source history. The core owns the one-shot+ // writer exit barrier; use the destination route, even if old auth expired.+ return maker.forkSdkSession('codex', {+ sourceSdkSessionId, workingDir, model,+ upToMessageId: undefined,+ providerId: targetRouteProviderId,+ stripEncryptedReasoning: false,+ });+ },+ commit: async ({ newSdkSessionId, target }) => {+ assertTransferOwner();+ return commitCodexThreadTransfer(transferDb!.client, sourceSnapshot, {+ sdkSessionId: newSdkSessionId,+ model: target.model,+ providerId: target.providerId,+ ...(target.effort !== null && isSupportedRuntimeEffort(target.effort) ? { effort: target.effort } : {}),+ fastMode: target.fastMode,+ ...(modelWindowRebuilt && targetContextWindow ? { contextWindow: targetContextWindow } : {}),+ });+ },+ }, {+ sessionId,+ target: {+ model, providerId: targetRouteProviderId,+ effort: atomicSelection ? atomicSelection.effort : transferStatus.effort,+ fastMode: atomicSelection ? atomicSelection.fastMode : transferStatus.fastMode,+ },+ });+ assertTransferOwner();+ if (transferred) {+ try {+ broadcastSessionPatched(sessionId, {+ sdkSessionId: transferred.newSdkSessionId,+ model, providerId: targetRouteProviderId,+ }, transferOwner);+ } catch (error) {+ log.warn('Codex writer transfer projection failed after commit', {+ sessionId, error: error instanceof Error ? error.message : String(error),+ });+ }+ }+ };+ assertRuntimeOwnerCurrent();const result = routeExplicit? await applyRuntimeSetModelChange({maker,@@ -16934,6 +17033,12 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)sessionId,model,providerId: effectiveProviderId,+ ...(canTransferThread ? {+ requiresCodexThreadRelink: () => maker.requiresCodexThreadHostTransfer({+ ...transferTarget, threadId: transferStatus.sdkSessionId!,+ }),+ relinkCodexThread,+ } : {}),...(atomicSelection?.effort? {effort: atomicSelection.effort as@@ -16980,6 +17085,9 @@ export function registerMakerIpc(maker: Maker, options: RegisterMakerIpcOptions)if (supersededByOwnerBoundary()) {return { deferred: false, superseded: true };}+ if (result.persistedRoute === true && isDeviceLinkInvoke()) {+ markRemoteSettingPersistedInsideHandler(response);+ }const piSessionAfterRouteChange = maker.getSession(sessionId);if (runtimeAgentKind === 'pi' &&diff --git a/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts b/apps/desktop/src/main/maker-ipc/runtimeSetModel.tsindex 30d6a3a05c..19909ff729 100644--- a/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts+++ b/apps/desktop/src/main/maker-ipc/runtimeSetModel.ts@@ -105,10 +105,10 @@ export interface ApplyRuntimeSetModelChangeInput {*/codexAuthInjection?: CodexProxyAuthInjection | null;/**- * The host has proved that this local Codex selection crosses the explicit XD/OpenAI- * credential boundary and has a persisted native thread to rebuild.+ * The host found a native writer in another local process. Closing the business+ * handle may retain that writer, so verify release or relink before publishing.*/- requiresCodexThreadRelink?: boolean;+ requiresCodexThreadRelink?: boolean | (() => Promise<boolean>);/** Closes over the captured Profile DB and atomically commits thread + full target route. */relinkCodexThread?: () => Promise<void>;logger?: RuntimeSetModelLogger;@@ -193,10 +193,8 @@ export async function applyRuntimeSetModelChange(codexAuthInjection: input.codexAuthInjection,}): false;- const requiresCodexThreadRelink = input.requiresCodexThreadRelink === true;- if (requiresCodexThreadRelink && !input.relinkCodexThread) {- throw new Error(`Codex provider thread relink is required for session ${sessionId}`);- }+ let requiresCodexThreadRelink = typeof input.requiresCodexThreadRelink === 'function'+ ? await input.requiresCodexThreadRelink() : input.requiresCodexThreadRelink === true;const modelSwitchRequiresRebuild =sess &&input.forceSessionRebuild !== true &&@@ -209,6 +207,12 @@ export async function applyRuntimeSetModelChange(modelSwitchRequiresRebuild ||credentialModeRequiresRebuild);+ if (shouldCloseSession && typeof input.requiresCodexThreadRelink === 'function') {+ requiresCodexThreadRelink = await input.requiresCodexThreadRelink();+ }+ if (requiresCodexThreadRelink && !input.relinkCodexThread) {+ throw new Error(`Codex provider thread relink is required for session ${sessionId}`);+ }let selfBusyMemo: boolean | undefined;const isSelfBusy = (): boolean => {if (selfBusyMemo !== undefined) return selfBusyMemo;@@ -340,16 +344,20 @@ export async function applyRuntimeSetModelChange(}throw err;}- if (requiresCodexThreadRelink) {- try {- await input.relinkCodexThread?.();- } catch (error) {- // A failed history transfer must not discard an earlier accepted pending route.- if (clearedPending && input.registerPendingCredentialSwitch) {- await input.registerPendingCredentialSwitch(sessionId, clearedPending);- }- throw error;+ let relinkAfterClose = false;+ try {+ relinkAfterClose = requiresCodexThreadRelink ||+ (typeof input.requiresCodexThreadRelink === 'function' && await input.requiresCodexThreadRelink());+ if (relinkAfterClose) {+ if (!input.relinkCodexThread) throw new Error(`Codex provider thread relink is required for session ${sessionId}`);+ await input.relinkCodexThread();+ }+ } catch (error) {+ // A failed history transfer must not discard an earlier accepted pending route.+ if (clearedPending && input.registerPendingCredentialSwitch) {+ await input.registerPendingCredentialSwitch(sessionId, clearedPending);}+ throw error;}if (providerId !== undefined) setSessionProvider(sessionId, nextProviderId);// close + route 都落定后再唤醒队列:排队消息按新凭证形态 lazy-create 派发。@@ -369,7 +377,7 @@ export async function applyRuntimeSetModelChange(fromModel: sess.model,toModel: model,});- return requiresCodexThreadRelink+ return relinkAfterClose && input.relinkCodexThread? { status: 'applied', persistedRoute: true }: { status: 'applied' };}diff --git a/docs/dev-rules/maker-core-and-agent-behavior.md b/docs/dev-rules/maker-core-and-agent-behavior.mdindex ec9c67a180..6221cb5250 100644--- a/docs/dev-rules/maker-core-and-agent-behavior.md+++ b/docs/dev-rules/maker-core-and-agent-behavior.md@@ -99,8 +99,12 @@ Claude Code/Codex/Pi 的强制换窗线与 Pi 的日常默认值也设为 90%,对齐 Codex 口径,但用户已有显式 override 继续生效。命中`danger`/`overflow` 的本机会话先走同一套 `context_rebuild` bounded handoff,再落目标route,不能 resume 旧原生窗口。-Codex 跨凭证时先按目标来源 resume 同一个原生线程,不因 `ordinal` / `history_base` 或来源-变化而 fork、改写历史或交接。本地恢复与分叉必须同时固定该线程的原生历史根+Codex 跨凭证优先保留同一个原生线程;仅当目标需要另一个 host、旧 host 仍持有原生 writer+时,关闭该任务的业务 handle 后使用不剥离历史的原生 fork,并等待一次性 fork host 退出,+再以任务 owner 与旧 SDK/路由版本为条件原子保存新 SDK thread 和目标路由。任务 ID 与+消息历史不变,无关任务与 host 不退出;旧 writer 已释放则不 fork。`ordinal` /+`history_base` 本身不能成为改写历史的理由。+本地恢复与分叉必须同时固定该线程的原生历史根(`CODEX_HOME`,含 `sessions` / `archived_sessions`)和数据库根(`sqlite_home`);仅固定 SQLite 不足以恢复分页祖先,原生按不可变 rollout ID 在历史根内查找祖先。凭证、代理路由和模型目录仍按本轮选中账号准备,不能把历史根写回全局账号配置。diff --git a/packages/maker-core/src/agents/base-agent.ts b/packages/maker-core/src/agents/base-agent.tsindex 6362afcf4f..75763c41d1 100644--- a/packages/maker-core/src/agents/base-agent.ts+++ b/packages/maker-core/src/agents/base-agent.ts@@ -87,6 +87,12 @@ import type { AutoReviewDelegate, AutoReviewDecision, AutoReviewRequest } from 'import type { ReviewableAction } from './shared/auto-review.js';import type { ClaudeSubagentModelAccessResult } from './claude-code/subagent-model-access.js';+export type CodexLocalAuthPolicyResolution = 'isolated' | 'legacy-shared' | {+ policy: 'isolated' | 'legacy-shared';+ /** Synchronous check of the host routing transaction that produced this policy. */+ isCurrent: () => boolean;+};+export interface AgentCapabilityAdditions {/** Extra models exposed by the host for this agent. Existing built-in ids are ignored. */availableModels?: readonly ModelDescriptor[];@@ -462,6 +468,8 @@ export interface LocalAgentProcessRegistration {}export interface CodexLocalCredentialModeSwitchContext {+ /** Exact local host being replaced; omitted by legacy hosts. */+ hostKey?: string;fromMode?: AgentCredentialMode;/*** 当前 host 的归一化生效形态(createHost 时按 auth fallback 推出并登记)。@@ -969,6 +977,13 @@ export interface AgentDeps {modelId: string,) => number | null;+ /** Local disk-auth policy, independent of the actual Provider credential mode. */+ resolveCodexLocalAuthPolicy?: (+ providerId: string | null | undefined,+ modelId: string,+ signal?: AbortSignal,+ ) => CodexLocalAuthPolicyResolution | Promise<CodexLocalAuthPolicyResolution>;+/*** Per-model requested context window (user override first, explicit provider default second).* A one-session native catalog permits this window without changing sibling routes.@@ -1010,6 +1025,9 @@ export interface AgentDeps {accountHostKey?: string;remoteHostId?: string;credentialMode?: AgentCredentialMode;+ /** Frozen disk OAuth policy; independent of the actual Provider credential. */+ localAuthPolicy?: 'isolated' | 'legacy-shared';+ hostScopeKey?: string;/** Original session request when the shared host was upgraded to a credential superset. */requestedCredentialMode?: AgentCredentialMode;/** Marks app-server work that must not share the normal local task host. */@@ -2154,6 +2172,8 @@ export interface AgentSessionHandle {): () => void;/** Codex-only: 当前会话绑定的 app-server host 是否经 loopback proxy 出口。 */readonly codexProxyActive?: boolean;+ /** Local runtime identity, never serialized to the remote wire protocol. */+ readonly codexHostKey?: string;/*** Codex-only: thread/start 或 thread/resume 响应确认的实际 model provider。* 这是 thread 级冻结身份,不随 thread/settings/update 的模型切换改变。@@ -2616,6 +2636,13 @@ export abstract class BaseAgent {return this.throwNotSupported('forkSdkSession', 'sdk-missing');}+ async requiresCodexThreadHostTransfer(+ opts: Pick<StartSessionOptions, 'sessionId' | 'model' | 'providerId' | 'reviewMode' | 'remoteHostId'> & { threadId: string },+ ): Promise<boolean> {+ void opts;+ return false;+ }+// ── Auth 透传到 deps.auth ────────────────────────────────────────────────// Maker 不直接访问 agent.deps (protected), 通过这层 thin façade 暴露给 host// 的 maker:auth:* IPC handler。BaseAgent 把"agent 的鉴权"作为一等公民,diff --git a/packages/maker-core/src/agents/codex/app-server/client.ts b/packages/maker-core/src/agents/codex/app-server/client.tsindex 16b02fc30f..7db23ca29a 100644--- a/packages/maker-core/src/agents/codex/app-server/client.ts+++ b/packages/maker-core/src/agents/codex/app-server/client.ts@@ -313,6 +313,11 @@ export class AppServerClient {return response;}+ /** Only local transports can prove this pre-protocol failure and process exit. */+ nativeSqliteInitializationFailed(): boolean {+ return !this.initialized && this.transport?.nativeSqliteInitializationFailed?.() === true;+ }+/*** close() 是幂等的; reason 仅用于 reject pending requests 的错误消息。* - reject 所有挂起 promisediff --git a/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts b/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.tsindex f1f525bc20..756e57bb90 100644--- a/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts+++ b/packages/maker-core/src/agents/codex/app-server/external-auth.native.test.ts@@ -30,7 +30,7 @@ function fakeTokens(account: string, revision = 'initial') {return { accessToken: `test.${payload}.not-a-signature`, chatgptAccountId: account, chatgptPlanType: 'pro' };}-async function fixture(archivedParent = false, testRefresh = false) {+async function fixture(archivedParent = false, testRefresh = false, revokedRefresh = false, generic401 = false) {const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-codex-history-contract-'));roots.push(root);const historyHome = path.join(root, 'history-a');@@ -38,11 +38,17 @@ async function fixture(archivedParent = false, testRefresh = false) {await fs.mkdir(credentialHome);const wireRequests: Array<{ authorization: string | undefined; account: string | string[] | undefined }> = [];const refreshRequests: unknown[] = [];+ const discoveryRequests: Array<string | string[] | undefined> = [];const server = createServer(async (request, response) => {if (request.method === 'POST' && request.url === '/oauth/token') {let body = '';for await (const chunk of request) body += chunk;refreshRequests.push(JSON.parse(body));+ if (revokedRefresh) {+ response.writeHead(400, { 'content-type': 'application/json' });+ response.end(JSON.stringify({ error: { code: 'refresh_token_invalidated', message: 'Synthetic refresh credential revoked' } }));+ return;+ }const token = fakeTokens('account-b', 'refreshed').accessToken;response.writeHead(200, { 'content-type': 'application/json' });response.end(JSON.stringify({ id_token: token, access_token: token, refresh_token: 'fixture-refresh-b2' }));@@ -51,9 +57,9 @@ async function fixture(archivedParent = false, testRefresh = false) {if (request.method === 'POST' && request.url?.endsWith('/responses')) {wireRequests.push({ authorization: request.headers.authorization, account: request.headers['chatgpt-account-id'] });request.resume();- if (testRefresh && wireRequests.length === 1) {+ if (testRefresh && (request.headers.authorization !== `Bearer ${fakeTokens('account-b', 'refreshed').accessToken}` || request.headers['chatgpt-account-id'] !== 'account-b')) {response.writeHead(401, { 'content-type': 'application/json' });- response.end(JSON.stringify({ error: { message: 'expired fixture credential' } }));+ response.end(JSON.stringify({ error: { ...(generic401 ? {} : { code: 'token_expired' }), message: 'Provided authentication token is expired.' } }));return;}response.writeHead(200, { 'content-type': 'text/event-stream' });@@ -63,6 +69,14 @@ async function fixture(archivedParent = false, testRefresh = false) {} })}\n\n`);return;}+ if (request.method === 'GET' && request.url?.endsWith('/accounts/check')) {+ discoveryRequests.push(request.headers['chatgpt-account-id']);+ response.writeHead(200, { 'content-type': 'application/json' });+ response.end(JSON.stringify({ accounts: ['account-a', 'account-b'].map(id => ({+ id, workspace_backend_origin: `https://127.0.0.1:${(server.address() as import('node:net').AddressInfo).port}`, account_routing_override: 'NO_CONSTRAINT',+ })), default_account_id: 'account-a' }));+ return;+ }response.setHeader('content-type', 'application/json');response.end(JSON.stringify({ models: [] }));});@@ -108,6 +122,7 @@ async function fixture(archivedParent = false, testRefresh = false) {'-c', `sqlite_home=${JSON.stringify(historyHome)}`,'-c', `cli_auth_credentials_store="${managed ? 'file' : 'ephemeral'}"`, '-c', 'model_provider="probe"','-c', 'model_providers.probe.name="Probe"', '-c', `model_providers.probe.base_url=${JSON.stringify(baseUrl)}`,+ '-c', 'model_providers.probe.stream_max_retries=0', '-c', 'model_providers.probe.request_max_retries=0','-c', 'model_providers.probe.wire_api="responses"', '-c', `model_providers.probe.requires_openai_auth=${Boolean(account)}`,'-c', `chatgpt_base_url=${JSON.stringify(baseUrl)}`],}),@@ -121,13 +136,13 @@ async function fixture(archivedParent = false, testRefresh = false) {approvalPolicy: 'never', sandbox: 'read-only',}, { timeoutMs: 15_000 });}- async function assertOriginals(managed = false) {- expect(await fs.readFile(parent.file, 'utf8')).toBe(parent.text);+ async function assertOriginals(managed = false, expectedParent = parent.text) {+ expect(await fs.readFile(parent.file, 'utf8')).toBe(expectedParent);expect(await fs.readFile(path.join(historyHome, 'auth.json'), 'utf8')).toBe(oldAuth);expect((await fs.stat(path.join(historyHome, 'auth.json'))).mtimeMs).toBe(authStat.mtimeMs);if (!managed) await expect(fs.stat(path.join(credentialHome, 'auth.json'))).rejects.toMatchObject({ code: 'ENOENT' });}- return { root, historyHome, credentialHome, parent, child, rollout, host, resume, assertOriginals, wireRequests, refreshRequests };+ return { root, historyHome, credentialHome, parent, child, rollout, host, resume, assertOriginals, wireRequests, refreshRequests, discoveryRequests };}describe.skipIf(!binaryPath)('real Codex history/account isolation contract', () => {@@ -147,6 +162,8 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()const host = f.host(f.historyHome, account);await expect(f.resume(host, grandchild)).resolves.toMatchObject({ thread: { id: grandchild.id } });const status = await host.request('account/read', { refreshToken: false });+ expect(f.discoveryRequests.at(-1)).toBe(account);+ expect(status).toMatchObject({ workspaceRouting: { chatgptAccountId: account } });expect(status).toMatchObject({ account: { type: 'chatgpt', email: `${account}@example.invalid`, planType: 'pro' } });await host.shutdown('simulate transport replacement');await expect(f.resume(host, grandchild)).resolves.toMatchObject({ thread: { id: grandchild.id } });@@ -223,15 +240,35 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()const original = f.host(f.historyHome, 'account-a');await f.resume(original, f.parent);await original.retire();+ // 0.156 persists a thread-owned settings snapshot on resume. Original+ // indexed bytes and ordinals stay unchanged; only this exact native record+ // is permitted. The rejected cross-home fork must not append anything else.+ const resumedHistory = await fs.readFile(f.parent.file, 'utf8');+ expect(resumedHistory.startsWith(f.parent.text)).toBe(true);+ const appended = resumedHistory.slice(f.parent.text.length).trim().split('\n').map(line => JSON.parse(line));+ expect(appended).toEqual([{+ timestamp: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/), ordinal: 2, type: 'event_msg',+ payload: { type: 'thread_settings_applied', thread_id: f.parent.id, thread_settings: {+ model: 'gpt-6-astra', model_provider_id: 'probe', approval_policy: 'never', approvals_reviewer: 'user',+ permission_profile: { type: 'managed', file_system: { type: 'restricted', entries: [+ { path: { type: 'special', value: { kind: 'root' } }, access: 'read' },+ ] }, network: 'restricted' },+ cwd: f.root, runtime_workspace_roots: [f.root],+ collaboration_mode: { mode: 'default', settings: { model: 'gpt-6-astra', reasoning_effort: null, developer_instructions: null } },+ disabled_plugin_ids: [],+ } },+ }]);const oldForkHost = f.host(f.credentialHome, 'account-b');await expect(oldForkHost.request('thread/fork', {threadId: f.parent.id, path: f.parent.file, cwd: f.root, model: 'gpt-6-astra',}, { timeoutMs: 15_000 })).rejects.toThrow('must be in Codex home directory');- await f.assertOriginals();+ await f.assertOriginals(false, resumedHistory);}, 30_000);- it('refreshes managed credentials on disk after a native 401 even before natural expiry', async () => {- const f = await fixture(false, true);+ it.each(['expired', 'generic', 'revoked'])('handles managed credentials after a native 401 before expiry (%s)', async (mode) => {+ const revoked = mode === 'revoked';+ const f = await fixture(false, true, revoked, mode === 'generic');+ const readerCalls: boolean[] = [];const authPath = path.join(f.credentialHome, 'auth.json');const initial = fakeTokens('account-b').accessToken;// A freshly written managed login must still force-refresh after a rejected request.@@ -240,6 +277,7 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()last_refresh: new Date().toISOString() }));const accountHost = f.host(f.credentialHome, 'account-b', true);const host = f.host(f.historyHome, 'account-b', false, { readTokens: async refresh => {+ readerCalls.push(refresh);if (refresh) await accountHost.request('account/read', { refreshToken: true }, { timeoutMs: 8_000 });const credentials = JSON.parse(await fs.readFile(authPath, 'utf8'));return { accessToken: credentials.tokens.access_token, chatgptAccountId: credentials.tokens.account_id };@@ -250,7 +288,14 @@ describe.skipIf(!binaryPath)('real Codex history/account isolation contract', ()const subscription = host.subscribeThread(f.child.id, { turnCompleted: completed });try {await host.request('turn/start', { threadId: f.child.id, input: [{ type: 'text', text: 'fixture request' }] }, { timeoutMs: 15_000 });- await expect(completion).resolves.toMatchObject({ turn: { status: 'completed' } });+ await expect(completion).resolves.toMatchObject({ turn: { status: revoked ? 'failed' : 'completed' } });+ expect(readerCalls).toEqual([false, true]);+ if (revoked) {+ expect(f.wireRequests).toEqual([{ authorization: `Bearer ${initial}`, account: 'account-b' }]);+ expect(f.refreshRequests).toHaveLength(1);+ await f.assertOriginals(true);+ return;+ }expect(f.wireRequests).toEqual([{ authorization: `Bearer ${fakeTokens('account-b').accessToken}`, account: 'account-b' },{ authorization: `Bearer ${fakeTokens('account-b', 'refreshed').accessToken}`, account: 'account-b' },diff --git a/packages/maker-core/src/agents/codex/app-server/host.test.ts b/packages/maker-core/src/agents/codex/app-server/host.test.tsindex 191e802237..c287f27e01 100644--- a/packages/maker-core/src/agents/codex/app-server/host.test.ts+++ b/packages/maker-core/src/agents/codex/app-server/host.test.ts@@ -1,6 +1,6 @@import { describe, expect, it, vi } from 'vitest';-import { AppServerHost } from './host.js';+import { AppServerHost, CodexNativeInitializationStoppedError } from './host.js';import type { Logger } from '../../../interfaces/logger.js';import type { Transport, LineHandler, StderrHandler, CloseHandler } from './transport.js';@@ -153,6 +153,40 @@ class NotificationTransport implements Transport {}}+describe('concrete writer candidate proof', () => {+ it.each(['request', 'notification', 'subscription'])('retains %s evidence until confirmed process exit', async (source) => {+ const transports: NotificationTransport[] = [];+ const host = new AppServerHost({ createTransport: () => {+ const transport = new NotificationTransport(); transports.push(transport); return transport;+ }, logger, clientInfo: { name: 'test', version: '0' } });+ try {+ await host.ensureStarted();+ expect(host.writerCandidate).toBeNull();+ await host.request('thread/loaded/list');+ expect(host.writerCandidate).toBeNull();+ if (source === 'request') await host.request('thread/resume', { threadId: 'source' });+ if (source === 'notification') transports[0].emit({ method: 'thread/started', params: { thread: { id: 'source' } } });+ if (source === 'subscription') host.subscribeThread('source', {});+ const proof = host.writerCandidate;+ expect(proof).not.toBeNull();+ const close = vi.spyOn(transports[0], 'close').mockRejectedValueOnce(new Error('exit not proven'));+ await expect(host.shutdown('test', { throwOnTransportError: true })).rejects.toThrow('exit not proven');+ expect(host.writerCandidate).toBe(proof);+ close.mockRestore();+ await host.shutdown('confirmed', { throwOnTransportError: true });+ expect(host.writerCandidate).toBeNull();+ await host.ensureStarted();+ expect(host.writerCandidate).toBeNull();+ // A late old notification cannot turn the replacement into an old writer.+ transports[0].emit({ method: 'thread/started', params: { thread: { id: 'source' } } });+ expect(host.writerCandidate).toBeNull();+ await host.request('thread/start');+ expect(host.writerCandidate).not.toBe(proof);+ expect(host.writerCandidate).not.toBeNull();+ } finally { await host.retire(); }+ });+});+describe('AppServerHost isolated account lifecycle', () => {it.each([false, true])('rejects persistent native policy before task dispatch (OAuth: %s)', async oauth => {const transport = new NotificationTransport(() => ({ config: { cli_auth_credentials_store: 'file' } }));@@ -489,7 +523,124 @@ const logger: Logger = {child: () => logger,};+describe('native SQLite initialization recovery', () => {+ class FailedNativeTransport extends NotificationTransport {+ failed = false;+ closeGate: Promise<void> = Promise.resolve();+ override async writeLine(line: string) {+ this.lines.push(line);+ this.failed = true;+ await super.close('native SQLite exited');+ }+ nativeSqliteInitializationFailed() { return this.failed; }+ override async close(reason?: string) { await this.closeGate; await super.close(reason); }+ }++ it('shares recovery, waits for close, and sends the task only to the replacement', async () => {+ const failed = new FailedNativeTransport();+ let release!: () => void;+ failed.closeGate = new Promise(resolve => { release = resolve; });+ const healthy = new NotificationTransport();+ const createTransport = vi.fn().mockReturnValueOnce(failed).mockReturnValue(healthy);+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });+ try {+ const first = host.ensureStarted();+ expect(host.ensureStarted()).toBe(first);+ await vi.waitFor(() => expect(failed.failed).toBe(true));+ expect(createTransport).toHaveBeenCalledTimes(1);+ release();+ await first;+ await host.request('thread/start', {});+ expect(createTransport).toHaveBeenCalledTimes(2);+ expect(failed.lines.map(line => JSON.parse(line).method)).toEqual(['initialize']);+ expect(healthy.lines.map(line => JSON.parse(line).method)).toEqual(['initialize', 'thread/start']);+ } finally { release(); await host.retire(); }+ });++ it.each(['exhaust', 'shutdown', 'retire', 'timeout', 'close-failure'] as const)('stops recovery on %s', async mode => {+ let release!: () => void;+ const gate = new Promise<void>(resolve => { release = resolve; });+ const failed = new FailedNativeTransport();+ if (mode !== 'exhaust') failed.closeGate = gate;+ if (mode === 'close-failure') failed.close = vi.fn(async () => { await gate; throw new Error('exit unconfirmed'); });+ const createTransport = vi.fn(() => mode === 'exhaust' ? new FailedNativeTransport() : failed);+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });+ const started = mode === 'timeout' ? host.ensureStartedWithTimeout(10, 'fixture') : host.ensureStarted();+ const rejection = expect(started).rejects.toThrow(mode === 'timeout' ? /timed out/ : mode === 'close-failure' ? /exit unconfirmed/ : /initialization stopped/);+ if (mode === 'exhaust') {+ await rejection;+ expect(createTransport).toHaveBeenCalledTimes(3);+ } else {+ await vi.waitFor(() => expect(failed.failed).toBe(true));+ const stopped = mode === 'shutdown' ? host.shutdown() : mode === 'retire' ? host.retire() : undefined;+ if (mode === 'timeout') await rejection;+ release();+ await rejection;+ await stopped;+ await new Promise(resolve => setTimeout(resolve, 0));+ expect(createTransport).toHaveBeenCalledTimes(1);+ }+ await host.retire();+ });++ it('does not retry an initialize RPC rejection', async () => {+ const createTransport = vi.fn(() => new RejectedInitializeTransport());+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });+ await expect(host.ensureStarted()).rejects.not.toBeInstanceOf(CodexNativeInitializationStoppedError);+ expect(createTransport).toHaveBeenCalledTimes(1);+ await host.retire();+ });++ it('does not retry credential installation after native initialization', async () => {+ const transport = new NotificationTransport(() => ({ config: { cli_auth_credentials_store: 'ephemeral' } }));+ const createTransport = vi.fn(() => transport);+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' },+ externalAuth: { readTokens: async () => { throw new Error('synthetic official account rejected'); } },+ });+ await expect(host.request('thread/start', {})).rejects.toThrow('Codex account authentication is unavailable or has changed');+ expect(createTransport).toHaveBeenCalledTimes(1);+ expect(transport.lines.map(line => JSON.parse(line).method)).not.toContain('thread/start');+ await host.retire();+ });++ it('never replays a task RPC failure after initialize', async () => {+ const transport = new NotificationTransport(method => {+ if (method === 'thread/start') throw new Error('synthetic task write failed');+ return {};+ });+ const createTransport = vi.fn(() => transport);+ const host = new AppServerHost({ createTransport, logger, clientInfo: { name: 'test', version: '0' } });+ await expect(host.request('thread/start', {})).rejects.toThrow();+ expect(createTransport).toHaveBeenCalledTimes(1);+ expect(transport.lines.filter(line => JSON.parse(line).method === 'thread/start')).toHaveLength(1);+ await host.retire();+ });+});+describe('AppServerHost.request startup timeout', () => {+ it.each([undefined, 1000])('checks dispatch after the final startup await (timeout=%s)', async (timeoutMs) => {+ const transport = new NotificationTransport();+ const host = new AppServerHost({ createTransport: () => transport, logger, clientInfo: { name: 'test', version: '0' } });+ try {+ await host.ensureStarted();+ let release!: () => void;+ const gate = new Promise<void>((resolve) => { release = resolve; });+ const ensure = host.ensureStarted.bind(host);+ vi.spyOn(host, 'ensureStarted').mockImplementationOnce(async () => { await gate; return ensure(); });+ let valid = true;+ const beforeDispatch = vi.fn(() => { if (!valid) throw new Error('route expired'); });+ const pending = host.request('thread/start', {}, { timeoutMs, beforeDispatch });+ expect(beforeDispatch).not.toHaveBeenCalled();+ valid = false;+ release();+ await expect(pending).rejects.toThrow('route expired');+ expect(transport.lines.some((line) => JSON.parse(line).method === 'thread/start')).toBe(false);+ valid = true;+ await host.request('thread/start', {}, { timeoutMs, beforeDispatch });+ expect(transport.lines.filter((line) => JSON.parse(line).method === 'thread/start')).toHaveLength(1);+ } finally { await host.shutdown(); }+ });+it('bounds a hung ensureStarted by the caller-provided timeoutMs (greptile R6 P1)', async () => {// 冷启动 / transport 重建时 ensureStarted 本身也可能永不返回 — 调用方显式// 给的 timeoutMs 必须同样覆盖启动路径, 否则「关键 RPC 加超时」形同虚设。diff --git a/packages/maker-core/src/agents/codex/app-server/host.ts b/packages/maker-core/src/agents/codex/app-server/host.tsindex 19c788b9f9..d4ee0e19fe 100644--- a/packages/maker-core/src/agents/codex/app-server/host.ts+++ b/packages/maker-core/src/agents/codex/app-server/host.ts@@ -329,6 +329,9 @@ interface BufferedNotification {ts: number;}+/** All native attempts have exited before this error is exposed to a task startup. */+export class CodexNativeInitializationStoppedError extends Error {}+export class AppServerHost {private readonly externalAuth: CodexExternalAuthSession | undefined;private readonly connectionId = randomUUID();@@ -337,8 +340,13 @@ export class AppServerHost {private readonly threadUnsubscribeTimeoutMs: number;private client: AppServerClient | null = null;+ // Negative proof belongs to the exact transport, not readiness or provider.+ // Any application RPC may load a thread (including future protocol methods).+ // Bootstrap initialize/config/auth and the read-only writer probe do not.+ private readonly writerCandidates = new WeakSet<AppServerClient>();/** 同次 ensureStarted 并发调用共享一个 init Promise (避免重复 spawn)。 */private startPromise: Promise<InitializeResponse> | null = null;+ private nativeInitializationEpoch = 0;private readonly subscribers = new Map<string, ThreadEventHandlers>();/** root / descendant threadId → 当前拥有该子树订阅的 root threadId。 */@@ -624,6 +632,7 @@ export class AppServerHost {started,new Promise<never>((_, reject) => {timer = setTimeout(() => {+ this.nativeInitializationEpoch++;reject(new Error(`app-server startup (for ${label}) timed out after ${timeoutMs}ms`));}, timeoutMs);timer.unref?.();@@ -637,11 +646,19 @@ export class AppServerHost {}}- private async bootstrap(capabilities?: InitializeCapabilities): Promise<InitializeResponse> {+ private async bootstrap(+ capabilities?: InitializeCapabilities,+ nativeAttempt = 0,+ nativeEpoch = this.nativeInitializationEpoch,+ ): Promise<InitializeResponse> {const client = new AppServerClient({createTransport: this.opts.createTransport,logger: this.opts.logger,- onTransportError: (err) => this.handleTransportError(err),+ onTransportError: (err) => {+ // Keep the shared startPromise while recovering this one pre-protocol+ // failure. Every other transport error retains the normal host lifecycle.+ if (!client.nativeSqliteInitializationFailed()) this.handleTransportError(err);+ },onAuthInvalidated: this.opts.onAuthInvalidated,captureCredentialGeneration: this.opts.captureCredentialGeneration,});@@ -665,7 +682,10 @@ export class AppServerHost {// 注册 notification handlers BEFORE initialize: server 在握手响应前可能就推了// banner / 启动 notification, 漏接就丢。for (const method of SUBSCRIBED_METHODS) {- client.onNotification(method, (params) => this.routeNotification(method, params));+ client.onNotification(method, (params) => {+ if (extractThreadId(method, params)) this.writerCandidates.add(client);+ this.routeNotification(method, params);+ });}// ServerRequest handlers (Phase 2 approval) — 同样在 initialize 前注册,@@ -834,7 +854,21 @@ export class AppServerHost {optOutNotificationMethods: NOTIFICATIONS_TO_OPT_OUT,...capabilities,};- const resp = await client.initialize(this.opts.clientInfo, mergedCapabilities);+ let resp: InitializeResponse;+ try {+ resp = await client.initialize(this.opts.clientInfo, mergedCapabilities);+ } catch (error) {+ if (!client.nativeSqliteInitializationFailed()) throw error;+ // No task/config/authentication RPC has been submitted. The transport+ // proves natural exit; still use the existing strict close barrier.+ await client.close({ reason: 'native SQLite initialization failed', throwOnTransportError: true });+ if (nativeAttempt >= 2 || nativeEpoch !== this.nativeInitializationEpoch+ || this.retired || this.shuttingDown || this.client !== client) {+ throw new CodexNativeInitializationStoppedError('Codex native SQLite initialization stopped', { cause: error });+ }+ this.logger.warn('retrying exited native SQLite initialization', { attempt: nativeAttempt + 2, maxAttempts: 3 });+ return this.bootstrap(capabilities, nativeAttempt + 1, nativeEpoch);+ }if (this.opts.requireEphemeralAuth || this.externalAuth) {// Requirements can override CLI configuration. Reject before any task RPC// or token installation; initialization has already loaded native config.@@ -865,7 +899,7 @@ export class AppServerHost {async request<R = unknown>(method: string,params?: unknown,- opts?: { timeoutMs?: number },+ opts?: { timeoutMs?: number; beforeDispatch?: () => void },): Promise<R> {// 冷启动 / transport 重建时 ensureStarted 本身也可能永不返回 (远端 daemon// bootstrap 挂死 / SSH 通道无响应) — 调用方显式给 timeoutMs 时同样给它@@ -882,6 +916,7 @@ export class AppServerHost {started,new Promise<never>((_, reject) => {timer = setTimeout(() => {+ this.nativeInitializationEpoch++;reject(new Error(`app-server startup (for ${method}) timed out after ${opts.timeoutMs}ms`));}, opts.timeoutMs);timer.unref?.();@@ -900,10 +935,14 @@ export class AppServerHost {throw new Error(`app-server startup (for ${method}) consumed the entire ${opts.timeoutMs}ms timeout budget`);}if (!this.client) throw new Error('AppServerHost: client missing after ensureStarted (unreachable)');+ opts?.beforeDispatch?.();+ if (method !== 'thread/loaded/list') this.writerCandidates.add(this.client);return this.client.request<R>(method, params, { ...opts, timeoutMs: remaining });}await started;if (!this.client) throw new Error('AppServerHost: client missing after ensureStarted (unreachable)');+ opts?.beforeDispatch?.();+ if (method !== 'thread/loaded/list') this.writerCandidates.add(this.client);return this.client.request<R>(method, params, opts);}@@ -930,6 +969,7 @@ export class AppServerHost {reason = 'AppServerHost.shutdown()',opts?: { throwOnTransportError?: boolean },): Promise<void> {+ this.nativeInitializationEpoch++;if (!this.shutdownPromise) {this.shuttingDown = true;const client = this.client;@@ -1084,6 +1124,7 @@ export class AppServerHost {if (this.subscribers.has(threadId)) {this.logger.warn('overwriting thread subscription', { threadId });}+ if (this.client) this.writerCandidates.add(this.client);this.subscribers.set(threadId, handlers);this.lineageRoots.set(threadId, threadId);this.notifyThreadHandlerWaiters(threadId);@@ -1660,6 +1701,15 @@ export class AppServerHost {return this.subscribers.has(threadId);}+ /**+ * Opaque concrete process identity which may own a writer. Null proves no+ * application request/thread evidence in this process. A failed shutdown keeps+ * the client (and evidence); a confirmed exit/restart gets a fresh identity.+ */+ get writerCandidate(): object | null {+ return this.client && this.writerCandidates.has(this.client) ? this.client : null;+ }+/** 是否已经 spawn 过子进程 (但可能已 close)。 */get hasStarted(): boolean {return this.client !== null;diff --git a/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts b/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.tsindex b62084286b..df57d72c55 100644--- a/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts+++ b/packages/maker-core/src/agents/codex/app-server/stdioTransport.test.ts@@ -10,6 +10,8 @@ vi.mock('node:child_process', () => ({ spawn: mocks.spawn }));vi.mock('node:readline', () => ({ createInterface: mocks.createInterface }));import { createStdioTransport } from './stdioTransport.js';+import { AppServerHost, CodexNativeInitializationStoppedError } from './host.js';+import type { Logger } from '../../../interfaces/logger.js';function makeEmitterStream() {const stream = new EventEmitter() as EventEmitter & { setEncoding: ReturnType<typeof vi.fn> };@@ -62,6 +64,82 @@ afterEach(() => {});describe('createStdioTransport process observer', () => {+ it.each(['exit', 'pending', 'stdout', 'signal', 'other-error', 'different-path'])('classifies only a confirmed pre-protocol SQLite exit (%s)', (scenario) => {+ const child = makeChild();+ mocks.spawn.mockReturnValue(child);+ const transport = createStdioTransport({ binaryPath: 'codex' });+ const error = scenario === 'other-error' ? 'Error: failed to load configuration: revoked'+ : `Error: failed to initialize sqlite state runtime under /synthetic: failed to initialize state runtime at ${scenario === 'different-path' ? '/other' : '/synthetic'}`;+ child.stderr.emit('data', `${error}\n`);+ if (scenario === 'stdout') child.stdout.emit('data', '{}');+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);+ if (scenario !== 'pending') {+ child.emit('exit', 1, scenario === 'signal' ? 'SIGTERM' : null);+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);+ child.emit('close', 1, scenario === 'signal' ? 'SIGTERM' : null);+ }+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(scenario === 'exit');+ });+ it.each(['/synthetic/db', String.raw`C:\synthetic\db`])('drains split fatal output after physical exit (%s)', async (home) => {+ const child = makeChild();+ mocks.spawn.mockReturnValue(child);+ const disposed = vi.fn();+ const transport = createStdioTransport({ binaryPath: 'codex', onProcessSpawned: () => disposed });+ const closed = vi.fn();+ const stderr = vi.fn();+ transport.onClose(closed);+ transport.onStderr?.(stderr);+ child.stderr.emit('data', `diagnostic\r\nError: failed to initialize sqlite state runtime under ${home}: failed to initialize state runtime at `);+ child.emit('exit', 1, null);+ expect(disposed).toHaveBeenCalledOnce();+ expect(closed).not.toHaveBeenCalled();+ expect(mocks.createInterface.mock.results[0]!.value.close).not.toHaveBeenCalled();+ child.stderr.emit('data', home + '\r'); // No final newline.+ child.emit('close', 1, null);+ expect(stderr).toHaveBeenLastCalledWith(`Error: failed to initialize sqlite state runtime under ${home}: failed to initialize state runtime at ${home}`);+ expect(closed).toHaveBeenCalledOnce();+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(true);+ await transport.close('strict cleanup');+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(true);+ expect(child.kill).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(0);+ });++ it.each(['stdout', 'cancel', 'drain-timeout'])('refuses recovery when %s arrives between exit and drain', async (scenario) => {+ const child = makeChild();+ mocks.spawn.mockReturnValue(child);+ const transport = createStdioTransport({ binaryPath: 'codex', outputDrainMs: 25 });+ const closed = vi.fn();+ transport.onClose(closed);+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at /x');+ child.emit('exit', 1, null);+ expect(closed).not.toHaveBeenCalled();+ if (scenario === 'stdout') child.stdout.emit('data', '{}');+ if (scenario === 'cancel') await transport.close('initialize timeout / cancellation');+ if (scenario === 'drain-timeout') await vi.advanceTimersByTimeAsync(25);+ child.emit('close', 1, null);+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);+ expect(closed).toHaveBeenCalledOnce();+ await transport.close();+ expect(child.kill).not.toHaveBeenCalled();+ expect(vi.getTimerCount()).toBe(0);+ });++ it('cancels recovery when the drained stderr callback closes synchronously', async () => {+ const child = makeChild();+ mocks.spawn.mockReturnValue(child);+ const transport = createStdioTransport({ binaryPath: 'codex' });+ transport.onStderr?.(() => { void transport.close('callback cancelled startup'); });+ const closed = vi.fn();+ transport.onClose(closed);+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at /x');+ child.emit('exit', 1, null);+ child.emit('close', 1, null);+ expect(transport.nativeSqliteInitializationFailed?.()).toBe(false);+ expect(closed).toHaveBeenCalledExactlyOnceWith({ reason: 'callback cancelled startup' });+ await transport.close();+ });+it('starts the app-server without a visible Windows console', () => {mocks.spawn.mockReturnValue(makeChild());@@ -137,6 +215,58 @@ describe('createStdioTransport process observer', () => {});});+describe('production stdio initialization recovery', () => {+ it.each(['recover', 'exhaust', 'timeout'])('keeps drain classification and the three-process budget on %s', async (scenario) => {+ const logger: Logger = { trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {}, child: () => logger };+ const children: ReturnType<typeof makeChild>[] = [];+ const readers: EventEmitter[] = [];+ const requests: string[][] = [];+ mocks.createInterface.mockImplementation(() => {+ const reader = Object.assign(new EventEmitter(), { close: vi.fn() });+ readers.push(reader); return reader;+ });+ mocks.spawn.mockImplementation(() => {+ const child = makeChild(4321 + children.length);+ const index = children.length;+ children.push(child); requests.push([]);+ child.stdin.end.mockImplementation(() => { child.emit('exit', 0, null); child.emit('close', 0, null); });+ child.stdin.write.mockImplementation((line: string, _encoding: string, done: () => void) => {+ const rpc = JSON.parse(line);+ if (rpc.method) requests[index].push(rpc.method);+ queueMicrotask(() => {+ if (index === 2 && scenario === 'recover') {+ if (rpc.id != null) readers[index].emit('line', JSON.stringify({ id: rpc.id, result: {} }));+ } else if (rpc.method === 'initialize') {+ child.stderr.emit('data', 'Error: failed to initialize sqlite state runtime under /x: failed to initialize state runtime at ');+ child.emit('exit', 1, null);+ // Late pipes: timeout must revoke retry eligibility before close.+ setTimeout(() => { child.stderr.emit('data', '/x'); child.emit('close', 1, null); }, 20);+ }+ });+ done(); return true;+ });+ return child;+ });+ const host = new AppServerHost({ logger, clientInfo: { name: 'test', version: '0' },+ createTransport: () => createStdioTransport({ binaryPath: 'codex' }),+ });+ const started = scenario === 'timeout' ? host.ensureStartedWithTimeout(10, 'test') : host.ensureStarted();+ const result = scenario === 'recover' ? expect(started).resolves.toBeDefined()+ : scenario === 'exhaust' ? expect(started).rejects.toBeInstanceOf(CodexNativeInitializationStoppedError)+ : expect(started).rejects.toThrow('timed out');+ await vi.advanceTimersByTimeAsync(100);+ await result;+ expect(children).toHaveLength(scenario === 'timeout' ? 1 : 3);+ if (scenario === 'recover') {+ await host.request('thread/start');+ children[0].emit('exit', 1, null); children[0].emit('close', 1, null);+ expect(host.hasStarted).toBe(true);+ expect(requests).toEqual([['initialize'], ['initialize'], ['initialize', 'thread/start']]);+ } else expect(requests.every(methods => methods.every(method => method === 'initialize'))).toBe(true);+ await host.retire();+ });+});+describe('close() 强杀兜底 (#3699)', () => {it('SIGTERM 后进程未退出 → 宽限期到点补 SIGKILL(卡死 app-server 不再活体泄漏)', async () => {vi.useFakeTimers();diff --git a/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts b/packages/maker-core/src/agents/codex/app-server/stdioTransport.tsindex 7d967a1871..9f714a77b8 100644--- a/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts+++ b/packages/maker-core/src/agents/codex/app-server/stdioTransport.ts@@ -5,7 +5,7 @@* - 构造时同步 spawn 子进程 (跟原版 spawnProcess 一致)* - readline on('line') → fan-out 给 onLine handlers* - stderr → 整行 normalize 后 fan-out 给 onStderr handlers- * - child.on('exit') 或我们调 close() → 触发 onClose, 之后 writeLine 都 reject+ * - child.on('close')(输出已排空)或我们调 close() → 触发 onClose, 之后 writeLine 都 reject*/import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';@@ -34,12 +34,15 @@ export interface StdioTransportOptions {forceKillGraceMs?: number;/** SIGKILL 后确认退出的时间;仅测试注入。 */killConfirmationMs?: number;+ /** 自然退出后等待 stdio 排空的上限;仅测试注入。 */+ outputDrainMs?: number;}// 合计 3s,给 Desktop 6s 退出预算中的其它收尾留出时间。const GRACEFUL_CLOSE_MS = 1_500;const FORCE_KILL_GRACE_MS = 1_000;const KILL_CONFIRMATION_MS = 500;+const OUTPUT_DRAIN_MS = 1_000;export function createStdioTransport(opts: StdioTransportOptions): Transport {if (!opts.binaryPath) {@@ -60,6 +63,13 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {let closed = false;let closePromise: Promise<void> | null = null;let exited = false;+ let sawStdout = false;+ let exitCode: number | null = null;+ let exitSignal: NodeJS.Signals | null = null;+ let outputFinalized = false;+ let drainTimer: ReturnType<typeof setTimeout> | undefined;+ let sqliteInitializationError = false;+ let nativeSqliteInitializationFailed = false;let resolveExit!: () => void;const exitPromise = new Promise<void>((resolve) => { resolveExit = resolve; });@@ -89,6 +99,7 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {// stdout NDJSON 增量解析: readline 处理 \r\n / \n / EOF, 单行触发 callback。child.stdout.setEncoding('utf8');+ child.stdout.on('data', () => { sawStdout = true; });const rl: Interface = createInterface({input: child.stdout,crlfDelay: Infinity,@@ -103,20 +114,26 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {for (const cb of lineHandlers) cb(line);});- // stderr 当诊断信息流, 不参与协议。按行 fan-out, client 层做 ANSI 剥除/分级。+ // stderr 不参与任务/认证协议;仅识别本机原生启动失败,且必须再有自然退出证据。+ // 其它内容仍按诊断行 fan-out,client 层做 ANSI 剥除/分级。child.stderr.setEncoding('utf8');let stderrBuffer = '';+ const emitStderrLine = (line: string): void => {+ const trimmed = line.replace(/\r$/, '');+ if (!trimmed) return;+ // Exact pre-protocol fatal in the pinned native runtime, not a generic SQL log.+ const match = /^Error: failed to initialize sqlite state runtime under (.+): failed to initialize state runtime at (.+)$/.exec(trimmed);+ if (match && match[1] === match[2]) sqliteInitializationError = true;+ for (const cb of stderrHandlers) cb(trimmed);+ };child.stderr.on('data', (chunk: string) => {+ if (outputFinalized) return;stderrBuffer += chunk;const idx = stderrBuffer.lastIndexOf('\n');if (idx === -1) return;const lines = stderrBuffer.slice(0, idx).split('\n');stderrBuffer = stderrBuffer.slice(idx + 1);- for (const line of lines) {- const trimmed = line.replace(/\r$/, '');- if (!trimmed) continue;- for (const cb of stderrHandlers) cb(trimmed);- }+ for (const line of lines) emitStderrLine(line);});const fireClose = (reason: string): void => {@@ -128,27 +145,54 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {}};- const finishProcess = (reason: string): void => {+ const finishOutput = (reason: string, drained: boolean): void => {+ if (outputFinalized) return;+ outputFinalized = true;+ if (drainTimer) clearTimeout(drainTimer);+ if (drained) emitStderrLine(stderrBuffer);+ stderrBuffer = '';+ nativeSqliteInitializationFailed = drained && exited && exitCode === 1 && exitSignal === null+ && !closed && !sawStdout && sqliteInitializationError;+ try { rl.close(); } catch { /* already closed */ }+ fireClose(reason);+ };++ // Physical exit is independent of pipe drainage (including inherited pipes).+ // Strict close uses only this proof; retry classification needs both proofs.+ const confirmExit = (): void => {if (exited) return;exited = true;- try { rl.close(); } catch { /* already closed */ }try { disposeProcessRegistration?.(); } catch { /* best-effort diagnostic cleanup */ }disposeProcessRegistration = undefined;resolveExit();- fireClose(reason);};+ const exitReason = () => `child exited (${exitSignal ? `signal=${exitSignal}` : `exit code=${exitCode ?? 'null'}`})`;child.on('error', (err) => {const reason = `child error: ${err.message}`;- // spawn 失败没有进程;运行中的 error(例如 kill 失败)不是退出证据。- if (child.pid == null) finishProcess(reason);- else fireClose(reason);+ // spawn failure has no process; a running process error is not exit proof.+ if (child.pid == null) {+ confirmExit();+ finishOutput(reason, false);+ } else fireClose(reason);+ });+ child.stdin.on('error', (err) => {+ if (!exited) fireClose(`child stdin error: ${err.message}`);});- child.stdin.on('error', (err) => fireClose(`child stdin error: ${err.message}`));child.on('exit', (code, signal) => {- const reason = signal ? `signal=${signal}` : `exit code=${code ?? 'null'}`;- finishProcess(`child exited (${reason})`);+ if (exited) return;+ exitCode = code;+ exitSignal = signal;+ confirmExit();+ if (closed) finishOutput(exitReason(), false);+ else {+ // An inherited pipe must not leave initialize pending forever. A drain+ // deadline cannot prove complete output, so it never qualifies for retry.+ drainTimer = setTimeout(() => finishOutput(`${exitReason()}; output drain timed out`, false), opts.outputDrainMs ?? OUTPUT_DRAIN_MS);+ drainTimer.unref?.();+ }});+ child.on('close', () => finishOutput(exitReason(), true));const waitForExit = async (timeoutMs: number): Promise<boolean> => {if (exited) return true;@@ -165,8 +209,9 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {};return {+ nativeSqliteInitializationFailed: () => nativeSqliteInitializationFailed,writeLine(line: string): Promise<void> {- if (closed || !child.stdin.writable) {+ if (closed || exited || !child.stdin.writable) {return Promise.reject(new Error('StdioTransport.writeLine after close'));}return new Promise<void>((resolve, reject) => {@@ -209,7 +254,16 @@ export function createStdioTransport(opts: StdioTransportOptions): Transport {close(reason = 'StdioTransport.close()'): Promise<void> {// 首次严格关闭可以超时;迟到的真实 exit 使后续幂等检查成功。- if (exited) return exitPromise;+ if (exited) {+ // Cancellation during exit → drain must win over late fatal output.+ // Already finalized natural failure retains its proof for strict cleanup.+ if (!closed) {+ nativeSqliteInitializationFailed = false;+ if (!outputFinalized) finishOutput(reason, false);+ else fireClose(reason); // Synchronous cancellation from a final stderr/line callback.+ }+ return exitPromise;+ }if (!closePromise) {// 先发布 Promise,再调用可能同步重入 close() 的监听器。closePromise = Promise.resolve().then(async () => {diff --git a/packages/maker-core/src/agents/codex/app-server/transport.ts b/packages/maker-core/src/agents/codex/app-server/transport.tsindex 8a3fb96cc0..4c14c581e1 100644--- a/packages/maker-core/src/agents/codex/app-server/transport.ts+++ b/packages/maker-core/src/agents/codex/app-server/transport.ts@@ -43,6 +43,8 @@ export type CloseHandler = (info: TransportCloseInfo) => void;* 字节流双向 transport。一个 transport 实例只服务一个 client (1:1)。*/export interface Transport {+ /** Local native SQLite bootstrap failed before any stdout, with a confirmed natural exit. */+ nativeSqliteInitializationFailed?(): boolean;/*** 把一行 NDJSON 异步写到对端。promise resolve 仅表示字节进入了* 操作系统 buffer (或 ws send buffer), 不保证对端收到 / 处理。diff --git a/packages/maker-core/src/agents/codex/index.test.ts b/packages/maker-core/src/agents/codex/index.test.tsindex e89653c2d6..2ddbd20a29 100644--- a/packages/maker-core/src/agents/codex/index.test.ts+++ b/packages/maker-core/src/agents/codex/index.test.ts@@ -13,7 +13,7 @@ import {import { CodexForkError } from './fork-error.js';import { Session } from '../../session.js';import { Method } from './app-server/protocol.js';-import type { ThreadEventHandlers } from './app-server/host.js';+import type { AppServerHost, ThreadEventHandlers } from './app-server/host.js';import {AUTO_REVIEW_SOURCE_CONTENT,INHERITED_CAPABILITY_SELECTION,@@ -47,6 +47,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoisteclass MockCodexTransport {static threadSeq = 1;+ static userAgent = 'mock-codex';static failThreadStart = false;static dropThreadUnsubscribe = false;static dropModelList = false;@@ -69,7 +70,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoisteerror?: { code: number; message: string; data?: unknown };}>();- constructor() {+ constructor(private readonly spawnArgs: string[] = []) {MockCodexTransport.onCreate?.(this);}@@ -88,7 +89,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoistethis.emitLine({id: req.id,result: {- userAgent: 'mock-codex',+ userAgent: MockCodexTransport.userAgent,codexHome: '/tmp/mock-codex-home',platformOs: 'macos',defaultModel: 'gpt-5.4',@@ -188,7 +189,7 @@ const { MockCodexTransport, createdTransports, createdStdioOptions } = vi.hoisteif (req.method === 'config/read') {this.emitLine({id: req.id,- result: { config: { features: { memories: this.memoryEnabled } } },+ result: { config: { cli_auth_credentials_store: this.spawnArgs.includes('cli_auth_credentials_store="ephemeral"') ? "ephemeral" : "file", features: { memories: this.memoryEnabled } } },});return;}@@ -279,13 +280,14 @@ vi.mock('./app-server/stdioTransport.js', () => ({}) => {createdStdioOptions.push(opts);opts.onProcessSpawned?.(7_000 + createdStdioOptions.length);- const transport = new MockCodexTransport();+ const transport = new MockCodexTransport(opts.extraArgs);createdTransports.push(transport);return transport;},}));beforeEach(() => {+ MockCodexTransport.userAgent = 'mock-codex';createdTransports.length = 0;createdStdioOptions.length = 0;MockCodexTransport.threadSeq = 1;@@ -366,6 +368,532 @@ function createDeps(};}+describe('Codex official OAuth host isolation', () => {+ function isolatedDeps() {+ return createDeps({}, {+ resolveCodexLocalAuthPolicy: (providerId) =>+ providerId === 'cprov-test' || providerId === 'xd' ? 'isolated' : 'legacy-shared',+ prepareCodexExtraSpawnConfig: async () => ({+ extraArgs: [], extraEnv: {}, codexProxyActive: true,+ }),+ });+ }++ it.each([false, true])('keeps gateway authentication independent of an OAuth host (oauthFirst=%s)', async (oauthFirst) => {+ const deps = isolatedDeps();+ const authState = vi.fn(async (opts?: { credentialMode?: string }) => ({ authenticated: true, authSource: opts?.credentialMode === 'gateway-key' ? 'api-key' as const : 'oauth' as const }));+ deps.auth.getState = authState;+ const agent = new CodexAgent(deps);+ const start = (providerId: string) => agent.startSession({ sessionId: providerId, providerId, model: 'gpt-5.4', workingDir: '/repo' });+ try {+ const first = await start(oauthFirst ? 'openai' : 'xd');+ const second = await start(oauthFirst ? 'xd' : 'openai');+ const gatewayIndex = oauthFirst ? 1 : 0;+ expect(createdTransports).toHaveLength(2);+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);+ expect(createdStdioOptions[gatewayIndex].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');+ expect(createdStdioOptions[1 - gatewayIndex].extraArgs).not.toContain('cli_auth_credentials_store="ephemeral"');+ expect(authState.mock.calls.every(([opts]) => opts?.credentialMode !== undefined)).toBe(true);+ await agent.forceDisposeLocalHostForAuthChange('expired OAuth', { preserveExternalAuth: true });+ expect(createdTransports[gatewayIndex].closed).toBe(false);+ expect(createdTransports[1 - gatewayIndex].closed).toBe(true);+ await first.close(); await second.close();+ } finally { await agent.dispose(); }+ });++ it.each(['openai', 'cprov-test'])('detects a retained native writer only across hosts from %s', async (providerId) => {+ const agent = new CodexAgent(isolatedDeps());+ try {+ const source = await agent.startSession({ sessionId: 'source', providerId, model: 'gpt-5.4', workingDir: '/repo' });+ const sibling = await agent.startSession({ sessionId: 'unrelated', providerId, model: 'gpt-5.4', workingDir: '/repo' });+ const transport = createdTransports[0];+ transport.setMockResponse('thread/loaded/list', { result: { data: [source.id, sibling.id], nextCursor: null } });+ await source.close();+ const query = { sessionId: 'source', threadId: source.id, model: 'gpt-5.4' };+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId })).toBe(false);+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: providerId === 'openai' ? 'cprov-test' : 'openai' })).toBe(true);+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: 'openai', remoteHostId: 'ssh' })).toBe(false);+ transport.setMockResponse('thread/loaded/list', { result: { data: [sibling.id], nextCursor: null } });+ expect(await agent.requiresCodexThreadHostTransfer({ ...query, providerId: providerId === 'openai' ? 'cprov-test' : 'openai' })).toBe(false);+ expect(transport.closed).toBe(false);+ expect(createdTransports).toHaveLength(1);+ await sibling.close();+ } finally { await agent.dispose(); }+ });++ it.each(['xd', 'cprov-test'])('does not wait for a cold official host while checking %s writers', async (providerId) => {+ const agent = new CodexAgent(isolatedDeps());+ let release!: () => void;+ const gate = new Promise<void>((resolve) => { release = resolve; });+ let official: Promise<AgentSessionHandle> | undefined;+ try {+ const source = await agent.startSession({ sessionId: 'source', providerId, model: 'gpt-5.4', workingDir: '/repo' });+ createdTransports[0].setMockResponse('thread/loaded/list', { result: { data: [source.id], nextCursor: null } });+ MockCodexTransport.beforeInitializeResponse = () => gate;+ official = agent.startSession({ sessionId: 'official', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ await vi.waitFor(() => expect(createdTransports).toHaveLength(2));+ const query = { sessionId: 'source', threadId: source.id, model: 'gpt-5.4' };+ await expect(agent.requiresCodexThreadHostTransfer({ ...query, providerId })).resolves.toBe(false);+ await source.close();+ await expect(agent.requiresCodexThreadHostTransfer({ ...query, providerId: 'openai' })).resolves.toBe(true);+ expect(createdTransports[1].closed).toBe(false);+ expect(createdTransports[1].lines.map(line => JSON.parse(line).method)).toEqual(['initialize']);+ } finally {+ release();+ await official;+ await agent.dispose();+ }+ });++ it.each(['resolve-success', 'resolve-failure', 'list-success', 'list-failure'])('waits for exact writer retirement during %s', async (window) => {+ const deps: AgentDeps = isolatedDeps();+ const agent = new CodexAgent(deps);+ const internals = agent as unknown as {+ hosts: Map<string, AppServerHost>;+ retiringHosts: Map<string, unknown>;+ retireHostKey(key: string, reason: string, opts: { failIfActive: boolean; logPrefix: string }): Promise<void>;+ };+ let releaseQuery = () => {};+ let releaseExit = () => {};+ let rejectExit: (error: Error) => void = () => {};+ const queryGate = new Promise<void>((resolve) => { releaseQuery = resolve; });+ const exitGate = new Promise<void>((resolve, reject) => { releaseExit = resolve; rejectExit = reject; });+ try {+ const source = await agent.startSession({ sessionId: 'source', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ const sibling = await agent.startSession({ sessionId: 'unrelated', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ await source.close();+ const host = internals.hosts.get('local')!;+ const siblingTransport = createdTransports[1];+ let entered = false;+ if (window.startsWith('resolve')) {+ const resolve = deps.resolveCodexLocalAuthPolicy!;+ deps.resolveCodexLocalAuthPolicy = async (...args) => {+ entered = true; await queryGate; return resolve(...args);+ };+ } else {+ const request = host.request.bind(host);+ vi.spyOn(host, 'request').mockImplementation(async (method, params, options) => {+ if (method === 'thread/loaded/list') { entered = true; await queryGate; return { data: [source.id], nextCursor: null }; }+ return request(method, params, options);+ });+ }+ const retire = host.retire.bind(host);+ const retirementSpy = vi.spyOn(host, 'retire').mockImplementation(async (...args) => { await exitGate; return retire(...args); });+ const decision = agent.requiresCodexThreadHostTransfer({ sessionId: 'source', threadId: source.id, providerId: 'cprov-test', model: 'gpt-5.4' });+ let settled = false;+ void decision.then(() => { settled = true; }, () => { settled = true; });+ await vi.waitFor(() => expect(entered).toBe(true));+ const retirement = internals.retireHostKey('local', 'test writer race', { failIfActive: false, logPrefix: 'test' });+ await vi.waitFor(() => expect(retirementSpy).toHaveBeenCalled());+ expect(internals.hosts.has('local')).toBe(false);+ if (window.endsWith('failure')) {+ rejectExit(new Error('writer exit failed'));+ await retirement;+ // Even removal of the current registry entry cannot erase the exact host's failure.+ internals.retiringHosts.delete('local');+ releaseQuery();+ await expect(decision).rejects.toThrow('writer exit failed');+ } else {+ releaseQuery();+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(settled).toBe(false);+ releaseExit();+ await retirement;+ await expect(decision).resolves.toBe(false);+ }+ expect(siblingTransport.closed).toBe(false);+ retirementSpy.mockRestore();+ await retire('test cleanup');+ await sibling.close();+ } finally { releaseQuery(); releaseExit(); await agent.dispose(); }+ });++ it('keeps external credentials and subscription hosts alive concurrently', async () => {+ const agent = new CodexAgent(isolatedDeps());+ try {+ const [official, external] = await Promise.all([+ agent.startSession({ sessionId: 'official', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' }),+ agent.startSession({ sessionId: 'external', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' }),+ ]);+ expect(createdTransports).toHaveLength(2);+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);+ expect(createdStdioOptions.filter((options) =>+ options.extraArgs?.includes('cli_auth_credentials_store="ephemeral"'),+ )).toHaveLength(1);+ await agent.startSession({ sessionId: 'external-again', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdTransports).toHaveLength(2);+ await official.close();+ expect(createdTransports.every((transport) => !transport.closed)).toBe(true);+ await external.close();+ } finally {+ await agent.dispose();+ }+ });++ it.each(['openai', 'cprov-test'])('rebuilds a changed routing signature without retiring the sibling of %s', async (providerId) => {+ let signature = 'initial';+ const deps = isolatedDeps();+ deps.prepareCodexExtraSpawnConfig = async () => ({ extraArgs: [], extraEnv: {}, codexProxyActive: true, codexSubagentRoutingSignature: signature });+ deps.resolveCodexSubagentRoutingSignature = async () => signature;+ const coordinate = vi.fn(async () => {});+ deps.prepareCodexLocalCredentialModeSwitch = coordinate;+ const agent = new CodexAgent(deps);+ try {+ const target = await agent.startSession({ sessionId: 'target-signature', providerId, model: 'gpt-5.4', workingDir: '/repo' });+ const sibling = await agent.startSession({ sessionId: 'sibling-signature', providerId: providerId === 'openai' ? 'cprov-test' : 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ const siblingTransport = createdTransports[1];+ await target.close();+ signature = 'changed';+ const replacement = await agent.startSession({ sessionId: 'replacement-signature', providerId, model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdTransports[0].closed).toBe(true);+ expect(siblingTransport.closed).toBe(false);+ expect(createdTransports).toHaveLength(3);+ if (coordinate.mock.calls.length) expect(coordinate).toHaveBeenCalledWith(expect.objectContaining({ hostKey: target.codexHostKey }));+ await sibling.close();+ await replacement.close();+ } finally { await agent.dispose(); }+ });++ it('re-evaluates provider switches and resumes on the isolated host', async () => {+ const agent = new CodexAgent(isolatedDeps());+ try {+ const handle = await agent.startSession({ sessionId: 'switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'openai' })).toBe(true);+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(false);+ const resumed = await agent.startSession({ sessionId: 'resumed', resumeSessionId: '11111111-1111-4111-8111-111111111111', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdTransports).toHaveLength(1);+ await resumed.send({ type: 'user', content: 'resume' });+ expect(createdTransports[0].lines.some((line) => JSON.parse(line).method === 'thread/resume')).toBe(true);+ await resumed.close();+ await handle.close();+ await agent.forceDisposeLocalHostForAuthChange();+ expect(createdTransports[0].closed).toBe(true);+ } finally {+ await agent.dispose();+ }+ });++ it.each(['isolated', 'legacy-shared'] as const)('rebuilds when the actual route policy changes from %s without changing model identity', async (initialPolicy) => {+ const deps = isolatedDeps();+ let policy: 'isolated' | 'legacy-shared' = initialPolicy;+ deps.resolveCodexLocalAuthPolicy = () => policy;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'policy-switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(false);+ policy = initialPolicy === 'isolated' ? 'legacy-shared' : 'isolated';+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'cprov-test' })).toBe(true);+ await handle.close();+ } finally {+ await agent.dispose();+ }+ });++ it('normalizes an absent policy callback to legacy compatibility without a false rebuild', async () => {+ const deps = isolatedDeps();+ delete deps.resolveCodexLocalAuthPolicy;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'legacy-policy', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ deps.resolveCodexLocalAuthPolicy = () => 'legacy-shared';+ expect(await handle.requiresModelSwitchRebuild?.('gpt-5.4', { providerId: 'openai' })).toBe(false);+ await handle.close();+ } finally {+ await agent.dispose();+ }+ });++ it('retires only the failing external host without invalidating shared OAuth', async () => {+ const deps = isolatedDeps();+ const invalidate = vi.fn(async () => undefined);+ deps.auth.invalidate = invalidate;+ const agent = new CodexAgent(deps);+ try {+ const official = await agent.startSession({ sessionId: 'official-survivor', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ const external = await agent.startSession({ sessionId: 'external-failure', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ createdTransports[1].setMockResponse(Method.TurnStart, { error: {+ code: -32000, message: 'OAuth refresh token was already used',+ data: { reason: 'cloudRequirements', errorCode: 'Auth' },+ } });+ await expect(external.send({ type: 'user', content: 'fail' }, { throwOnStartFailure: true })).rejects.toThrow(/refresh token/);+ await waitForExpectation(() => expect(createdTransports[1].closed).toBe(true));+ expect(invalidate).not.toHaveBeenCalled();+ expect(createdTransports[0].closed).toBe(false);+ await official.send({ type: 'user', content: 'still available' });+ await external.close();+ await official.close();+ } finally {+ await agent.dispose();+ }+ });++ it('uses host-injected credentials for an inferred custom route without gateway or OAuth login', async () => {+ const deps = isolatedDeps();+ deps.resolveCodexLocalAuthPolicy = () => 'isolated';+ const getState = vi.fn<AuthAdapter['getState']>(async (options) => ({ authenticated: options?.credentialMode === 'provider-oauth' }));+ deps.auth.getState = getState;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'inferred', model: 'custom-model', workingDir: '/repo' });+ expect(getState.mock.calls.every(([options]) => options?.credentialMode === 'provider-oauth')).toBe(true);+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');+ await handle.close();+ } finally {+ await agent.dispose();+ }+ });++ it('preserves external hosts on OAuth invalidation and retires both under an explicit credential change', async () => {+ const agent = new CodexAgent(isolatedDeps());+ try {+ await agent.startSession({ sessionId: 'official-boundary', providerId: 'openai', model: 'gpt-5.4', workingDir: '/repo' });+ await agent.startSession({ sessionId: 'external-boundary', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ await agent.forceDisposeLocalHostForAuthChange('revoked OAuth', { preserveExternalAuth: true });+ expect(createdTransports[0].closed).toBe(true);+ expect(createdTransports[1].closed).toBe(false);+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });+ try {+ await guard.retireActiveHost();+ expect(createdTransports[1].closed).toBe(true);+ await guard.finalize();+ } finally {+ guard.release();+ }+ await agent.startSession({ sessionId: 'external-new-generation', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdTransports).toHaveLength(3);+ expect(createdStdioOptions[2].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');+ } finally {+ await agent.dispose();+ }+ });++ it('preserves custom-context ownership and cleanup on external hosts', async () => {+ const deps = isolatedDeps();+ deps.resolveCodexThreadContextWindow = () => 700_000;+ const onHostRetired = vi.fn(async () => undefined);+ const prepare = vi.fn<NonNullable<typeof deps.prepareCodexExtraSpawnConfig>>(async () => ({+ extraArgs: [], extraEnv: {}, codexProxyActive: true, onHostRetired,+ }));+ deps.prepareCodexExtraSpawnConfig = prepare;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'external-context', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(prepare).toHaveBeenCalledWith([], expect.objectContaining({+ hostPurpose: 'custom-context', localAuthPolicy: 'isolated',+ hostScopeKey: 'local-custom-context:external-context:external-auth:1',+ }));+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');+ await handle.close();+ expect(createdTransports[0].closed).toBe(true);+ expect(onHostRetired).toHaveBeenCalledOnce();+ } finally {+ await agent.dispose();+ }+ });++ it.each([false, true])('retires scoped snapshots and blocks new hosts during configuration persistence (review=%s)', async (reviewMode) => {+ if (reviewMode) MockCodexTransport.userAgent = 'mock-codex/0.145.0';+ if (reviewMode) MockCodexTransport.onCreate = (transport) => transport.setMockResponse('config/read', { result: { config: { cli_auth_credentials_store: 'ephemeral', mcp_servers: { node_repl: { command: 'synthetic-node-repl' } } } } });+ const workingDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-scope-change-'));+ const deps = isolatedDeps();+ deps.resolveCodexThreadContextWindow = () => 700_000;+ const agent = new CodexAgent(deps);+ try {+ await agent.startSession({ sessionId: 'old-config', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });+ try {+ await guard.retireActiveHost();+ expect(createdTransports[0].closed).toBe(true);+ const pending = agent.startSession({ sessionId: 'new-config', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });+ let completed = false;+ void pending.then(() => { completed = true; });+ await new Promise((resolve) => setTimeout(resolve, 20));+ expect(completed).toBe(false);+ expect(createdTransports).toHaveLength(1);+ await guard.finalize();+ const handle = await pending;+ expect(createdTransports).toHaveLength(2);+ expect(handle.codexHostKey).toBe(reviewMode ? 'local-review:new-config:external-auth' : 'local-custom-context:new-config:external-auth');+ await handle.close();+ } finally {+ guard.release();+ }+ } finally {+ await agent.dispose();+ await fs.rm(workingDir, { recursive: true, force: true });+ }+ });++ it.each([false, true])('supersedes an in-flight scoped creation at the configuration boundary (review=%s)', async (reviewMode) => {+ MockCodexTransport.userAgent = 'mock-codex/0.145.0';+ if (reviewMode) MockCodexTransport.onCreate = (transport) => transport.setMockResponse('config/read', { result: { config: { cli_auth_credentials_store: 'ephemeral', mcp_servers: { node_repl: { command: 'synthetic-node-repl' } } } } });+ const workingDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cindy-scope-inflight-'));+ const deps = isolatedDeps();+ deps.resolveCodexThreadContextWindow = () => 700_000;+ const agent = new CodexAgent(deps);+ let entered!: () => void;+ let resume!: () => void;+ const started = new Promise<void>((resolve) => { entered = resolve; });+ const paused = new Promise<void>((resolve) => { resume = resolve; });+ MockCodexTransport.beforeInitializeResponse = async () => { entered(); await paused; };+ try {+ const pending = agent.startSession({ sessionId: 'creating-scope', ...(reviewMode ? { reviewMode: true as const } : {}), providerId: 'cprov-test', model: 'gpt-5.4', workingDir });+ await started;+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });+ try {+ const retired = guard.retireActiveHost();+ resume();+ await retired;+ await guard.finalize();+ } finally { guard.release(); }+ MockCodexTransport.beforeInitializeResponse = null;+ const replacement = await pending;+ expect(createdTransports[0].lines.some((line) => JSON.parse(line).method === Method.ThreadStart)).toBe(false);+ expect(createdTransports[0].closed).toBe(true);+ expect(createdTransports.at(-1)?.closed).toBe(false);+ await replacement.close();+ } finally {+ resume();+ await agent.dispose();+ await fs.rm(workingDir, { recursive: true, force: true });+ }+ });++ it('does not replay an accepted thread start when the route changes before its response', async () => {+ const deps = isolatedDeps();+ let revision = 0;+ deps.resolveCodexLocalAuthPolicy = () => { const captured = revision; return { policy: 'isolated', isCurrent: () => captured === revision }; };+ MockCodexTransport.beforeThreadStartResponse = () => { revision++; };+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'accepted-once', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdTransports).toHaveLength(1);+ expect(createdTransports[0].lines.filter((line) => JSON.parse(line).method === Method.ThreadStart)).toHaveLength(1);+ await handle.close();+ } finally { await agent.dispose(); }+ });++ it('reselects after a route mutation during spawn preparation without allocating a stale transport', async () => {+ const deps = isolatedDeps();+ let revision = 0;+ deps.resolveCodexLocalAuthPolicy = () => {+ const captured = revision;+ return { policy: revision === 0 ? 'legacy-shared' : 'isolated', isCurrent: () => captured === revision };+ };+ const retired = vi.fn();+ const prepare = vi.fn(async () => {+ revision = 1;+ return { extraArgs: [], extraEnv: {}, codexProxyActive: true, onHostRetired: retired };+ });+ deps.prepareCodexExtraSpawnConfig = prepare;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'reselect', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ expect(handle.codexHostKey).toBe('local:external-auth');+ expect(prepare).toHaveBeenCalledTimes(2);+ expect(retired).toHaveBeenCalledOnce();+ expect(createdTransports).toHaveLength(1);+ expect(createdStdioOptions[0].extraArgs).toContain('cli_auth_credentials_store="ephemeral"');+ expect(createdTransports[0].lines.filter((line) => JSON.parse(line).method === 'thread/start')).toHaveLength(1);+ await handle.close();+ } finally { await agent.dispose(); }+ });++ it('waits for a stable route before comparing temporary context catalog omissions', async () => {+ const deps = isolatedDeps();+ let pending = false;+ let release!: () => void;+ const barrier = new Promise<void>((resolve) => { release = resolve; });+ deps.resolveCodexLocalAuthPolicy = async () => { if (pending) await barrier; return 'isolated' as const; };+ const resolveWindow = vi.fn(() => pending ? null : 700_000);+ deps.resolveCodexThreadContextWindow = resolveWindow;+ const agent = new CodexAgent(deps);+ try {+ const handle = await agent.startSession({ sessionId: 'context-switch', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ pending = true;+ resolveWindow.mockClear();+ const switching = handle.requiresModelSwitchRebuild!('gpt-5.4', { providerId: 'cprov-test' });+ await new Promise((resolve) => setTimeout(resolve, 10));+ expect(resolveWindow).not.toHaveBeenCalled();+ pending = false;+ release();+ expect(await switching).toBe(false);+ expect(createdTransports).toHaveLength(1);+ expect(createdTransports[0].closed).toBe(false);+ await handle.close();+ } finally { release(); await agent.dispose(); }+ });++ it('cancels a startup waiting for the configuration barrier without reserving a host', async () => {+ const agent = new CodexAgent(isolatedDeps());+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });+ try {+ const pending = agent.startSession({ sessionId: 'cancelled-barrier', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ const rejection = expect(pending).rejects.toThrow(/cancelled/);+ await new Promise((resolve) => setTimeout(resolve, 10));+ await agent.dispose();+ await rejection;+ expect(createdTransports).toHaveLength(0);+ } finally { guard.release(); await agent.dispose(); }+ });++ it('reselects a route after a configuration change before sending a thread RPC', async () => {+ const deps = isolatedDeps();+ let releaseResolution!: () => void;+ const resolving = new Promise<void>((resolve) => { releaseResolution = resolve; });+ const resolveDependency = vi.fn(async () => { await resolving; return 'isolated' as const; });+ deps.resolveCodexLocalAuthPolicy = resolveDependency;+ const agent = new CodexAgent(deps);+ try {+ const pending = agent.startSession({ sessionId: 'stale-policy', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' });+ await waitForExpectation(() => expect(resolveDependency).toHaveBeenCalledOnce());+ const guard = await agent.beginLocalHostCredentialChange('provider snapshot changed', { allLocalHosts: true, forceRetire: true });+ await guard.finalize();+ releaseResolution();+ const handle = await pending;+ expect(resolveDependency).toHaveBeenCalledTimes(2);+ expect(createdTransports).toHaveLength(1);+ await handle.close();+ } finally {+ releaseResolution();+ await agent.dispose();+ }+ });++ it('does not let spawn preparation upgrade an external route back to disk OAuth', async () => {+ const deps = isolatedDeps();+ const retired = vi.fn(async () => undefined);+ const prepare = vi.fn<NonNullable<typeof deps.prepareCodexExtraSpawnConfig>>(async () => ({+ extraArgs: [], extraEnv: {}, requiredSpawnCredentialMode: 'oauth-bearer', onHostRetired: retired,+ }));+ deps.prepareCodexExtraSpawnConfig = prepare;+ const agent = new CodexAgent(deps);+ try {+ await expect(agent.startSession({ sessionId: 'conflicting-spawn', providerId: 'cprov-test', model: 'gpt-5.4', workingDir: '/repo' })).rejects.toThrow('requires official OAuth');+ expect(prepare).toHaveBeenCalledOnce();+ expect(retired).toHaveBeenCalledOnce();+ expect(createdTransports).toHaveLength(0);+ } finally {+ await agent.dispose();+ }+ });++ it('does not infer isolated storage from an unrelated custom route catalog', async () => {+ const agent = new CodexAgent(createDeps({}, {+ prepareCodexExtraSpawnConfig: async () => ({+ extraArgs: [], extraEnv: {}, codexProxyActive: true,+ codexCustomProviderRoutes: [{ providerId: 'cprov-unrelated', modelProviderId: 'custom', capabilities: {}, responseModels: ['gpt-5.4'] }],+ }),+ }));+ try {+ await agent.startSession({ sessionId: 'legacy', model: 'gpt-5.4', workingDir: '/repo' });+ expect(createdStdioOptions[0]?.extraArgs).not.toContain('cli_auth_credentials_store="ephemeral"');+ } finally {+ await agent.dispose();+ }+ });+});+describe('CodexAgent spawn configuration', () => {it('holds account session recovery until the MCP bridge replacement is ready', async () => {let endpoint = 'http://127.0.0.1:51359/mcp/cindy_scheduler';@@ -2050,11 +2578,11 @@ describe('CodexAgent capability routing', () => {const hosts = (agent as unknown as { hosts: Map<string, unknown> }).hosts;let displacedHost: unknown;MockCodexTransport.beforeSkillsListResponse = () => {- displacedHost = hosts.get('local-control:provider-oauth');+ displacedHost = hosts.get('local-control:provider-oauth:external-auth');const sessionHost = hosts.get('local');expect(displacedHost).toBeDefined();expect(sessionHost).toBeDefined();- hosts.set('local-control:provider-oauth', sessionHost);+ hosts.set('local-control:provider-oauth:external-auth', sessionHost);};await expect(agent.startSession({@@ -2066,7 +2594,7 @@ describe('CodexAgent capability routing', () => {'Codex Skill discovery expired because its control-plane app-server was replaced',);- if (displacedHost) hosts.set('local-control:provider-oauth', displacedHost);+ if (displacedHost) hosts.set('local-control:provider-oauth:external-auth', displacedHost);await agent.dispose();});@@ -8837,6 +9365,7 @@ describe('CodexAgent MCP thread context hooks', () => {})).rejects.toThrow(/still attached/i);expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({+ hostKey: 'local',fromMode: 'oauth-bearer',fromModeEffective: 'oauth-bearer',toMode: 'oauth-bearer',@@ -9022,6 +9551,7 @@ describe('CodexAgent MCP thread context hooks', () => {});expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({+ hostKey: 'local',fromMode: 'gateway-key',fromModeEffective: 'gateway-key',toMode: 'oauth-bearer',@@ -9065,6 +9595,7 @@ describe('CodexAgent MCP thread context hooks', () => {});expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({+ hostKey: 'local',fromMode: 'gateway-key',fromModeEffective: 'gateway-key',toMode: 'oauth-bearer',@@ -9176,6 +9707,7 @@ describe('CodexAgent MCP thread context hooks', () => {await expect(oauthStart).rejects.toThrow(/still attached/i);expect(prepareCodexLocalCredentialModeSwitch).toHaveBeenCalledWith({+ hostKey: 'local',fromMode: 'gateway-key',fromModeEffective: 'gateway-key',toMode: 'oauth-bearer',@@ -24036,7 +24568,7 @@ describe('CodexAgent.forkSdkSession', () => {})).resolves.toMatchObject({ newSdkSessionId: 'child', usedNativeForkAnchor: true });expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({path: '/account-a/sessions/source.jsonl', lastTurnId: 'boundary',- }));+ }), expect.objectContaining({ beforeDispatch: expect.any(Function) }));expect(recordCodexThreadLocation).toHaveBeenCalledWith('child', '/account-a', '/account-a/sessions/child.jsonl');});@@ -24057,7 +24589,7 @@ describe('CodexAgent.forkSdkSession', () => {})).resolves.toMatchObject({ newSdkSessionId: 'fork-thread-id', usedNativeForkAnchor: true });expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, {threadId: 'source', lastTurnId: 'failed-boundary', excludeTurns: true,- });+ }, { beforeDispatch: expect.any(Function) });expect(host.request).not.toHaveBeenCalledWith(Method.ThreadRollback, expect.anything());expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');});@@ -24205,6 +24737,8 @@ describe('CodexAgent.forkSdkSession', () => {expect(host.getHost).toHaveBeenCalledWith(undefined, undefined, {keyOverride: expect.stringMatching(/^local-fork:/),+ routeIsCurrent: expect.any(Function),+ routeSignal: expect.any(AbortSignal),hostPurpose: 'control-plane',});expect(prepareCodexResumeSession).toHaveBeenCalledWith('source-thread-id');@@ -24214,7 +24748,7 @@ describe('CodexAgent.forkSdkSession', () => {lastTurnId: 'turn-at-boundary',excludeTurns: true,cwd: '/repo',- });+ }, { beforeDispatch: expect.any(Function) });expect(host.request).not.toHaveBeenCalledWith(Method.ThreadRollback, expect.anything());expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');expect(retireHostKey).toHaveBeenCalledExactlyOnceWith(@@ -24250,7 +24784,7 @@ describe('CodexAgent.forkSdkSession', () => {threadId: 'imported-source-thread',lastTurnId: 'turn-at-boundary',excludeTurns: true,- });+ }, { beforeDispatch: expect.any(Function) });});it('uses the isolated rollback fallback when bounded native-turn fork is unavailable', async () => {@@ -24267,7 +24801,7 @@ describe('CodexAgent.forkSdkSession', () => {expect(host.request).toHaveBeenNthCalledWith(1, Method.ThreadFork, {threadId: 'source-thread-id',persistExtendedHistory: true,- });+ }, { beforeDispatch: expect.any(Function) });expect(host.request).toHaveBeenNthCalledWith(2, Method.ThreadRollback, {threadId: 'fork-thread-id',numTurns: 1,@@ -24382,7 +24916,7 @@ describe('CodexAgent.forkSdkSession', () => {expect(order).toEqual(['prepare', 'fork']);expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({threadId: 'imported-source-thread',- }));+ }), { beforeDispatch: expect.any(Function) });});it('does not call thread/fork when source-thread preparation fails', async () => {@@ -24418,7 +24952,7 @@ describe('CodexAgent.forkSdkSession', () => {threadId: 'source-thread-id',persistExtendedHistory: true,cwd: '/repo',- });+ }, { beforeDispatch: expect.any(Function) });expect(host.request).toHaveBeenNthCalledWith(2, Method.ThreadRollback, {threadId: 'fork-thread-id',numTurns: 2,@@ -24445,7 +24979,7 @@ describe('CodexAgent.forkSdkSession', () => {expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, {threadId: 'source-thread-id',persistExtendedHistory: true,- });+ }, { beforeDispatch: expect.any(Function) });expect(host.unsubscribeThread).toHaveBeenCalledTimes(1);expect(host.unsubscribeThread).toHaveBeenCalledWith('fork-thread-id');expect(host.unsubscribeThread).not.toHaveBeenCalledWith('source-thread-id');@@ -24540,7 +25074,7 @@ describe('CodexAgent.forkSdkSession', () => {threadId: 'source-thread-id',persistExtendedHistory: true,excludeTurns: true,- });+ }, { beforeDispatch: expect.any(Function) });});it('omits excludeTurns for daemons older than 0.145.0', async () => {@@ -24582,7 +25116,7 @@ describe('CodexAgent.forkSdkSession', () => {);expect(host.request).toHaveBeenCalledWith(Method.ThreadFork, expect.objectContaining({threadId: 'source-thread-id',- }));+ }), { beforeDispatch: expect.any(Function) });});it('inspects indexed source history without requiring the outgoing provider credentials', async () => {@@ -24698,7 +25232,7 @@ describe('CodexAgent.forkSdkSession', () => {expect(host.request).toHaveBeenCalledWith(Method.ThreadFork,expect.objectContaining({ path: sourceRollout }),- );+ { beforeDispatch: expect.any(Function) });} finally {await fs.rm(externalHome, { recursive: true, force: true });}@@ -33881,7 +34415,7 @@ describe('CodexAgent custom provider context window override', () => {expect(host.getHost).toHaveBeenCalledWith(undefined,'provider-oauth',- { ignoreBindingLeases: 1 },+ { ignoreBindingLeases: 1, routeIsCurrent: expect.any(Function), routeSignal: expect.any(AbortSignal) },);await handle.close();});diff --git a/packages/maker-core/src/agents/codex/index.ts b/packages/maker-core/src/agents/codex/index.tsindex 4793fe7cbc..d9e6827975 100644--- a/packages/maker-core/src/agents/codex/index.ts+++ b/packages/maker-core/src/agents/codex/index.ts@@ -194,7 +194,7 @@ import { CodexForkError, type CodexForkStage } from './fork-error.js';import { resolveForkTurnAnchor } from './fork-turn-anchor.js';import { parseReconnectAttemptMessage } from '../shared/network-error.js';import { extractNonSecretErrorSignals } from '@cindy/maker-shared/error-redaction';-import { AppServerHost, type ThreadEventHandlers, type ThreadSubscription } from './app-server/host.js';+import { AppServerHost, CodexNativeInitializationStoppedError, type ThreadEventHandlers, type ThreadSubscription } from './app-server/host.js';import { AppServerRequestTimeoutError } from './app-server/client.js';import { useCodexHistoryHome, type CodexExternalAuth } from './app-server/external-auth.js';import {@@ -496,9 +496,52 @@ export function hostKey(remoteHostId?: string | null): string {return remoteHostId ? `remote:${remoteHostId}` : 'local';}+/** Preserve legacy identities unless the concrete route excludes official OAuth. */+export function codexLocalAuthHostIdentity(key: string, policy?: 'isolated' | 'legacy-shared'): string {+ return policy === 'isolated' ? `${key}:external-auth` : key;+}++/** One identity calculation for initial creation, route reselection and writer handoff. */+function localSessionHostIdentity(input: {+ sessionId: string;+ remoteHostId?: string;+ accountSessionHost: boolean;+ accountProviderId?: string;+ reviewMode: boolean;+ customContext: boolean;+ storage?: { sqliteHome: string; historyHome: string };+ policy: 'isolated' | 'legacy-shared';+}): string {+ const base = input.accountSessionHost+ ? `local-account:${input.accountProviderId ?? 'openai'}:session:${input.sessionId}`+ : input.reviewMode ? localReviewHostKey(input.sessionId)+ : input.customContext ? localCustomContextHostKey(input.sessionId) : hostKey(input.remoteHostId);+ return codexLocalAuthHostIdentity(base + (input.storage+ ? `:storage:${input.storage.sqliteHome}:history:${input.storage.historyHome}` : ''), input.policy);+}+const LOCAL_CONTROL_PLANE_HOST_PREFIX = 'local-control:';// One bridge is shared by every local host, including account and utility hosts.const LOCAL_MCP_REFRESH_KEY = 'local-mcp-refresh';+const LOCAL_CONFIGURATION_CHANGE_KEY = LOCAL_MCP_REFRESH_KEY;+// Only raised before a caller sends a thread RPC; safe to select a fresh route.+class CodexRouteSelectionChangedError extends Error {+ constructor(message = 'Codex route changed during startup', readonly retryable = true) { super(message); }+}++async function awaitCodexRouteSelection<T>(pending: Promise<T>, signal?: AbortSignal): Promise<T> {+ if (!signal) return pending;+ signal.throwIfAborted();+ return new Promise<T>((resolve, reject) => {+ const abort = () => {+ signal.removeEventListener('abort', abort);+ reject(signal.reason);+ };+ signal.addEventListener('abort', abort, { once: true });+ void pending.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));+ });+}+const CODEX_MODEL_LIST_RPC_TIMEOUT_MS = 20_000;const CODEX_MODEL_REFRESH_DEADLINE_MS = 20_000;@@ -1967,6 +2010,8 @@ export class CodexAgent extends BaseAgent {generation: number;promise: Promise<void> | null;}>();+ // Keep exact-process exit evidence even after its reusable registry entry is gone.+ private hostRetirementResults = new WeakMap<AppServerHost, Promise<void>>();/*** app-server 启动时返回的 $CODEX_HOME 绝对路径 (InitializeResponse.codexHome)。@@ -2228,10 +2273,11 @@ export class CodexAgent extends BaseAgent {}}- private async waitForHostCredentialModeSwitch(key: string): Promise<void> {+ private async waitForHostCredentialModeSwitch(key: string, skipConfigurationGuard = false): Promise<void> {while (true) {- const switching = this.hostCredentialModeSwitches.get(LOCAL_MCP_REFRESH_KEY)- ?? this.hostCredentialModeSwitches.get(key);+ const switching = (!skipConfigurationGuard && !key.startsWith('remote:')+ ? this.hostCredentialModeSwitches.get(LOCAL_CONFIGURATION_CHANGE_KEY)+ : undefined) ?? this.hostCredentialModeSwitches.get(key);if (!switching) return;await switching.catch(() => undefined);}@@ -2239,7 +2285,7 @@ export class CodexAgent extends BaseAgent {async beginLocalHostCredentialChange(reason = 'CodexAgent local credential state changed',- options: { allLocalHosts?: boolean; busyError?: () => Error } = {},+ options: { allLocalHosts?: boolean; forceRetire?: boolean; busyError?: () => Error } = {},): Promise<{assertIdle(): void;retireActiveHost(): Promise<void>;@@ -2257,6 +2303,7 @@ export class CodexAgent extends BaseAgent {if (pending.length === 0) break;await Promise.allSettled(pending);}+ this.bumpHostGeneration(LOCAL_CONFIGURATION_CHANGE_KEY);let releaseSwitch!: () => void;const switchPromise = new Promise<void>((resolve) => {@@ -2291,7 +2338,7 @@ export class CodexAgent extends BaseAgent {const retire = async (): Promise<void> => {for (const candidate of affectedKeys()) {await this.retireHostKey(candidate, reason, {- failIfActive: options.allLocalHosts === true,+ failIfActive: options.allLocalHosts === true && options.forceRetire !== true,logPrefix: 'codex local credential hard cut',throwOnShutdownFailure: true,});@@ -2317,7 +2364,7 @@ export class CodexAgent extends BaseAgent {try {if (!hostRetired) {if (options.allLocalHosts) {- if (activeUseCount() > 0) throw options.busyError?.() ?? new Error('Cannot refresh MCP while local Codex hosts are active or starting');+ if (!options.forceRetire && activeUseCount() > 0) throw options.busyError?.() ?? new Error('Cannot refresh MCP while local Codex hosts are active or starting');await retire();} else {await this.disposeLocalHostForCredentialChangeUnlocked(key, reason);@@ -2353,6 +2400,7 @@ export class CodexAgent extends BaseAgent {const coordinator = this.deps.prepareCodexLocalCredentialModeSwitch;if (coordinator) {await coordinator({+ hostKey: key,fromMode: currentMode,fromModeEffective: currentEffective,toMode,@@ -2396,12 +2444,39 @@ export class CodexAgent extends BaseAgent {}}+ private routeResolutionAbort = new AbortController();++ private async resolveLocalAuthSelection(providerId: string | null | undefined, model: string) {+ const signal = this.routeResolutionAbort.signal;+ for (let attempt = 0; ; attempt++) {+ signal.throwIfAborted();+ await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(LOCAL_CONFIGURATION_CHANGE_KEY), signal);+ signal.throwIfAborted();+ const generation = this.hostGenerations.get(LOCAL_CONFIGURATION_CHANGE_KEY);+ const resolved = await awaitCodexRouteSelection(+ Promise.resolve(this.deps.resolveCodexLocalAuthPolicy?.(providerId, model, signal) ?? 'legacy-shared'), signal,+ );+ signal.throwIfAborted();+ const policy = typeof resolved === 'string' ? resolved : resolved.policy;+ const isCurrent = () => !signal.aborted+ && generation === this.hostGenerations.get(LOCAL_CONFIGURATION_CHANGE_KEY)+ && !this.hostCredentialModeSwitches.has(LOCAL_CONFIGURATION_CHANGE_KEY)+ && (typeof resolved === 'string' || resolved.isCurrent());+ if (isCurrent()) return { policy, isCurrent };+ if (attempt >= 7) throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during selection', false);+ }+ }+private async getHost(remoteHostId?: string,credentialMode?: AgentCredentialMode,opts: {providerId?: string;ignoreBindingLeases?: number;+ routeIsCurrent?: () => boolean;+ routeSignal?: AbortSignal;+ reuseExistingUtilityHost?: boolean;+ localAuthPolicy?: 'isolated' | 'legacy-shared';keyOverride?: string;hostPurpose?: 'control-plane' | 'review' | 'custom-context';customContextModel?: string;@@ -2411,6 +2486,9 @@ export class CodexAgent extends BaseAgent {} = {},): Promise<AppServerHost> {const key = opts.keyOverride ?? (opts.providerId ? `local-account:${opts.providerId}` : hostKey(remoteHostId));+ const assertRouteCurrent = (): void => {+ if (opts.routeIsCurrent && !opts.routeIsCurrent()) throw new CodexRouteSelectionChangedError();+ };// spawnMode = 调用方原始诉求(undefined 保持 adapter fallback,spawn 行为不变)。// 复用判定分两级(review P2:归一化解析走 getState、含 reconcile/fs,不允许进// 无条件路径):@@ -2466,7 +2544,8 @@ export class CodexAgent extends BaseAgent {return true;};while (true) {- if (!remoteHostId) await this.waitForHostCredentialModeSwitch(key);+ if (!remoteHostId) await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(key), opts.routeSignal);+ assertRouteCurrent();const retiring = this.retiringHosts.get(key);if (retiring) {await this.beginHostRetirement(key, retiring.host, 'recheck retirement before Host reuse');@@ -2475,6 +2554,8 @@ export class CodexAgent extends BaseAgent {const existing = this.hosts.get(key);if (existing) {+ // Preserve getUtilityHost's reuse semantics if a switch finished while it awaited getHost.+ if (opts.reuseExistingUtilityHost) return existing;const currentMode = this.hostCredentialModes.get(key);const currentEffective = this.hostEffectiveCredentialModes.get(key);const subagentRoutingProfileCompatible = remoteHostId@@ -2489,6 +2570,7 @@ export class CodexAgent extends BaseAgent {) {if (this.hosts.get(key) !== existing || this.retiringHosts.has(key)|| (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY))) continue;+assertRouteCurrent();return existing;}await this.shutdownHostForCredentialModeChange(@@ -2506,6 +2588,10 @@ export class CodexAgent extends BaseAgent {const inflight = this.hostPromises.get(key);if (inflight) {+ if (opts.reuseExistingUtilityHost) {+ await inflight.promise;+ continue;+ }// inflight 的归一化形态要等 createHost 内 getState 完成才知道,这里按// undefined(保守)参与仲裁:跨形态请求会走重建,与改动前语义一致。// in-flight host 还不知道 codexProxyActive。provider-oauth 只复用同为 provider-oauth@@ -2553,6 +2639,7 @@ export class CodexAgent extends BaseAgent {) {if (this.hosts.get(key) !== inflightHost || this.retiringHosts.has(key)|| this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)) continue;+assertRouteCurrent();return inflightHost;}continue;@@ -2590,6 +2677,7 @@ export class CodexAgent extends BaseAgent {if (this.retiringHosts.has(key) || this.hosts.has(key) || this.hostPromises.has(key)) continue;if (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)) continue;+ assertRouteCurrent();const generation = this.bumpHostGeneration(key);// 超集归一化发生在 createHost 内(gateway-key → oauth-bearer);通过回调同步// in-flight 登记,让并发的 oauth-bearer 诉求命中复用而不是 supersede 重建。@@ -2616,6 +2704,8 @@ export class CodexAgent extends BaseAgent {opts.providerId,opts.sqliteHome,opts.historyHome,+ opts.localAuthPolicy,+ opts.routeIsCurrent,).finally(() => {// 成功: this.hosts 已赋值, 后续走快路径; 失败: 清掉 promise 让下次调用能重试const current = this.hostPromises.get(key);@@ -2631,6 +2721,7 @@ export class CodexAgent extends BaseAgent {const host = await promise;if (this.hosts.get(key) !== host || this.retiringHosts.has(key)|| (!remoteHostId && this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY))) continue;+assertRouteCurrent();return host;}}@@ -2683,7 +2774,7 @@ export class CodexAgent extends BaseAgent {const existing = this.hosts.get(key);if (existing) return { key, host: existing };const inflight = this.hostPromises.get(key);- if (!inflight) return { key, host: await this.getHost() };+ if (!inflight) return { key, host: await this.getHost(undefined, undefined, { reuseExistingUtilityHost: true }) };const host = await inflight.promise;if (this.hosts.get(key) !== host || this.retiringHosts.has(key)) continue;return { key, host };@@ -2734,7 +2825,10 @@ export class CodexAgent extends BaseAgent {const credentialMode = options?.credentialMode;if (!credentialMode) return this.refreshLocalModelsWithinDeadline(options);- const key = options?.providerId ? `local-account:${options.providerId}:models` : localControlPlaneHostKey(credentialMode);+ const key = codexLocalAuthHostIdentity(+ options?.providerId ? `local-account:${options.providerId}:models` : localControlPlaneHostKey(credentialMode),+ credentialMode === 'gateway-key' ? 'isolated' : 'legacy-shared',+ );let timer: ReturnType<typeof setTimeout> | undefined;const deadline = new Promise<never>((_, reject) => {timer = setTimeout(() => {@@ -2765,14 +2859,17 @@ export class CodexAgent extends BaseAgent {const credentialMode = options?.credentialMode;// 显式 provider 刷新使用独立 control-plane app-server。不能为了发一次 model/list// 切换共享 local host 的凭证形态:切换协调器会关闭空闲会话,忙碌会话则直接拒绝。- const key = options?.providerId ? `local-account:${options.providerId}:models` : credentialMode- ? localControlPlaneHostKey(credentialMode)- : hostKey();+ const key = codexLocalAuthHostIdentity(+ options?.providerId ? `local-account:${options.providerId}:models` : credentialMode+ ? localControlPlaneHostKey(credentialMode) : hostKey(),+ credentialMode === 'gateway-key' ? 'isolated' : 'legacy-shared',+ );return this.withHostOperation(async () => ({key: credentialMode ? key : hostKey(),host: credentialMode? await this.getHost(undefined, credentialMode, {providerId: options?.providerId,+ ...(credentialMode === 'gateway-key' ? { localAuthPolicy: 'isolated' as const } : {}),keyOverride: key,hostPurpose: 'control-plane',})@@ -2854,6 +2951,8 @@ export class CodexAgent extends BaseAgent {providerId?: string,sqliteHome?: string,historyHome?: string,+ localAuthPolicy?: 'isolated' | 'legacy-shared',+ routeIsCurrent?: () => boolean,): Promise<AppServerHost> {const seq = (this.createHostSeqByKey.get(key) ?? 0) + 1;this.createHostSeqByKey.set(key, seq);@@ -2871,6 +2970,7 @@ export class CodexAgent extends BaseAgent {generation,});const assertCurrentGeneration = (stage: string): void => {+ if (routeIsCurrent && !routeIsCurrent()) throw new CodexRouteSelectionChangedError();if ((this.hostGenerations.get(key) ?? 0) === generation) return;throw new Error(`Codex app-server host creation was superseded before ${stage}`);};@@ -2879,7 +2979,7 @@ export class CodexAgent extends BaseAgent {// 同时还能服务订阅会话 —— 订阅/API 会话真正并行,不再因来源切换重建 host 排队。let spawnCredentialMode = credentialMode;let requestedGatewayState: AuthState | null = null;- if (!remoteHostId && credentialMode === 'gateway-key') {+ if (!remoteHostId && localAuthPolicy !== 'isolated' && credentialMode === 'gateway-key') {// 即使升格为 OAuth spawn,API 会话的出口仍依赖 gateway key,必须先验证原诉求。requestedGatewayState = await this.deps.auth.getState({ credentialMode: 'gateway-key' });assertCurrentGeneration('gateway credential validation');@@ -2976,6 +3076,9 @@ export class CodexAgent extends BaseAgent {...(!remoteHostId && historyHome ? { runtimeCodexHome: historyHome } : {}),...(key.startsWith('local-account:') ? { accountHostKey: `${key}:${generation}` } : {}),credentialMode: spawnCredentialMode,+ ...(localAuthPolicy === 'isolated'+ ? { localAuthPolicy, hostScopeKey: `${key}:${generation}` }+ : {}),...(spawnCredentialMode !== credentialMode? { requestedCredentialMode: credentialMode }: {}),@@ -3003,6 +3106,9 @@ export class CodexAgent extends BaseAgent {});await hostRetirementCleanup?.();hostRetirementCleanup = undefined;+ if (localAuthPolicy === 'isolated') {+ throw Object.assign(new Error('Codex route requires official OAuth on an external-auth host'), { codexSpawnConfigFatal: true });+ }spawnCredentialMode = cfg.requiredSpawnCredentialMode;continue;}@@ -3042,6 +3148,7 @@ export class CodexAgent extends BaseAgent {} catch (e) {await hostRetirementCleanup?.();hostRetirementCleanup = undefined;+ if (e instanceof CodexRouteSelectionChangedError) throw e;const isFatalSpawnConfigError =(typeof e === 'object' && e !== null &&(e as { codexSpawnConfigFatal?: unknown }).codexSpawnConfigFatal === true);@@ -3073,7 +3180,8 @@ export class CodexAgent extends BaseAgent {}if (!remoteHostId && sqliteHome) extraArgs.push('-c', `sqlite_home=${JSON.stringify(sqliteHome)}`);let externalAuth: CodexExternalAuth | undefined;- const requireEphemeralAuth = !remoteHostId && !!historyHome && path.resolve(historyHome) !== path.resolve(env.CODEX_HOME ?? '');+ const requireEphemeralAuth = !remoteHostId && (localAuthPolicy === 'isolated'+ || (!!historyHome && path.resolve(historyHome) !== path.resolve(env.CODEX_HOME ?? '')));if (!remoteHostId && hostPurpose === 'control-plane' && effectiveMode === 'oauth-bearer' && env.CODEX_HOME) {// Managed refresh must read the selected account's file, not an inherited identity.env = useCodexHistoryHome(env, env.CODEX_HOME);@@ -3082,7 +3190,7 @@ export class CodexAgent extends BaseAgent {// Extra spawn configuration above intentionally uses the TARGET credential// home (proxy auth, model catalogs and account controls). Only the native// runtime uses the canonical history home, including lineage/writer locks.- env = useCodexHistoryHome(env, historyHome!);+ env = useCodexHistoryHome(env, historyHome ?? env.CODEX_HOME);extraArgs.push('-c', 'cli_auth_credentials_store="ephemeral"');if (effectiveMode === 'oauth-bearer') {if (!readAccountTokens) {@@ -3188,7 +3296,7 @@ export class CodexAgent extends BaseAgent {// 持续撞鉴权失败; auth.invalidate 会触发 logout + 通知 UI 重登。延后到 microtask// 防止在 JSON-RPC response 分发回调里同步收割自己。远端也走同一结构化协议路径。onAuthInvalidated: (reason) => {- const usesLocalAuth = !remoteHostId;+ const usesLocalAuth = !remoteHostId && localAuthPolicy !== 'isolated';this.deps.logger.warn('codex auth invalidated', {reason,key,@@ -3400,20 +3508,37 @@ export class CodexAgent extends BaseAgent {}async startSession(opts: StartSessionOptions): Promise<AgentSessionHandle> {- const startupCleanup: { customContext?: () => Promise<void> } = {};- try {- return await this.startSessionInternal(opts, (cleanup) => {- startupCleanup.customContext = cleanup ?? undefined;- });- } catch (error) {- await startupCleanup.customContext?.();- throw error;+ const signal = this.routeResolutionAbort.signal;+ for (let attempt = 0; ; attempt++) {+ const startup = {+ signal, threadDispatched: false,+ cleanup: undefined as (() => Promise<void>) | undefined,+ customContext: undefined as (() => Promise<void>) | undefined,+ };+ try {+ signal.throwIfAborted();+ return await this.startSessionInternal(opts, (cleanup) => {+ startup.customContext = cleanup ?? undefined;+ }, startup);+ } catch (error) {+ if (!startup.threadDispatched+ && (error instanceof CodexRouteSelectionChangedError || error instanceof CodexNativeInitializationStoppedError || signal.aborted)) {+ // No thread was submitted. Release this startup's lease and retire only+ // an unused host; another live handle's process belongs to that handle.+ await startup.cleanup?.();+ if (!signal.aborted && error instanceof CodexRouteSelectionChangedError && error.retryable && attempt < 7) continue;+ throw new AgentStartupStoppedError(signal.aborted ? signal.reason : error);+ }+ await startup.customContext?.();+ throw error;+ }}}private async startSessionInternal(opts: StartSessionOptions,registerFailedCustomContextStartupCleanup: (cleanup: (() => Promise<void>) | null) => void,+ startup: { signal: AbortSignal; threadDispatched: boolean; cleanup?: () => Promise<void> },): Promise<AgentSessionHandle> {// scope 带完整 s:<sessionId> 前缀 → host logger 落盘时提取 business sessionId,// 路由到 sessions/<id>/<date>.ndjson (logger.ts extractSessionId / sessionAgentSlot)。@@ -4782,15 +4907,22 @@ export class CodexAgent extends BaseAgent {const accountProviderId = this.deps.isCodexAccountProvider?.(opts.providerId) ? opts.providerId! : undefined;const accountSessionHost = !opts.remoteHostId && (accountProviderId !== undefined || this.deps.isolateCodexAccountSessions === true);if (opts.remoteHostId && accountProviderId) throw new Error('This Codex account belongs to the local device');- const credentialMode = opts.remoteHostId+ const startupRouteSignal = this.routeResolutionAbort.signal;+ let routeSelection = opts.remoteHostId+ ? { policy: 'legacy-shared' as const, isCurrent: () => true }+ : await this.resolveLocalAuthSelection(opts.providerId, opts.model);+ const requestedCredentialMode = opts.remoteHostId? undefined: accountProviderId ? 'oauth-bearer' : resolveAgentCredentialMode({agentKind: 'codex',providerId: opts.providerId,model: opts.model,});+ let localAuthPolicy = routeSelection.policy;+ let credentialMode = requestedCredentialMode+ ?? (localAuthPolicy === 'isolated' ? 'provider-oauth' : undefined);const resolveCodexThreadContextWindow = this.deps.resolveCodexThreadContextWindow;- const initialCustomContextWindow = !reviewMode+ let initialCustomContextWindow = !reviewMode? await resolveCodexThreadContextWindow?.(opts.providerId, opts.model) ?? null: null;const customContextCatalogIdentity = (@@ -4800,13 +4932,13 @@ export class CodexAgent extends BaseAgent {typeof contextWindow === 'number' && Number.isFinite(contextWindow) && contextWindow > 0? `${model}\0${Math.floor(contextWindow)}`: null;- const initialCustomContextCatalogIdentity = customContextCatalogIdentity(+ let initialCustomContextCatalogIdentity = customContextCatalogIdentity(opts.model,initialCustomContextWindow,);// SSH shares a daemon across tasks; its context settings belong to each// thread/start or thread/resume config, never a local single-session host.- const usesCustomContextHost = !opts.remoteHostId && initialCustomContextCatalogIdentity !== null;+ let usesCustomContextHost = !opts.remoteHostId && initialCustomContextCatalogIdentity !== null;const resolveModelSwitchCatalogIdentity = async (newModel: string,setOpts?: { providerId?: string | null },@@ -4824,20 +4956,29 @@ export class CodexAgent extends BaseAgent {setOpts?: { providerId?: string | null },): Promise<boolean> => {const nextProvider = setOpts && Object.hasOwn(setOpts, 'providerId') ? setOpts.providerId : mutableProviderId;- return (this.deps.isCodexAccountProvider?.(nextProvider) ? nextProvider : undefined) !== accountProviderId ||- (await resolveModelSwitchCatalogIdentity(newModel, setOpts)) !== initialCustomContextCatalogIdentity;- };- const baseSessionHostKey = reviewMode- ? localReviewHostKey(sid)- : usesCustomContextHost- ? localCustomContextHostKey(sid)- : hostKey(opts.remoteHostId);+ if ((this.deps.isCodexAccountProvider?.(nextProvider) ? nextProvider : undefined) !== accountProviderId) return true;+ for (let attempt = 0; ; attempt++) {+ const selection = opts.remoteHostId ? null : await this.resolveLocalAuthSelection(+ setOpts && Object.hasOwn(setOpts, 'providerId') ? setOpts.providerId : mutableProviderId,+ newModel,+ );+ const catalogIdentity = await resolveModelSwitchCatalogIdentity(newModel, setOpts);+ if (!selection || selection.isCurrent()) {+ return catalogIdentity !== initialCustomContextCatalogIdentity+ || (selection !== null && selection.policy !== localAuthPolicy);+ }+ if (attempt >= 7) throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during model switch');+ }+ };const sessionStorage = !opts.remoteHostId && opts.resumeSessionId? await this.deps.resolveCodexThreadStorage?.(opts.resumeSessionId): undefined;const sessionSqliteHome = sessionStorage?.sqliteHome;- const currentHostKey = (accountSessionHost ? `local-account:${accountProviderId ?? 'openai'}:session:${sid}` : baseSessionHostKey)- + (sessionStorage ? `:storage:${sessionSqliteHome}:history:${sessionStorage.historyHome}` : '');+ const resolveSessionHostKey = (): string => localSessionHostIdentity({+ sessionId: sid, remoteHostId: opts.remoteHostId, accountSessionHost, accountProviderId,+ reviewMode, customContext: usesCustomContextHost, storage: sessionStorage, policy: localAuthPolicy,+ });+ let currentHostKey = resolveSessionHostKey();let releaseHostBindingLease: (() => void) | null = null;const acquireHostBindingLeaseIfNeeded = (): void => {if (opts.remoteHostId || releaseHostBindingLease) return;@@ -4852,10 +4993,9 @@ export class CodexAgent extends BaseAgent {if (opts.remoteHostId) return await this.getHost(opts.remoteHostId, credentialMode);// 本地会话先等已有 credential switch 完成,再占用 startup reservation。否则// session 已拿到旧 host、但尚未 thread/start 订阅时,credential 切换看不到它。- do {- await this.waitForHostCredentialModeSwitch(currentHostKey);- } while (this.hostCredentialModeSwitches.has(LOCAL_MCP_REFRESH_KEY)- || this.hostCredentialModeSwitches.has(currentHostKey));+ await awaitCodexRouteSelection(this.waitForHostCredentialModeSwitch(currentHostKey), startupRouteSignal);+ startupRouteSignal.throwIfAborted();+ if (!routeSelection.isCurrent()) throw new CodexRouteSelectionChangedError();acquireHostBindingLeaseIfNeeded();return await this.getHost(opts.remoteHostId, credentialMode, {...(accountProviderId ? { providerId: accountProviderId } : {}),@@ -4863,6 +5003,12 @@ export class CodexAgent extends BaseAgent {...(sessionStorage ? { historyHome: sessionStorage.historyHome } : {}),...(accountSessionHost || reviewMode || usesCustomContextHost || sessionSqliteHome ? { keyOverride: currentHostKey } : {}),ignoreBindingLeases: 1,+ routeIsCurrent: routeSelection.isCurrent,+ routeSignal: startupRouteSignal,+ ...(localAuthPolicy === 'isolated' || reviewMode || usesCustomContextHost+ ? { keyOverride: currentHostKey }+ : {}),+ ...(localAuthPolicy === 'isolated' ? { localAuthPolicy } : {}),...(reviewMode? { hostPurpose: 'review' as const }: usesCustomContextHost@@ -4874,10 +5020,28 @@ export class CodexAgent extends BaseAgent {: {}),});};- const host = await getSessionHost().catch((error) => {- releaseHostBindingLeaseIfNeeded();- throw error;- });+ const host = await (async () => {+ for (let attempt = 0; ; attempt++) {+ try {+ return await getSessionHost();+ } catch (error) {+ releaseHostBindingLeaseIfNeeded();+ startupRouteSignal.throwIfAborted();+ if (!(error instanceof CodexRouteSelectionChangedError)) throw error;+ if (!error.retryable || attempt >= 7) {+ throw new CodexRouteSelectionChangedError('Codex route changed repeatedly during host preparation', false);+ }+ routeSelection = await this.resolveLocalAuthSelection(opts.providerId, opts.model);+ localAuthPolicy = routeSelection.policy;+ credentialMode = requestedCredentialMode ?? (localAuthPolicy === 'isolated' ? 'provider-oauth' : undefined);+ initialCustomContextWindow = !reviewMode+ ? await resolveCodexThreadContextWindow?.(opts.providerId, opts.model) ?? null : null;+ initialCustomContextCatalogIdentity = customContextCatalogIdentity(opts.model, initialCustomContextWindow);+ usesCustomContextHost = initialCustomContextCatalogIdentity !== null;+ currentHostKey = resolveSessionHostKey();+ }+ }+ })();const hostGeneration = this.hostGenerations.get(currentHostKey) ?? 0;const capturedHostWasRegistered = this.hosts.get(currentHostKey) === host;const retireSingleSessionHost = async (): Promise<void> => {@@ -4903,6 +5067,17 @@ export class CodexAgent extends BaseAgent {await retireSingleSessionHost();});}+ startup.cleanup = async () => {+ releaseHostBindingLeaseIfNeeded();+ const retiring = this.retiringHosts.get(currentHostKey);+ if (retiring?.host === host) await this.beginHostRetirement(currentHostKey, host, 'unsubmitted startup stopping');+ if (this.hosts.get(currentHostKey) === host && this.hostActiveUseCount(currentHostKey, host) === 0) {+ await this.retireHostKey(currentHostKey, 'Codex startup route changed before thread submission', {+ failIfActive: true, logPrefix: 'codex unsubmitted startup cleanup',+ expectedHost: host, expectedGeneration: hostGeneration, throwOnShutdownFailure: true,+ });+ }+ };const connectionId = host.getConnectionId();// JSON-RPC IDs are connection-local (often 0). Desktop indexes interaction// requests across sessions, so never expose a raw server ID as a UI ID.@@ -4917,6 +5092,10 @@ export class CodexAgent extends BaseAgent {const staleHostError = (operation: string): Error =>new Error(`Codex session expired because its app-server was replaced before ${operation}; restart the session`);const assertCurrentHost = (operation: string): void => {+ if (!startup.threadDispatched) {+ startup.signal.throwIfAborted();+ if (!routeSelection.isCurrent()) throw new CodexRouteSelectionChangedError();+ }if (isCurrentHost()) return;log.warn('codex session handle rejected after app-server replacement', {operation,@@ -4944,6 +5123,12 @@ export class CodexAgent extends BaseAgent {assertCurrentHost('initialize');} catch (error) {releaseHostBindingLeaseIfNeeded();+ // Exhaustion/cancellation of native startup is terminal for this request;+ // a simultaneous route change must not multiply the three-process budget.+ if (error instanceof CodexNativeInitializationStoppedError) throw error;+ // A provider transaction may close initialize while no thread exists yet.+ // Preserve route reselection instead of surfacing the transport's close error.+ assertCurrentHost('initialize failed');throw error;}const sessionCodexHome = initResp.codexHome ?? null;@@ -5022,11 +5207,12 @@ export class CodexAgent extends BaseAgent {const useLocalSkillDiscoveryHost =!opts.remoteHostId && sessionCredentialMode === 'provider-oauth';const skillDiscoveryHostKey = useLocalSkillDiscoveryHost- ? localControlPlaneHostKey('provider-oauth')+ ? codexLocalAuthHostIdentity(localControlPlaneHostKey('provider-oauth'), 'isolated'): currentHostKey;const skillDiscoveryHost = useLocalSkillDiscoveryHost? await this.getHost(undefined, 'provider-oauth', {keyOverride: skillDiscoveryHostKey,+ localAuthPolicy: 'isolated',hostPurpose: 'control-plane',}): host;@@ -5073,6 +5259,7 @@ export class CodexAgent extends BaseAgent {};} catch (error) {releaseHostBindingLeaseIfNeeded();+ if (error instanceof CodexRouteSelectionChangedError) throw error;throw new Error(`Cannot start Codex safely because Cindy could not inspect restricted Codex Skills: ${error instanceof Error ? error.message : String(error)}`,);@@ -5184,6 +5371,7 @@ export class CodexAgent extends BaseAgent {assertCurrentHost('Review capability isolation');} catch (error) {releaseHostBindingLeaseIfNeeded();+ if (error instanceof CodexRouteSelectionChangedError) throw error;throw new Error(`Cannot start Codex Review safely because Cindy could not disable local Skills, plugins, and MCP servers: ${error instanceof Error ? error.message : String(error)}`,);@@ -5221,6 +5409,7 @@ export class CodexAgent extends BaseAgent {}} catch (error) {releaseHostBindingLeaseIfNeeded();+ if (error instanceof CodexRouteSelectionChangedError) throw error;throw new Error(`Cannot prepare Codex Bot MCP configuration: ${error instanceof Error ? error.message : String(error)}`);}}@@ -5251,6 +5440,7 @@ export class CodexAgent extends BaseAgent {);} catch (error) {releaseHostBindingLeaseIfNeeded();+ if (error instanceof CodexRouteSelectionChangedError) throw error;throw new Error(`Cannot prepare local Skill configuration: ${error instanceof Error ? error.message : String(error)}`);}}@@ -6555,9 +6745,16 @@ export class CodexAgent extends BaseAgent {};acquireHostBindingLeaseIfNeeded();assertCurrentHost('thread/start');- const resp = await withMcpDiscoveryContext(() => host.request<ThreadStartResponse>(Method.ThreadStart, params, {- timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,- }));+ const resp = await withMcpDiscoveryContext(() => {+ assertCurrentHost('thread/start dispatch');+ return host.request<ThreadStartResponse>(Method.ThreadStart, params, {+ timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,+ beforeDispatch: () => {+ assertCurrentHost('thread/start write');+ startup.threadDispatched = true;+ },+ });+ });assertCurrentHost('thread/start');if (Object.hasOwn(resp, 'serviceTier')) {mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;@@ -6657,9 +6854,16 @@ export class CodexAgent extends BaseAgent {try {acquireHostBindingLeaseIfNeeded();assertCurrentHost('thread/resume');- const resp = await withMcpDiscoveryContext(() => host.request<ThreadResumeResponse>(Method.ThreadResume, params, {- timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,- }));+ const resp = await withMcpDiscoveryContext(() => {+ assertCurrentHost('thread/resume dispatch');+ return host.request<ThreadResumeResponse>(Method.ThreadResume, params, {+ timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS,+ beforeDispatch: () => {+ assertCurrentHost('thread/resume write');+ startup.threadDispatched = true;+ },+ });+ });assertCurrentHost('thread/resume');if (Object.hasOwn(resp, 'serviceTier')) {mutableServiceTier = normalizeServiceTier(resp.serviceTier) ?? null;@@ -6732,6 +6936,7 @@ export class CodexAgent extends BaseAgent {serviceTier: mutableServiceTier ?? null,});} catch (e) {+ if (!startup.threadDispatched && (e instanceof CodexRouteSelectionChangedError || startup.signal.aborted)) throw e;let freshThreadStarted = false;if (!preparedResumePath && (!indexedRolloutMissing || indexedThreadAbsent)&& isExactNoRolloutThreadResumeError(e, opts.resumeSessionId)) {@@ -6786,6 +6991,7 @@ export class CodexAgent extends BaseAgent {await startFreshThread();} catch (e) {releaseHostBindingLeaseIfNeeded();+ if (!startup.threadDispatched && (e instanceof CodexRouteSelectionChangedError || startup.signal.aborted)) throw e;log.error('thread/start failed', { error: String(e) });const message = `Failed to start Codex thread: ${String(e)}`;eventQueue.push({@@ -12695,6 +12901,7 @@ export class CodexAgent extends BaseAgent {agentKind: 'codex',get model() { return mutableModel; },get codexProxyActive() { return hostUsesCodexProxy; },+ get codexHostKey() { return currentHostKey; },get codexThreadModelProviderId() { return codexThreadModelProviderId; },get codexThreadMayHaveRollout() { return threadMayHaveRollout; },get codexCindyRemoteCompactionCompatible() {@@ -14380,6 +14587,71 @@ export class CodexAgent extends BaseAgent {return bestPath;}+ async requiresCodexThreadHostTransfer(+ opts: Parameters<BaseAgent['requiresCodexThreadHostTransfer']>[0],+ ): Promise<boolean> {+ if (opts.remoteHostId) return false;+ const observedHosts = new Set<AppServerHost>();+ for (let attempt = 0; attempt < 8; attempt += 1) {+ const hosts = new Map([...this.hosts].filter(([key]) => key.startsWith('local')));+ const generations = new Map([...this.hostGenerations].filter(([key]) => key.startsWith('local')));+ const writerCandidates = new Map([...hosts.values()].map((host) => [host, host.writerCandidate]));+ for (const host of hosts.values()) observedHosts.add(host);+ const registryCurrent = () => {+ const currentHosts = [...this.hosts].filter(([key]) => key.startsWith('local'));+ const currentGenerations = [...this.hostGenerations].filter(([key]) => key.startsWith('local'));+ return currentHosts.length === hosts.size && currentGenerations.length === generations.size+ && currentHosts.every(([key, host]) => hosts.get(key) === host && writerCandidates.get(host) === host.writerCandidate)+ && currentGenerations.every(([key, generation]) => generations.get(key) === generation);+ };+ const settleRetirements = async () => {+ for (const [key, entry] of this.retiringHosts) {+ if (key.startsWith('local')) observedHosts.add(entry.host);+ }+ // Do not retry a failed retirement here: callers must not commit a new+ // route after a failed exit proof, even if the registry later changes.+ await awaitCodexRouteSelection(Promise.all([...observedHosts].map((host) =>+ this.hostRetirementResults.get(host))), this.routeResolutionAbort.signal);+ };+ await settleRetirements();+ if (!registryCurrent()) continue;+ const selection = await this.resolveLocalAuthSelection(opts.providerId, opts.model);+ const contextWindow = opts.reviewMode ? null+ : await this.deps.resolveCodexThreadContextWindow?.(opts.providerId, opts.model);+ const accountProviderId = this.deps.isCodexAccountProvider?.(opts.providerId) ? opts.providerId! : undefined;+ const storage = await this.deps.resolveCodexThreadStorage?.(opts.threadId);+ const targetKey = localSessionHostIdentity({+ sessionId: opts.sessionId ?? '', accountProviderId,+ accountSessionHost: accountProviderId !== undefined || this.deps.isolateCodexAccountSessions === true,+ reviewMode: opts.reviewMode === true,+ customContext: typeof contextWindow === 'number' && Number.isFinite(contextWindow) && contextWindow > 0,+ storage, policy: selection.policy,+ });+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();+ for (const [key, host] of hosts) {+ if (!registryCurrent()) break;+ if (key === targetKey || !host.writerCandidate) continue;+ let cursor: string | null = null;+ do {+ const result: { data: string[]; nextCursor?: string | null } | null = await awaitCodexRouteSelection(+ host.request<{ data: string[]; nextCursor?: string | null }>('thread/loaded/list', { cursor }, { timeoutMs: CRITICAL_THREAD_RPC_TIMEOUT_MS }),+ this.routeResolutionAbort.signal,+ ).catch((error) => { if (!registryCurrent()) return null; throw error; });+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();+ if (!result || !registryCurrent()) break;+ // A closed business handle does not release the native 0.153 writer.+ if (result.data?.includes(opts.threadId)) return true;+ cursor = result.nextCursor ?? null;+ } while (cursor !== null);+ }+ await settleRetirements();+ if (!registryCurrent()) continue;+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();+ return false;+ }+ throw new CodexRouteSelectionChangedError('Codex writer registry did not stabilize', false);+ }+async forkSdkSession(opts: ForkSdkSessionOptions): Promise<ForkSdkSessionResult> {const log = this.deps.logger.child('codex/fork');const tailTurnsToDrop = normalizeTailTurnsToDrop(opts.tailTurnsToDrop);@@ -14400,7 +14672,9 @@ export class CodexAgent extends BaseAgent {// maxLineBytes 守卫后整条连接被熔断,当时共享 utility host 上挂着的 5 个活跃// session 全部同时报错。fork 是离线控制面操作(不跑 turn、无订阅者),改用// 唯一 key 的一次性 app-server:超限只让 fork 自己失败,不波及活跃任务。- const forkHostKey = forkAccountId ? `local-account:${forkAccountId}:${localForkHostKey()}` : localForkHostKey();+ const forkRouteSignal = this.routeResolutionAbort.signal;+ const forkBaseHostKey = forkAccountId ? `local-account:${forkAccountId}:${localForkHostKey()}` : localForkHostKey();+ let forkHostKey = forkBaseHostKey;let releaseForkLease: (() => void) | undefined;let forkHost: AppServerHost | undefined;let forkHostRetired = false;@@ -14464,78 +14738,105 @@ export class CodexAgent extends BaseAgent {await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));historyChecked = true;}- // ID-only turn queries must use the source thread's index even when the- // account supplying credentials has changed. Keep the child in that index.const forkSqliteHome = forkStorage?.sqliteHome;- stage = 'host-create';- const leased = await this.acquireHostOperation(async () => {- const host = await this.getHost(undefined, forkCredentialMode, {- keyOverride: forkHostKey,- ...(forkAccountId ? { providerId: forkAccountId } : {}),- ...(forkSqliteHome ? { sqliteHome: forkSqliteHome } : {}),- ...(forkStorage ? { historyHome: forkStorage.historyHome } : {}),- hostPurpose: 'control-plane',- }).catch((error) => {- // This is the outgoing source's offline fork host, not a target send.- // Missing old credentials must not trap a task on the provider it is leaving.- if (opts.stripEncryptedReasoning && error instanceof AgentNotAuthenticatedError) {- throw new CodexHistoryRecoveryRequiredError();+ let forkCodexHome: string | undefined;+ let forkDispatched = false;+ const { host, resp, initResp, usedNativeForkAnchor } = await (async () => {+ for (let attempt = 0; ; attempt++) {+ forkRouteSignal.throwIfAborted();+ const selection = await this.resolveLocalAuthSelection(opts.providerId, opts.model ?? '');+ forkHostKey = codexLocalAuthHostIdentity(forkBaseHostKey, selection.policy);+ forkHostRetired = false;+ stage = 'host-create';+ try {+ const leased = await this.acquireHostOperation(async () => {+ const host = await this.getHost(undefined, forkCredentialMode, {+ keyOverride: forkHostKey,+ ...(forkAccountId ? { providerId: forkAccountId } : {}),+ ...(forkSqliteHome ? { sqliteHome: forkSqliteHome } : {}),+ ...(forkStorage ? { historyHome: forkStorage.historyHome } : {}),+ routeIsCurrent: selection.isCurrent,+ routeSignal: forkRouteSignal,+ ...(selection.policy === 'isolated' ? { localAuthPolicy: selection.policy } : {}),+ hostPurpose: 'control-plane',+ });+ return { key: forkHostKey, host };+ });+ const { host } = leased;+ releaseForkLease = leased.release;+ forkHost = host;+ stage = 'host-start';+ const initResp = await host.ensureStarted();+ // Child rollout discovery scans this.codexHome. The fork host may be+ // the first host started by this process, so hydrate it here.+ forkCodexHome = initResp.codexHome ?? undefined;+ if (forkCodexHome && !forkAccountId && !forkStorage) this.codexHome = forkCodexHome;+ // Imported Codex threads may still live under another CODEX_HOME. Resume+ // already asks the desktop host to link/adopt their state and rollout;+ // fork must cross the same preparation boundary before thread/fork or the+ // fork app-server cannot resolve a freshly imported thread.+ // A first host may have just created the managed state DB needed for imports.+ stage = 'source-prepare';+ preparedSourcePath ??= await this.deps.prepareCodexResumeSession?.(opts.sourceSdkSessionId);+ if (opts.stripEncryptedReasoning && !historyChecked) {+ // Check before allocating a child: indexed native history must go through+ // Cindy's handoff recovery, never a file rewrite that invalidates Codex's DB.+ await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));+ }+ if (+ !lastTurnId && (tailTurnsToDrop > 0 || opts.forkAtTimestampMs !== undefined) && !opts.stripEncryptedReasoning+ && codexUserAgentAtLeast(initResp.userAgent, [0, 153, 4])+ ) {+ // Older/failed messages have no persisted UI anchor. Paginated threads+ // reject rollback, so resolve the requested boundary with metadata only+ // before allocating a child. Never rewrite indexed rollout files.+ lastTurnId = await resolveForkTurnAnchor(+ (method, params) => host.request(method, params),+ opts.sourceSdkSessionId,+ opts.forkAtTimestampMs,+ );+ }+ forkRouteSignal.throwIfAborted();+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();+ const usedNativeForkAnchor = Boolean(+ lastTurnId && !opts.stripEncryptedReasoning && supportsCodexNativeTurnFork(initResp.userAgent),+ );+ const params: ThreadForkParams = {+ threadId: opts.sourceSdkSessionId,+ ...(preparedSourcePath ? { path: preparedSourcePath } : {}),+ ...(!usedNativeForkAnchor ? { persistExtendedHistory: true } : {}),+ ...(usedNativeForkAnchor ? { lastTurnId } : {}),+ // 响应体瘦身:fork 后 Cindy 自己的会话数据负责历史展示,thread.turns 全量+ // 回传只会撑爆单行上限。老 daemon 不认识该字段则保持 legacy 行为 —— 此时+ // 一次性 host 的隔离仍兜住故障半径。+ ...(supportsCodexForkExcludeTurns(initResp.userAgent) ? { excludeTurns: true } : {}),+ ...(opts.workingDir ? { cwd: opts.workingDir } : {}),+ };+ // Once dispatched, a lost response may still mean a child was allocated.+ stage = 'thread-fork';+ const resp = await host.request<ThreadForkResponse>(Method.ThreadFork, params, {+ beforeDispatch: () => {+ forkRouteSignal.throwIfAborted();+ if (!selection.isCurrent()) throw new CodexRouteSelectionChangedError();+ forkDispatched = true;+ },+ });+ return { host, resp, initResp, usedNativeForkAnchor };+ } catch (error) {+ if (!forkDispatched && error instanceof CodexRouteSelectionChangedError && !forkRouteSignal.aborted) {+ await retireForkHost(true);+ releaseForkLease?.();+ releaseForkLease = undefined;+ forkHost = undefined;+ if (attempt < 7) continue;+ }+ if (opts.stripEncryptedReasoning && error instanceof AgentNotAuthenticatedError) {+ throw new CodexHistoryRecoveryRequiredError();+ }+ throw error;}- throw error;- });- return { key: forkHostKey, host };- });- const { host } = leased;- releaseForkLease = leased.release;- forkHost = host;- stage = 'host-start';- const initResp = await host.ensureStarted();- // Child rollout discovery scans this.codexHome. The fork host may be- // the first host started by this process, so hydrate it here.- const forkCodexHome = initResp.codexHome ?? undefined;- if (forkCodexHome && !forkAccountId && !forkStorage) this.codexHome = forkCodexHome;- // Imported Codex threads may still live under another CODEX_HOME. Resume- // already asks the desktop host to link/adopt their state and rollout;- // fork must cross the same preparation boundary before thread/fork or the- // fork app-server cannot resolve a freshly imported thread.- // A first host may have just created the managed state DB needed for imports.- stage = 'source-prepare';- preparedSourcePath ??= await this.deps.prepareCodexResumeSession?.(opts.sourceSdkSessionId);- if (opts.stripEncryptedReasoning && !historyChecked) {- // Check before allocating a child: indexed native history must go through- // Cindy's handoff recovery, never a file rewrite that invalidates Codex's DB.- await assertCodexRolloutRewriteSupported(preparedSourcePath || await this.findRolloutPath(opts.sourceSdkSessionId));- }- if (- !lastTurnId && (tailTurnsToDrop > 0 || opts.forkAtTimestampMs !== undefined) && !opts.stripEncryptedReasoning- && codexUserAgentAtLeast(initResp.userAgent, [0, 153, 4])- ) {- // Older/failed messages have no persisted UI anchor. Paginated threads- // reject rollback, so resolve the requested boundary with metadata only- // before allocating a child. Never rewrite indexed rollout files.- lastTurnId = await resolveForkTurnAnchor(- (method, params) => host.request(method, params),- opts.sourceSdkSessionId,- opts.forkAtTimestampMs,- );- }- const usedNativeForkAnchor = Boolean(- lastTurnId && !opts.stripEncryptedReasoning && supportsCodexNativeTurnFork(initResp.userAgent),- );- const params: ThreadForkParams = {- threadId: opts.sourceSdkSessionId,- ...(preparedSourcePath ? { path: preparedSourcePath } : {}),- ...(!usedNativeForkAnchor ? { persistExtendedHistory: true } : {}),- ...(usedNativeForkAnchor ? { lastTurnId } : {}),- // 响应体瘦身:fork 后 Cindy 自己的会话数据负责历史展示,thread.turns 全量- // 回传只会撑爆单行上限。老 daemon 不认识该字段则保持 legacy 行为 —— 此时- // 一次性 host 的隔离仍兜住故障半径。- ...(supportsCodexForkExcludeTurns(initResp.userAgent) ? { excludeTurns: true } : {}),- ...(opts.workingDir ? { cwd: opts.workingDir } : {}),- };- // Once dispatched, a lost response may still mean a child was allocated.- stage = 'thread-fork';- const resp = await host.request<ThreadForkResponse>(Method.ThreadFork, params);+ }+ })();let newSdkSessionId = resp.thread.id;if (forkCodexHome && typeof resp.thread.path === 'string') {await this.deps.recordCodexThreadLocation?.(newSdkSessionId, forkSqliteHome ?? forkCodexHome, resp.thread.path);@@ -14642,6 +14943,8 @@ export class CodexAgent extends BaseAgent {* SSH-bridged 各一份)。Windows 不会随父进程死, 必须显式收割。幂等。*/async dispose(): Promise<void> {+ this.routeResolutionAbort.abort(new Error('Codex route selection cancelled by dispose'));+ this.routeResolutionAbort = new AbortController();this.deps.logger.error('codex dispose called', {hostCount: this.hosts.size,inflightCount: this.hostPromises.size,@@ -14729,8 +15032,11 @@ export class CodexAgent extends BaseAgent {* 这些 host 都持有本机凭证,账号边界变化后不能继续复用;remote hosts 使用远端* 用户配置,不在本次清理范围内。*/- async forceDisposeLocalHostForAuthChange(reason = 'CodexAgent local auth changed'): Promise<void> {- const keys = new Set<string>([hostKey()]);+ async forceDisposeLocalHostForAuthChange(+ reason = 'CodexAgent local auth changed',+ options: { preserveExternalAuth?: boolean } = {},+ ): Promise<void> {+ const keys = new Set<string>([hostKey(), codexLocalAuthHostIdentity(hostKey(), 'isolated')]);for (const key of this.hosts.keys()) {if (key.startsWith('local-account:openai:') || isLocalControlPlaneHostKey(key) ||@@ -14747,7 +15053,9 @@ export class CodexAgent extends BaseAgent {isLocalCustomContextHostKey(key)) keys.add(key);}- await Promise.all(Array.from(keys, (key) =>+ await Promise.all(Array.from(keys).filter((key) =>+ !options.preserveExternalAuth || !key.endsWith(':external-auth'),+ ).map((key) =>this.retireHostKey(key, reason, {failIfActive: false,logPrefix: 'codex local auth restart',@@ -14788,6 +15096,7 @@ export class CodexAgent extends BaseAgent {};const promise = Promise.resolve().then(() => host.retire(reason, { throwOnTransportError: true }));entry.promise = promise;+ this.hostRetirementResults.set(host, promise);this.retiringHosts.set(key, entry);// 失败保留 key/Host 屏障;下次请求可重查迟到的 exit,不自动重试或另启 writer。void promise.then(() => {diff --git a/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.ts b/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.tsnew file mode 100644index 0000000000..40b457e30f--- /dev/null+++ b/packages/maker-core/src/agents/codex/oauth-isolation.integration.test.ts@@ -0,0 +1,105 @@+import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises';+import { createServer } from 'node:http';+import type { AddressInfo } from 'node:net';+import { tmpdir } from 'node:os';+import path from 'node:path';+import { describe, expect, it } from 'vitest';+import type { Logger } from '../../interfaces/logger.js';+import { CodexAgent } from './index.js';++// Explicit opt-in: never discover a user's installed runtime or credentials.+const binaryPath = process.env.CINDY_TEST_CODEX_BINARY;+const logger: Logger = {+ trace() {}, debug() {}, info() {}, warn() {}, error() {}, fatal() {},+ child: () => logger,+};++describe.skipIf(!binaryPath)('CodexAgent disk OAuth isolation with real app-server', () => {+ it.each([false, true])('completes a custom Responses turn with revoked OAuth=%s', async (revoked) => {+ const root = await mkdtemp(path.join(tmpdir(), 'cindy-codex-host-auth-'));+ const home = path.join(root, 'codex');+ const workingDir = path.join(root, 'work');+ await mkdir(home);+ await mkdir(workingDir);+ const calls: string[] = [];+ const server = createServer(async (req, res) => {+ for await (const chunk of req) void chunk;+ calls.push(`${req.method} ${req.url}`);+ if (req.url === '/provider/responses') {+ expect(req.headers.authorization).toBe('Bearer synthetic-invalid-api-key');+ res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });+ const events = [+ { type: 'response.created', response: { id: 'response-fixture' } },+ { type: 'response.output_item.done', item: { type: 'message', role: 'assistant', id: 'message-fixture', content: [{ type: 'output_text', text: 'fixture complete' }] } },+ { type: 'response.completed', response: { id: 'response-fixture', usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } } },+ ];+ res.end(events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(''));+ } else {+ res.writeHead(401, { 'content-type': 'application/json' });+ res.end(JSON.stringify({ error: { code: req.url === '/oauth/token' ? 'refresh_token_invalidated' : 'unauthorized', message: 'synthetic revoked token' } }));+ }+ });+ await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));+ const endpoint = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;+ const authPath = path.join(home, 'auth.json');+ let authFixture: string | undefined;+ if (revoked) {+ const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url');+ authFixture = JSON.stringify({+ auth_mode: 'chatgpt', OPENAI_API_KEY: null,+ tokens: {+ id_token: `${encode({ alg: 'none', typ: 'JWT' })}.${encode({ email: '[email protected]', 'https://api.openai.com/auth': { chatgpt_plan_type: 'business', chatgpt_user_id: 'fixture-user', chatgpt_account_id: 'fixture-account' } })}.c3ludGhldGlj`,+ access_token: 'synthetic-invalid-access-token', refresh_token: 'synthetic-invalid-refresh-token', account_id: 'fixture-account',+ }, last_refresh: new Date().toISOString(),+ });+ await writeFile(authPath, authFixture, { mode: 0o600 });+ }+ await writeFile(path.join(home, 'config.toml'), [+ 'model="fixture-model"', 'model_provider="fixture"', 'cli_auth_credentials_store="file"',+ `chatgpt_base_url="${endpoint}"`, 'check_for_update_on_startup=false',+ '[analytics]', 'enabled=false',+ '[mcp_servers.cindy_memory]', 'command="/usr/bin/false"', 'enabled=false',+ '[model_providers.fixture]', 'name="Fixture"', `base_url="${endpoint}/provider"`,+ 'wire_api="responses"', 'env_key="FIXTURE_API_KEY"', 'requires_openai_auth=false', 'supports_websockets=false', 'request_max_retries=0',+ ].join('\n'));+ const agent = new CodexAgent({+ binaryPath: binaryPath!, logger, runtimeConfig: {},+ resolveCodexLocalAuthPolicy: (providerId) => providerId === 'cprov-fixture' ? 'isolated' : 'legacy-shared',+ prepareCodexExtraSpawnConfig: async () => ({ extraArgs: [], extraEnv: {}, codexProxyActive: true }),+ auth: {+ getState: async () => ({ authenticated: true }),+ triggerLogin: async () => ({ authenticated: true }), logout: async () => {},+ getAuthEnv: async () => ({+ HOME: root, CODEX_HOME: home, TMPDIR: root, FIXTURE_API_KEY: 'synthetic-invalid-api-key',+ OPENAI_API_KEY: '', CODEX_API_KEY: '',+ CODEX_REFRESH_TOKEN_URL_OVERRIDE: `${endpoint}/oauth/token`,+ HTTP_PROXY: endpoint, HTTPS_PROXY: endpoint, ALL_PROXY: endpoint, NO_PROXY: '127.0.0.1,localhost',+ }),+ },+ });+ try {+ if (revoked) {+ await expect(agent.startSession({ sessionId: 'official-revoked', providerId: 'openai', model: 'fixture-model', workingDir })).rejects.toThrow(/refresh|revoked|logged out/i);+ expect(calls.some((call) => call.includes('/oauth/token'))).toBe(true);+ }+ const cloudCallsBeforeCustom = calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'));+ const handle = await agent.startSession({ sessionId: `fixture-${revoked}`, providerId: 'cprov-fixture', model: 'fixture-model', workingDir });+ const events = (async () => {+ for await (const event of handle.events()) {+ if (event.type === 'error') throw new Error(JSON.stringify(event));+ if (event.type === 'done') return;+ }+ })();+ await handle.send({ type: 'user', content: 'return fixture complete' }, { throwOnStartFailure: true });+ await expect.poll(() => calls.filter((call) => call === 'POST /provider/responses').length, { timeout: 10_000 }).toBe(1);+ expect(calls.filter((call) => call.includes('/oauth/token') || call.includes('/config/bundle'))).toEqual(cloudCallsBeforeCustom);+ if (authFixture) expect(await readFile(authPath, 'utf8')).toBe(authFixture);+ await events;+ await handle.close();+ } finally {+ await agent.dispose();+ await new Promise<void>((resolve) => server.close(() => resolve()));+ await rm(root, { recursive: true, force: true });+ }+ }, 45_000);+});diff --git a/packages/maker-core/src/maker.shutdown.test.ts b/packages/maker-core/src/maker.shutdown.test.tsindex 1240067509..0169372f8b 100644--- a/packages/maker-core/src/maker.shutdown.test.ts+++ b/packages/maker-core/src/maker.shutdown.test.ts@@ -1,3 +1,4 @@+import { CodexAgent } from './agents/codex/index.js';import { describe, expect, it, vi } from 'vitest';import { Maker } from './maker.js';@@ -87,13 +88,93 @@ function createAgent(handle: AgentSessionHandle): BaseAgent {} as unknown as BaseAgent;}-function createDeferred(): { promise: Promise<void>; resolve: () => void } {- let resolve!: () => void;- const promise = new Promise<void>((res) => { resolve = res; });+function createDeferred<T = void>(): { promise: Promise<T>; resolve: (value: T | PromiseLike<T>) => void } {+ let resolve!: (value: T | PromiseLike<T>) => void;+ const promise = new Promise<T>((res) => { resolve = res; });return { promise, resolve };}describe('Maker.shutdown', () => {+ it.each(['exhaust', 'exhaust-route', 'cancel'] as const)('settles Maker startup after native initialization %s', async mode => {+ const module = await import('./agents/codex/app-server/stdioTransport.js');+ let release!: () => void;+ const gate = new Promise<void>(resolve => { release = resolve; });+ const methods: string[] = [];+ let routeCurrent = true;+ const spawn = vi.spyOn(module, 'createStdioTransport').mockImplementation(() => {+ const closeHandlers = new Set<import('./agents/codex/app-server/transport.js').CloseHandler>();+ let failed = false;+ return {+ nativeSqliteInitializationFailed: () => failed,+ onLine: () => () => {},+ onClose: handler => { closeHandlers.add(handler); return () => closeHandlers.delete(handler); },+ writeLine: async line => {+ methods.push(JSON.parse(line).method);+ if (mode === 'exhaust-route' && methods.length === 3) routeCurrent = false;+ failed = true;+ for (const handler of closeHandlers) handler({ reason: 'native exited before initialize' });+ },+ close: async () => { if (mode === 'cancel') await gate; },+ };+ });+ const agent = new CodexAgent({ logger, binaryPath: 'synthetic', runtimeConfig: {},+ resolveCodexLocalAuthPolicy: () => ({ policy: 'legacy-shared', isCurrent: () => routeCurrent }),+ auth: { getState: async () => ({ authenticated: true }), getAuthEnv: async () => ({}), triggerLogin: async () => ({ authenticated: true }), logout: async () => {} },+ });+ let guarded = false;+ const failed = vi.fn(({ runtimeMayBeAlive }: { runtimeMayBeAlive?: boolean }) => { if (!runtimeMayBeAlive) guarded = false; });+ const maker = new Maker({ agents: { codex: agent }, storage: createStorage(), logger,+ lifecycleHooks: { onBeforeStart: async () => { guarded = true; }, onStartFailed: failed },+ });+ try {+ const startup = maker.createSession({ id: 'native-stop', agentKind: 'codex', model: 'fixture', providerId: 'openai', workingDir: '/fixture' });+ const rejection = expect(startup).rejects.toThrow(mode === 'cancel' ? /cancelled/ : /initialization stopped/);+ await vi.waitFor(() => expect(spawn).toHaveBeenCalled());+ if (mode === 'cancel') { const disposing = agent.dispose(); release(); await disposing; }+ await rejection;+ expect(spawn).toHaveBeenCalledTimes(mode === 'cancel' ? 1 : 3);+ expect(methods.every(method => method === 'initialize')).toBe(true);+ expect(failed).toHaveBeenCalledWith(expect.objectContaining({ runtimeMayBeAlive: false }));+ expect(guarded).toBe(false);+ expect(maker.listActiveSessions()).toEqual([]);+ } finally { release(); await maker.shutdown(); spawn.mockRestore(); }+ });++ it.each(['cancel', 'exhaust', 'spawn-exhaust'] as const)('releases the real Codex startup guard after route %s before any host exists', async (mode) => {+ let entered!: () => void;+ const waiting = new Promise<void>((resolve) => { entered = resolve; });+ let revision = 0;+ const prepareSpawn = vi.fn(async () => { revision++; return { extraArgs: [], extraEnv: {}, codexProxyActive: true }; });+ const resolveRoute = vi.fn(async () => {+ entered();+ if (mode === 'cancel') await new Promise<void>(() => {});+ const captured = revision;+ return { policy: 'isolated' as const, isCurrent: () => mode === 'spawn-exhaust' && captured === revision };+ });+ const agent = new CodexAgent({+ logger, binaryPath: process.execPath, runtimeConfig: {},+ auth: { getState: async () => ({ authenticated: true }), getAuthEnv: async () => ({}), triggerLogin: async () => ({ authenticated: true }), logout: async () => {} },+ resolveCodexLocalAuthPolicy: resolveRoute,+ ...(mode === 'spawn-exhaust' ? { prepareCodexExtraSpawnConfig: prepareSpawn } : {}),+ });+ let guarded = false;+ const failed = vi.fn(({ runtimeMayBeAlive }: { runtimeMayBeAlive?: boolean }) => { if (!runtimeMayBeAlive) guarded = false; });+ const maker = new Maker({ agents: { codex: agent }, storage: createStorage(), logger,+ lifecycleHooks: { onBeforeStart: async () => { guarded = true; }, onStartFailed: failed },+ });+ const result = maker.createSession({ id: 'route-stop', agentKind: 'codex', model: 'fixture', providerId: 'cprov-fixture', workingDir: '/fixture' });+ const rejection = expect(result).rejects.toThrow(mode === 'cancel' ? /cancelled/ : /changed repeatedly/);+ await waiting;+ if (mode === 'cancel') await agent.dispose();+ await rejection;+ expect(failed).toHaveBeenCalledWith(expect.objectContaining({ stage: 'agent-start', runtimeMayBeAlive: false }));+ expect(guarded).toBe(false);+ expect(maker.listActiveSessions()).toEqual([]);+ if (mode !== 'cancel') expect(resolveRoute).toHaveBeenCalledTimes(8);+ if (mode === 'spawn-exhaust') expect(prepareSpawn).toHaveBeenCalledTimes(8);+ await maker.shutdown();+ });+it('waits for deferred startup cleanup hooks before resolving', async () => {const stopped = createDeferred();const cleanupGate = createDeferred();diff --git a/packages/maker-core/src/maker.ts b/packages/maker-core/src/maker.tsindex 9c2f25013e..d2f417f7a7 100644--- a/packages/maker-core/src/maker.ts+++ b/packages/maker-core/src/maker.ts@@ -1481,6 +1481,12 @@ export class Maker {return this.requireAgent(agentKind).forkSdkSession(opts);}+ async requiresCodexThreadHostTransfer(+ opts: Parameters<BaseAgent['requiresCodexThreadHostTransfer']>[0],+ ): Promise<boolean> {+ return this.requireAgent('codex').requiresCodexThreadHostTransfer(opts);+ }+// ── Agent 鉴权 ───────────────────────────────────────────────────────────// 透传到 agent.deps.auth, 让 host 的 maker:auth:* IPC 不必直接拿 AuthAdapter,// renderer 也不需要写死任何 vendor 名 (统一 maker:auth:get-state(agentKind) 入口)。diff --git a/packages/maker-core/src/session.ts b/packages/maker-core/src/session.tsindex 82a65bb34b..aa5c1bf377 100644--- a/packages/maker-core/src/session.ts+++ b/packages/maker-core/src/session.ts@@ -1597,6 +1597,11 @@ export class Session {return this.handle.model;}+ /** Codex-only: 当前会话实际绑定的本地 host 身份。 */+ get codexHostKey(): string | undefined {+ return this.handle.codexHostKey;+ }+/** Codex-only: 当前会话绑定的 app-server host 是否经 loopback proxy 出口。 */get codexProxyActive(): boolean | undefined {return this.handle.codexProxyActive;