@meistrari/agent-core 0.2.0-experimental.1 → 0.2.0-experimental.2

package/src/agents/codex/codex-provider.ts

@@ -4,27 +4,33 @@ import type { AgentProvider, AgentSessionOpenInput, AgentSessionResumeInput } fr
 import type { AgentRun } from '../agent-run'
 import type { AgentTool } from '../agent-tool'
 import type { InstructionComposer } from '../instructions'
-import type { CodexAuthentication, CodexAuthProvider, CodexAuthRefreshInput, CodexAuthTokens, CodexBedrockCredentials } from './codex-auth'
+import type { SessionContextComposer } from '../session-context'
+import type { CodexAuthentication, CodexAuthProvider, CodexAuthTokens, CodexBedrockCredentials } from './codex-auth'
 import type { CodexEventMapperState, CodexNotification } from './codex-event-mapper'
 import type { CodexJsonRpcMessage, CodexServerRequest } from './codex-json-rpc-client'
-import type { ClientRequestResponsesByMethod, CodexChatGPTAuthTokensRefreshParams } from './codex-protocol'
-import { randomUUID } from 'node:crypto'
-import { lstat, open, readFile, realpath, rename, unlink } from 'node:fs/promises'
-import { basename, dirname, join, resolve } from 'node:path'
+import type { ClientRequestResponsesByMethod } from './codex-protocol'
+import { realpath } from 'node:fs/promises'
+import { resolve } from 'node:path'
 import { codexModelIdSchema } from '../../protocol'
 import { serializeAgentError } from '../agent-error-serializer'
-import { AgentNotAcceptedError, AgentProviderMetadataError, AgentProviderProtocolError, AgentProviderRuntimeError } from '../agent-runtime-error'
+import { AgentProviderMetadataError, AgentProviderProtocolError, AgentProviderRuntimeError } from '../agent-runtime-error'
 import { sessionConfiguredEvent } from '../agent-session-events'
 import { selectAgentTools, toolByName } from '../agent-tool'
 import { emptyInstructionComposer } from '../instructions'
 import { ModelRebindingRun } from '../model-rebinding-run'
+import { reconcileSelectedRepositoryInstructions, repositoryInstructionsUnavailable } from '../selected-repository-instructions'
+import { pendingSessionContext } from '../session-context'
 import { UserInputRequestStore, userInputRequestStoreRootFromTranscriptPath } from '../user-input-request'
+import { toAuthRefreshInput, toCodexLoginParams, toCodexRefreshResponse } from './codex-auth-mapper'
 import { bedrockDiagnosticMessage } from './codex-bedrock-diagnostics'
 import { CodexBedrockSessionAuth, validateBedrockCredentials } from './codex-bedrock-session-auth'
+import { CodexBrowserAuthBroker } from './codex-browser-auth-broker'
+import { codexThreadConfig } from './codex-command-mapper'
 import { cacheCodexThreadMetadata, codexNotificationFromMessage, createCodexEventMapperState, mapCodexNotification } from './codex-event-mapper'
 import { CodexJsonRpcClient, isCodexServerRequest } from './codex-json-rpc-client'
 import { CodexRun } from './codex-run'
-import { catalogRepositorySkillRoots, stableRepositoryRoots, workspaceSkillRoots } from './codex-skill-roots'
+import { CodexRunAuth, CodexRunAuthClosedError } from './codex-run-auth'
+import { catalogRepositorySkillRoots, workspaceSkillRoots } from './codex-skill-roots'
 import { runCodexDynamicTool, toCodexDynamicTools } from './codex-tool-mapper'
 
 export interface CodexStartupStageFact {
@@ -42,10 +48,18 @@ export interface CodexProviderConfig {
     environment?: Record<string, string | undefined>
     onStartupStage?: (fact: CodexStartupStageFact) => void
     instructions?: InstructionComposer
+    // Per-session context delivered once with the first prompt of a session that has a web URL.
+    sessionContext?: SessionContextComposer
+    // Product context published with the selected-repository instructions, even with no repository.
+    selectedRepositoryContext?: string
     /** Service-owned public model to inference model mapping. */
     resolveInferenceModel?: (model: string) => string
     /** Native plugin/marketplace discovery. Does not disable repository skill roots. */
     pluginsEnabled?: boolean
+    /** Serves the run's ChatGPT credential to Browser Use through a per-run socket (ChatGPT auth only). */
+    browserAuth?: boolean
+    /** Opt in to the pinned CLI’s experimental active-turn model switching. */
+    stepModelSwitching?: boolean
 }
 
 interface CodexRunHolder {
@@ -53,6 +67,8 @@ interface CodexRunHolder {
     run?: CodexRun
     authTokens?: CodexAuthTokens
     bedrockAuth?: CodexBedrockSessionAuth
+    browserAuthBroker?: CodexBrowserAuthBroker
+    auth?: CodexRunAuth
     startupFailure?: Error
 }
 type CodexAuthMaterial
@@ -73,6 +89,7 @@ type CodexThreadBootstrapResult
         | ClientRequestResponsesByMethod['thread/resume']
 interface CodexSessionBootstrapConfig {
     sessionId: string
+    sessionWebUrl?: string
     cwd: string
     workspaceRepositoryRoots: readonly string[]
     model?: string
@@ -88,9 +105,13 @@ export class CodexProvider implements AgentProvider<'codex'> {
     private readonly auth: CodexAuthentication
     private readonly onStartupStage: ((fact: CodexStartupStageFact) => void) | undefined
     private readonly instructions: InstructionComposer
+    private readonly sessionContext: SessionContextComposer | undefined
+    private readonly selectedRepositoryContext: string | undefined
     private readonly resolveInferenceModel: (model: string) => string
     private readonly hasInferenceModelMapping: boolean
     private readonly pluginsEnabled: boolean | undefined
+    private readonly browserAuth: boolean
+    private readonly stepModelSwitching: boolean
 
     private constructor(config: CodexProviderConfig) {
         this.auth = normalizeCodexAuthentication(config.auth)
@@ -99,9 +120,13 @@ export class CodexProvider implements AgentProvider<'codex'> {
         this.environment = config.environment ?? {}
         this.onStartupStage = config.onStartupStage
         this.instructions = config.instructions ?? emptyInstructionComposer
+        this.sessionContext = config.sessionContext
+        this.selectedRepositoryContext = config.selectedRepositoryContext
         this.resolveInferenceModel = config.resolveInferenceModel ?? (model => model)
         this.hasInferenceModelMapping = config.resolveInferenceModel !== undefined
         this.pluginsEnabled = config.pluginsEnabled
+        this.browserAuth = config.browserAuth === true && this.auth.kind === 'chatgpt'
+        this.stepModelSwitching = config.stepModelSwitching === true
     }
 
     static create(config: CodexProviderConfig): CodexProvider {
@@ -120,7 +145,8 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 ephemeral: false,
                 approvalPolicy: 'never',
                 sandbox: 'danger-full-access',
-                developerInstructions: this.instructions({ provider: 'codex', tools }),
+                config: codexThreadConfig(input.reasoningEffort, this.stepModelSwitching),
+                developerInstructions: input.instructions ?? this.instructions({ provider: 'codex', tools }),
                 dynamicTools: toCodexDynamicTools(tools),
             }),
         })
@@ -131,6 +157,8 @@ export class CodexProvider implements AgentProvider<'codex'> {
         return this.wrapBedrockRun(await this.resumeRawSession(input, options), input)
     }
 
+    // Bedrock model bindings are fixed per app-server session, so a model change resumes the same
+    // thread under the new binding at an idle turn boundary.
     private wrapBedrockRun(run: CodexRun, input: AgentSessionOpenInput<'codex'>): AgentRun {
         if (this.auth.kind !== 'amazon-bedrock')
             return run
@@ -153,9 +181,10 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 cwd: input.cwd,
                 approvalPolicy: 'never',
                 sandbox: 'danger-full-access',
+                config: codexThreadConfig(input.reasoningEffort, this.stepModelSwitching),
                 model: input.model ? this.resolveInferenceModel(input.model) : undefined,
                 modelProvider: this.modelProvider(),
-                developerInstructions: this.instructions({ provider: 'codex', tools }),
+                developerInstructions: input.instructions ?? this.instructions({ provider: 'codex', tools }),
             }),
             validateThread: (result) => {
                 // Resume must rebind the same provider session; adopting a different thread would silently
@@ -182,7 +211,16 @@ export class CodexProvider implements AgentProvider<'codex'> {
     }): Promise<CodexRun> {
         input.options.signal?.throwIfAborted()
         const tools = selectAgentTools(this.tools, input.config.tools)
-        const holder: CodexRunHolder = { toolsByName: toolByName(tools) }
+        const auth = this.auth.kind === 'chatgpt' ? new CodexRunAuth(this.auth.provider) : undefined
+        const browserAuthBroker = this.browserAuth && auth
+            ? await CodexBrowserAuthBroker.open({
+                    executable: this.executable,
+                    cwd: input.config.cwd,
+                    environment: this.environment,
+                    auth,
+                })
+            : undefined
+        const holder: CodexRunHolder = { toolsByName: toolByName(tools), browserAuthBroker, auth }
         const authStartedAt = performance.now()
         let authObserved = false
         const instructionBridge = this.prepareSessionBootstrap({
@@ -197,6 +235,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
             options: input.options,
             holder,
         }).catch(async (error: unknown) => {
+            await holder.browserAuthBroker?.close()
             await instructionBridge.catch(() => undefined)
             this.observeStartupStage({
                 stage: 'auth-acquisition-login',
@@ -233,6 +272,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
 
             return await this.bootstrapRun({
                 config: input.config,
+                stage: input.stage,
                 result,
                 client,
                 abortController,
@@ -252,6 +292,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 })
             }
             await stopCodexClientBestEffort(client)
+            await holder.browserAuthBroker?.close()
             input.options.signal?.throwIfAborted()
             throw holder.startupFailure ?? error
         }
@@ -269,6 +310,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
         const instructionBridgePath = await reconcileSelectedRepositoryInstructionBridge({
             cwd: input.cwd,
             repositoryRoots: input.workspaceRepositoryRoots,
+            sharedContext: this.selectedRepositoryContext,
         })
         input.startupSignal?.throwIfAborted()
         return instructionBridgePath
@@ -314,7 +356,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
             (value): StartupTaskResult<'connection', CodexConnection> => ({ source: 'connection', result: { status: 'fulfilled', value } }),
             (reason): StartupTaskResult<'connection', CodexConnection> => ({ source: 'connection', result: { status: 'rejected', reason } }),
         )
-        const authTask = this.getAuthMaterial(authAbortController.signal).then(
+        const authTask = this.getAuthMaterial(input.holder, authAbortController.signal).then(
             (value): StartupTaskResult<'auth', CodexAuthMaterial> => ({ source: 'auth', result: { status: 'fulfilled', value } }),
             (reason): StartupTaskResult<'auth', CodexAuthMaterial> => ({ source: 'auth', result: { status: 'rejected', reason } }),
         )
@@ -341,6 +383,16 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 return { ...connection.result.value, authMaterial: first.result.value }
             }
 
+            // Process-close revocation must not replace the initialize error that caused it.
+            // The native process is already closed, so its connection task can settle without
+            // injecting a new cancellation reason into that error path.
+            if (first.result.reason instanceof CodexRunAuthClosedError) {
+                const connection = await connectionTask
+                if (connection.result.status === 'rejected')
+                    throw connection.result.reason
+                await stopCodexClientBestEffort(connection.result.value.client)
+                throw first.result.reason
+            }
             connectionAbortController.abort(first.result.reason)
             const interruptedConnection = await connectionTask
             if (interruptedConnection.result.status === 'fulfilled')
@@ -352,7 +404,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
         }
     }
 
-    private async getAuthMaterial(signal: AbortSignal): Promise<CodexAuthMaterial> {
+    private async getAuthMaterial(holder: CodexRunHolder, signal: AbortSignal): Promise<CodexAuthMaterial> {
         if (this.auth.kind === 'amazon-bedrock') {
             const credentials = await this.auth.provider.getCredentials({ signal })
             signal.throwIfAborted()
@@ -363,7 +415,9 @@ export class CodexProvider implements AgentProvider<'codex'> {
             const credentials = await this.auth.provider.getApiKey({ signal })
             return { kind: 'api-key', apiKey: credentials.apiKey }
         }
-        const tokens = await this.auth.provider.getAuthTokens({ signal })
+        if (!holder.auth)
+            throw new AgentProviderProtocolError({ message: 'Codex ChatGPT authentication is not configured for this run.' })
+        const tokens = await holder.auth.acquireInitialTokens({ signal })
         return { kind: 'chatgpt', tokens }
     }
 
@@ -389,7 +443,9 @@ export class CodexProvider implements AgentProvider<'codex'> {
         try {
             client = new CodexJsonRpcClient(this.executable, {
                 cwd,
-                environment: this.environment,
+                environment: holder.browserAuthBroker
+                    ? { ...this.environment, CODING_AGENT_BROWSER_AUTH_SOCKET: holder.browserAuthBroker.socketPath }
+                    : this.environment,
                 configOverrides: [
                     ...(this.auth.kind === 'amazon-bedrock'
                         ? ['cli_auth_credentials_store="ephemeral"', 'model_provider="amazon-bedrock"', `model_providers.amazon-bedrock.aws.region=${JSON.stringify(this.auth.region)}`, 'model_providers.amazon-bedrock.aws.wire_api="responses"']
@@ -417,6 +473,9 @@ export class CodexProvider implements AgentProvider<'codex'> {
             })
             throw error
         }
+        client.child.once('close', () => {
+            void holder.browserAuthBroker?.close()
+        })
         const stopForStartupAbort = () => {
             abortController.abort(startupSignal.reason)
             void stopCodexClientBestEffort(client)
@@ -519,6 +578,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
 
     private async bootstrapRun(input: {
         config: CodexSessionBootstrapConfig
+        stage: 'thread-start' | 'thread-resume'
         result: CodexThreadBootstrapResult
         client: CodexJsonRpcClient
         abortController: AbortController
@@ -540,6 +600,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
         if (this.hasInferenceModelMapping && config.model && result.model && result.model !== this.resolveInferenceModel(config.model))
             throw new AgentProviderProtocolError({ message: 'Codex returned a model that does not match the configured inference binding.' })
 
+        state.mainThreadId = thread.id
         const metadata = {
             provider: 'codex' as const,
             sessionId: config.sessionId,
@@ -549,7 +610,7 @@ export class CodexProvider implements AgentProvider<'codex'> {
             transcriptPath: thread.path,
         }
         throwIfStartupFailed(holder)
-        const [, userInputRequests] = await Promise.all([
+        const [, userInputRequests, sessionContext] = await Promise.all([
             this.attestSessionBootstrap({
                 holder,
                 instructionBridgePath,
@@ -561,13 +622,19 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 sessionId: metadata.sessionId,
                 rootDir: userInputRequestStoreRootFromTranscriptPath(metadata.transcriptPath),
             }),
+            pendingSessionContext({
+                compose: this.sessionContext,
+                sessionWebUrl: config.sessionWebUrl,
+                resumedTranscriptPath: input.stage === 'thread-resume' ? metadata.transcriptPath : undefined,
+            }),
         ])
         startupSignal?.throwIfAborted()
         const run = new CodexRun({
-            beforePrompt: holder.bedrockAuth ? signal => holder.bedrockAuth!.beforePrompt(signal) : undefined,
-            metadata,
-            reasoningEffort: config.reasoningEffort,
+            beforePrompt: holder.bedrockAuth ? async signal => await holder.bedrockAuth!.beforePrompt(signal) : undefined,
             resolveInferenceModel: this.resolveInferenceModel,
+            metadata,
+            sessionContext,
+            settings: { model: effectiveModel, effort: config.reasoningEffort },
             client,
             requestedCwd: config.cwd,
             workspaceRepositoryRoots: config.workspaceRepositoryRoots,
@@ -578,18 +645,24 @@ export class CodexProvider implements AgentProvider<'codex'> {
                 runtimeCwd: metadata.cwd,
             }),
             reconcileInstructionBridge: async (repositoryRoots) => {
-                await reconcileSelectedRepositoryInstructionBridge({ cwd: config.cwd, repositoryRoots })
+                await reconcileSelectedRepositoryInstructionBridge({ cwd: config.cwd, repositoryRoots, sharedContext: this.selectedRepositoryContext })
             },
             userInputRequests,
             eventMapperState: state,
             abortSignal: abortController.signal,
-            onStop: () => abortController.abort(),
+            onStop: async () => {
+                abortController.abort()
+                await holder.browserAuthBroker?.close()
+            },
         })
         holder.run = run
 
         run.pushEvent({ type: 'session.started', payload: run.metadata })
         run.pushEvent(sessionConfiguredEvent({ model: run.metadata.model ?? effectiveModel, cwd: run.metadata.cwd, reasoningEffort: config.reasoningEffort, tools: config.tools, environment: this.environment }))
-        run.pushEvent({ type: 'session.state.changed', payload: { state: 'ready' } })
+        run.pushEvent({
+            type: 'session.state.changed',
+            payload: { state: userInputRequests.hasUnresolvedUserInput() ? 'waiting_for_user_input' : 'ready' },
+        })
         return run
     }
 
@@ -651,20 +724,19 @@ export class CodexProvider implements AgentProvider<'codex'> {
     }
 
     private async cacheSpawnedSubagentThreadMetadata(input: { notification: CodexNotification, state: CodexEventMapperState, client: CodexJsonRpcClient }): Promise<void> {
-        const threadId = spawnedSubagentThreadId(input.notification)
-        if (!threadId)
-            return
-
-        let thread: Parameters<typeof cacheCodexThreadMetadata>[0]
-        try {
-            const result = await input.client.request('thread/read', { threadId, includeTurns: false })
-            thread = result.thread
-        }
-        catch {
-            // Metadata improves display labels only; lifecycle mapping can proceed without it.
-            return
-        }
-        cacheCodexThreadMetadata(thread, input.state)
+        const threadIds = spawnedSubagentThreadIds(input.notification)
+        await Promise.all(threadIds.map(async (threadId) => {
+            let thread: Parameters<typeof cacheCodexThreadMetadata>[0]
+            try {
+                const result = await input.client.request('thread/read', { threadId, includeTurns: false })
+                thread = result.thread
+            }
+            catch {
+                // Metadata improves display labels only; lifecycle mapping can proceed without it.
+                return
+            }
+            cacheCodexThreadMetadata(thread, input.state)
+        }))
     }
 
     private async login(input: {
@@ -718,9 +790,9 @@ export class CodexProvider implements AgentProvider<'codex'> {
             return
         }
         try {
-            if (this.auth.kind !== 'chatgpt')
-                throw new AgentProviderProtocolError({ message: 'Codex requested ChatGPT token refresh while using API-key authentication.' })
-            const refreshed = await this.auth.provider.refreshAuthTokens(toAuthRefreshInput(request.params, current))
+            if (!holder.auth)
+                throw new AgentProviderProtocolError({ message: 'Codex requested ChatGPT token refresh without ChatGPT authentication.' })
+            const refreshed = await holder.auth.refreshAuthTokens(toAuthRefreshInput(request.params, current))
             holder.authTokens = refreshed
             client.respond(request.id, toCodexRefreshResponse(refreshed))
         }
@@ -812,135 +884,15 @@ function throwIfStartupFailed(holder: CodexRunHolder): void {
 }
 
 const SELECTED_REPOSITORY_INSTRUCTION_BRIDGE_FILENAME = 'AGENTS.override.md'
-const SELECTED_REPOSITORY_INSTRUCTION_BRIDGE_SENTINEL = '<!-- coding-agent-managed-selected-repository-instructions -->'
-
-type InstructionBridgeOwnership = 'missing' | 'managed' | 'unowned'
 
-async function reconcileSelectedRepositoryInstructionBridge(input: { cwd: string, repositoryRoots: readonly string[] }): Promise<string> {
+async function reconcileSelectedRepositoryInstructionBridge(input: { cwd: string, repositoryRoots: readonly string[], sharedContext?: string }): Promise<string> {
     const instructionBridgePath = resolve(input.cwd, SELECTED_REPOSITORY_INSTRUCTION_BRIDGE_FILENAME)
-    let ownership: InstructionBridgeOwnership
-    try {
-        ownership = await readInstructionBridgeOwnership(instructionBridgePath)
-    }
-    catch (error) {
-        if (!(error instanceof AgentProviderRuntimeError))
-            throw error
-        throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause: error })
-    }
-    const repositoryRoots = stableRepositoryRoots(input.repositoryRoots)
-
-    if (repositoryRoots.length === 0) {
-        if (ownership === 'managed') {
-            try {
-                await removeManagedInstructionBridge(instructionBridgePath)
-            }
-            catch (error) {
-                if (!(error instanceof AgentProviderRuntimeError))
-                    throw error
-                throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause: error })
-            }
-        }
-        return instructionBridgePath
-    }
-
-    if (ownership === 'unowned') {
-        const cause = new AgentProviderRuntimeError({
-            message: 'Refusing to overwrite an AGENTS.override.md not owned by the Coding Agent runtime.',
-            details: { instructionBridgePath },
-            retryable: false,
-        })
-        throw repositoryInstructionsUnavailable({ recoveryKind: 'terminal', cause })
-    }
-
-    try {
-        await writeInstructionBridgeAtomically({
-            instructionBridgePath,
-            content: selectedRepositoryInstructionBridge(repositoryRoots),
-        })
-    }
-    catch (error) {
-        if (!(error instanceof AgentProviderRuntimeError))
-            throw error
-        throw repositoryInstructionsUnavailable({ recoveryKind: 'retry', cause: error })
-    }
+    await reconcileSelectedRepositoryInstructions({ provider: 'codex', path: instructionBridgePath, repositoryRoots: input.repositoryRoots, sharedContext: input.sharedContext })
     return instructionBridgePath
 }
 
-async function readInstructionBridgeOwnership(instructionBridgePath: string): Promise<InstructionBridgeOwnership> {
-    let entry
-    try {
-        entry = await lstat(instructionBridgePath)
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT')
-            return 'missing'
-        throw new AgentProviderRuntimeError({
-            message: 'Failed to inspect the selected-repository instruction bridge.',
-            details: { instructionBridgePath },
-            retryable: true,
-            cause: error,
-        })
-    }
-
-    if (!entry.isFile() || entry.isSymbolicLink())
-        return 'unowned'
-
-    let content: string
-    try {
-        content = await readFile(instructionBridgePath, 'utf8')
-    }
-    catch (error) {
-        throw new AgentProviderRuntimeError({
-            message: 'Failed to inspect the selected-repository instruction bridge.',
-            details: { instructionBridgePath },
-            retryable: true,
-            cause: error,
-        })
-    }
-
-    return firstLine(content) === SELECTED_REPOSITORY_INSTRUCTION_BRIDGE_SENTINEL ? 'managed' : 'unowned'
-}
-
-async function writeInstructionBridgeAtomically(input: { instructionBridgePath: string, content: string }): Promise<void> {
-    const tempPath = join(
-        dirname(input.instructionBridgePath),
-        `.${basename(input.instructionBridgePath)}.${process.pid}.${randomUUID()}.tmp`,
-    )
-    let tempFile: Awaited<ReturnType<typeof open>> | undefined
-    try {
-        tempFile = await open(tempPath, 'wx', 0o640)
-        await tempFile.chmod(0o640)
-        await tempFile.writeFile(input.content, 'utf8')
-        await tempFile.close()
-        tempFile = undefined
-        await rename(tempPath, input.instructionBridgePath)
-    }
-    catch (error) {
-        await tempFile?.close().catch(() => undefined)
-        await unlink(tempPath).catch(() => undefined)
-        throw new AgentProviderRuntimeError({
-            message: 'Failed to publish the selected-repository instruction bridge.',
-            details: { instructionBridgePath: input.instructionBridgePath },
-            retryable: true,
-            cause: error,
-        })
-    }
-}
-
-async function removeManagedInstructionBridge(instructionBridgePath: string): Promise<void> {
-    try {
-        await unlink(instructionBridgePath)
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT')
-            return
-        throw new AgentProviderRuntimeError({
-            message: 'Failed to remove the stale selected-repository instruction bridge.',
-            details: { instructionBridgePath },
-            retryable: true,
-            cause: error,
-        })
-    }
+function normalizeCodexAuthentication(auth: CodexAuthProvider | CodexAuthentication): CodexAuthentication {
+    return 'kind' in auth ? auth : { kind: 'chatgpt', provider: auth }
 }
 
 async function requireSelectedRepositoryInstructionSource(input: {
@@ -997,42 +949,6 @@ async function requireSelectedRepositoryInstructionSource(input: {
     throw repositoryInstructionsUnavailable({ recoveryKind: 'terminal', cause })
 }
 
-function repositoryInstructionsUnavailable(input: {
-    recoveryKind: 'retry' | 'terminal'
-    cause: AgentProviderRuntimeError
-}): AgentNotAcceptedError {
-    return new AgentNotAcceptedError({
-        message: 'Selected repository instructions are unavailable.',
-        recovery: { kind: input.recoveryKind, reason: 'repository_instructions_unavailable' },
-        cause: input.cause,
-    })
-}
-
-function selectedRepositoryInstructionBridge(repositoryRoots: readonly string[]): string {
-    return [
-        SELECTED_REPOSITORY_INSTRUCTION_BRIDGE_SENTINEL,
-        '# Selected repository instructions',
-        '',
-        'Selected repository roots:',
-        ...repositoryRoots.map(root => `- ${JSON.stringify(root)}`),
-        '',
-        'For each repository root, you must:',
-        '- Inspect `AGENTS.override.md` first; if it does not exist, inspect `AGENTS.md`.',
-        '- Follow every documentation file referenced by the applicable AGENTS file.',
-        '- Before editing nested files, re-check for more-local `AGENTS.override.md` or `AGENTS.md` files.',
-        '',
-        'Runtime and developer instructions take precedence over these repository instructions.',
-        'Repository instructions apply only within their own repository.',
-        'If selected repositories contain irreconcilable instructions, report the conflict instead of resolving it by repository input order.',
-        '',
-    ].join('\n')
-}
-
-function firstLine(content: string): string {
-    const lineEnd = content.indexOf('\n')
-    return lineEnd === -1 ? content : content.slice(0, lineEnd)
-}
-
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
     return error instanceof Error && 'code' in error
 }
@@ -1056,40 +972,6 @@ async function stopCodexClientBestEffort(client: CodexJsonRpcClient): Promise<vo
     await client.stop().catch(() => undefined)
 }
 
-function toCodexLoginParams(tokens: CodexAuthTokens): {
-    type: 'chatgptAuthTokens'
-    accessToken: string
-    chatgptAccountId: string
-    chatgptPlanType?: string | null
-} {
-    return {
-        type: 'chatgptAuthTokens',
-        accessToken: tokens.accessToken,
-        chatgptAccountId: tokens.chatgptAccountId,
-        chatgptPlanType: tokens.chatgptPlanType ?? null,
-    }
-}
-
-function normalizeCodexAuthentication(auth: CodexAuthProvider | CodexAuthentication): CodexAuthentication {
-    return 'kind' in auth ? auth : { kind: 'chatgpt', provider: auth }
-}
-
-function toAuthRefreshInput(params: CodexChatGPTAuthTokensRefreshParams, tokens: CodexAuthTokens): CodexAuthRefreshInput {
-    return {
-        reason: params.reason,
-        rejectedTokenGeneration: tokens.accessTokenGeneration,
-        rejectedTokenFingerprint: tokens.accessTokenFingerprint,
-    }
-}
-
-function toCodexRefreshResponse(tokens: CodexAuthTokens): { accessToken: string, chatgptAccountId: string, chatgptPlanType?: string | null } {
-    return {
-        accessToken: tokens.accessToken,
-        chatgptAccountId: tokens.chatgptAccountId,
-        chatgptPlanType: tokens.chatgptPlanType ?? null,
-    }
-}
-
 function redactSerializedError(error: unknown, accessToken: string): { message: string, code?: string, name?: string, stack?: string } {
     return redactAgentError(serializeAgentError(error), accessToken)
 }
@@ -1114,13 +996,13 @@ function firstCodexModelId(...values: Array<string | null | undefined>): CodexMo
     return undefined
 }
 
-function spawnedSubagentThreadId(notification: CodexNotification): string | undefined {
+function spawnedSubagentThreadIds(notification: CodexNotification): string[] {
     if (notification.method !== 'item/completed')
-        return undefined
+        return []
 
     const item = notification.params.item
     if (item.type !== 'collabAgentToolCall' || item.tool !== 'spawnAgent' || item.status === 'failed')
-        return undefined
+        return []
 
-    return item.receiverThreadIds.at(0)
+    return [...new Set(item.receiverThreadIds.filter(threadId => threadId.length > 0))]
 }