@myagentroam/node 0.9.124 → 0.9.126

package/dist/runner/codex/conversation-parser.js

@@ -499,7 +499,14 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                 summaryCode: 'CONTEXT_COMPACTED'
             }
         };
-    return codexUnknownOfficialItem(base, value);
+    const special = codexSpecialItem(value);
+    return special === undefined
+        ? codexUnknownOfficialItem(base, value)
+        : {
+            ...base,
+            ...special,
+            status: value.type === 'collabAgentToolCall' ? codexItemStatus(value.status, true) : base.status
+        };
 }
 export function codexLiveConversationItem(value, completed, imageAttachments = []) {
     if (typeof value.type !== 'string')
@@ -687,7 +694,16 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             merge: true
         };
     }
-    return codexUnknownLiveItem(itemId, value.type, completed);
+    const special = codexSpecialItem(value);
+    return special === undefined
+        ? codexUnknownLiveItem(itemId, value.type, completed)
+        : {
+            itemId,
+            kind: special.kind,
+            status: special.kind === 'tool_call' ? codexItemStatus(value.status, completed) : 'COMPLETED',
+            payload: special.payload,
+            merge: special.kind === 'tool_call'
+        };
 }
 function normalizeCodexFileChanges(changes) {
     return changes.flatMap((value) => {
@@ -718,6 +734,128 @@ function normalizeCodexFileChanges(changes) {
 function nonnegativeIntegerOrNull(value) {
     return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
+function codexSpecialItem(value) {
+    if (value.type === 'sleep') {
+        const durationMs = nonnegativeIntegerOrNull(value.durationMs);
+        return {
+            kind: 'tool_call',
+            payload: normalizeCodexTool({
+                name: 'clock.sleep',
+                namespace: 'clock',
+                inputSummary: durationMs === null ? null : `${durationMs} ms`
+            }).payload
+        };
+    }
+    if (value.type === 'imageView')
+        return {
+            kind: 'tool_call',
+            payload: normalizeCodexTool({
+                name: 'view_image',
+                namespace: 'codex',
+                inputSummary: typeof value.path === 'string' ? compactRunnerText(value.path, 4_096) : null
+            }).payload
+        };
+    if (value.type === 'subAgentActivity') {
+        const activity = typeof value.kind === 'string' ? value.kind : '';
+        const operation = activity === 'started'
+            ? 'START'
+            : activity === 'interrupted'
+                ? 'CANCEL'
+                : activity === 'interacted' || activity === 'completed'
+                    ? 'STATUS'
+                    : undefined;
+        if (operation === undefined)
+            return undefined;
+        const agentId = typeof value.agentThreadId === 'string' ? compactRunnerText(value.agentThreadId, 128) : '';
+        const agentPath = typeof value.agentPath === 'string' ? compactRunnerText(value.agentPath, 500) : '';
+        return {
+            kind: 'tool_call',
+            payload: {
+                ...normalizeCodexTool({
+                    name: 'subagent_activity',
+                    namespace: 'codex',
+                    outputSummary: activity
+                }).payload,
+                ...(agentPath ? { title: agentPath } : {}),
+                subagentOperation: operation,
+                subagentId: agentId || null
+            }
+        };
+    }
+    if (value.type === 'collabAgentToolCall') {
+        const names = {
+            spawnAgent: 'spawn_agent',
+            sendInput: 'send_input',
+            resumeAgent: 'resume_agent',
+            wait: 'wait_agent',
+            closeAgent: 'close_agent',
+            sendMessage: 'send_message',
+            followupTask: 'followup_task',
+            interruptAgent: 'interrupt_agent',
+            listAgents: 'list_agents'
+        };
+        const toolName = typeof value.tool === 'string' ? names[value.tool] : undefined;
+        if (toolName === undefined)
+            return undefined;
+        const targets = Array.isArray(value.receiverThreadIds)
+            ? value.receiverThreadIds.filter((id) => typeof id === 'string')
+            : [];
+        const input = {
+            ...(typeof value.prompt === 'string' ? { prompt: value.prompt } : {}),
+            ...(targets.length === 1 ? { target: targets[0] } : {}),
+            ...(targets.length > 1 ? { receiverThreadIds: targets } : {}),
+            ...(typeof value.model === 'string' ? { model: value.model } : {})
+        };
+        const normalized = normalizeCodexTool({
+            name: toolName,
+            namespace: 'collaboration',
+            rawInput: input,
+            inputSummary: codexCompactJson(input) || null,
+            outputSummary: codexCompactJson({
+                status: value.status,
+                agentsStates: value.agentsStates
+            }) || null
+        });
+        const effort = value.reasoningEffort;
+        const modelId = typeof value.model === 'string' ? compactRunnerText(value.model, 128) : '';
+        return {
+            kind: 'tool_call',
+            payload: {
+                ...normalized.payload,
+                ...(modelId ? { subagentModelId: modelId } : {}),
+                ...(typeof effort === 'string' &&
+                    ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(effort)
+                    ? { subagentReasoningEffort: effort }
+                    : {})
+            }
+        };
+    }
+    const notice = codexNotice(value);
+    return notice === undefined
+        ? undefined
+        : {
+            kind: 'warning',
+            payload: { code: notice.code, message: notice.message, recoverable: true }
+        };
+}
+function codexNotice(value) {
+    if (value.type === 'hookPrompt') {
+        const count = Array.isArray(value.fragments) ? value.fragments.length : 0;
+        return {
+            code: 'CODEX_HOOK_PROMPT',
+            message: `Hook prompt added (${count} ${count === 1 ? 'fragment' : 'fragments'}).`
+        };
+    }
+    if (value.type === 'enteredReviewMode' || value.type === 'exitedReviewMode') {
+        const action = value.type === 'enteredReviewMode' ? 'Entered' : 'Exited';
+        const review = typeof value.review === 'string' ? compactRunnerText(value.review, 400) : '';
+        return {
+            code: value.type === 'enteredReviewMode' ? 'CODEX_REVIEW_STARTED' : 'CODEX_REVIEW_ENDED',
+            message: `${action} review mode${review ? `: ${review}` : ''}`
+        };
+    }
+    return undefined;
+}
 function codexUnknownOfficialItem(base, value) {
     if (value.type === 'userMessage' || value.type === 'agentMessage')
         return undefined;
@@ -835,6 +973,8 @@ export function codexItemStatus(value, completed) {
         return 'FAILED';
     if (value === 'declined')
         return 'DECLINED';
+    if (value === 'interrupted')
+        return 'INTERRUPTED';
     return completed || value === 'completed' ? 'COMPLETED' : 'IN_PROGRESS';
 }
 export function codexContentText(value) {

package/dist/runner/codex/managed-run-controller.js

@@ -35,8 +35,8 @@ export class CodexManagedRunController {
             this.runner.prepareEnvironment(context.secretEnvironment, environmentLeaseId);
             let modes;
             try {
-                await this.runner.start();
-                modes = await this.runner.listCollaborationModes();
+                await this.runner.start(environmentLeaseId);
+                modes = await this.runner.listCollaborationModes(environmentLeaseId);
             }
             finally {
                 this.runner.releaseEnvironment(environmentLeaseId);
@@ -67,7 +67,7 @@ export class CodexManagedRunController {
             const runId = crypto.randomUUID();
             this.runner.prepareEnvironment(context.secretEnvironment, runId);
             try {
-                await this.runner.start();
+                await this.runner.start(runId);
                 return await this.compact(session, threadId, runId, context.initiatedByUserId);
             }
             catch (error) {
@@ -99,8 +99,8 @@ export class CodexManagedRunController {
         });
         this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
         try {
-            await this.runner.resumeThread(threadId, session.cwd);
-            await this.runner.request('thread/compact/start', { threadId });
+            await this.runner.resumeThread(threadId, session.cwd, undefined, runId);
+            await this.runner.request('thread/compact/start', { threadId }, runId);
             return {
                 command: 'compact',
                 run: this.host.run(runId),
@@ -158,15 +158,15 @@ export class CodexManagedRunController {
         }
         if (notification.requestId !== undefined &&
             notification.method === 'mcpServer/elicitation/request' &&
-            activeRun.goalMcp === true &&
-            params.serverName === 'myagentroam_goal' &&
+            ((activeRun.goalMcp === true && params.serverName === 'myagentroam_goal') ||
+                (activeRun.scheduleMcp === true && params.serverName === 'mar_schedule')) &&
             isPlainRecord(params._meta) &&
             params._meta.codex_approval_kind === 'mcp_tool_call') {
             this.runner.respond(notification.requestId, {
                 action: 'accept',
                 content: {},
                 _meta: null
-            });
+            }, runId);
             return;
         }
         if (notification.method === 'item/agentMessage/delta' && typeof params.delta === 'string') {
@@ -252,9 +252,12 @@ export class CodexManagedRunController {
         }
     }
     requestApproval(runId, notification) {
-        const approvalId = `codex:${notification.requestId}`;
+        const approvalId = `codex:${runId}:${notification.requestId}`;
         const expiresAt = Date.now() + 10 * 60_000;
-        this.runner.execution.approvals.set(approvalId, notification.requestId);
+        this.runner.execution.approvals.set(approvalId, {
+            runId,
+            requestId: notification.requestId
+        });
         try {
             this.host.createApproval({
                 runId,
@@ -278,7 +281,7 @@ export class CodexManagedRunController {
         const questions = codexUserInputQuestions(params.questions);
         if (questions.length === 0) {
             try {
-                this.runner.respond(nativeRequestId, { answers: {} });
+                this.runner.respond(nativeRequestId, { answers: {} }, runId);
             }
             catch {
                 // A disconnected App Server cannot receive a malformed-request response.
@@ -286,7 +289,7 @@ export class CodexManagedRunController {
             return;
         }
         const requestId = String(nativeRequestId);
-        this.runner.execution.userInputs.set(requestId, {
+        this.runner.execution.userInputs.set(`${runId}\0${requestId}`, {
             runId,
             requestId: nativeRequestId,
             questions: questions.map((question) => ({
@@ -391,7 +394,7 @@ export class CodexManagedRunController {
     async run(payload, attachments) {
         const { runId, sessionId, input, cwd } = payload;
         try {
-            await this.runner.start();
+            await this.runner.start(runId);
             if (this.host.completeCancelled(runId, cwd)) {
                 this.runner.releaseEnvironment(runId);
                 return;
@@ -420,8 +423,8 @@ export class CodexManagedRunController {
             for (let attempt = 0; attempt < 2; attempt += 1) {
                 try {
                     const threadResult = typeof payload.externalSessionId === 'string'
-                        ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
-                        : await this.runner.startThread(cwd, configuration);
+                        ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration, runId)
+                        : await this.runner.startThread(cwd, configuration, runId);
                     if (this.host.completeCancelled(runId, cwd)) {
                         this.runner.releaseEnvironment(runId);
                         return;
@@ -431,9 +434,10 @@ export class CodexManagedRunController {
                         sessionId,
                         threadId,
                         cwd,
-                        goalMcp: hasGoalMcp(payload.mcpServers)
+                        goalMcp: hasGoalMcp(payload.mcpServers),
+                        scheduleMcp: hasScheduleMcp(payload.mcpServers)
                     });
-                    turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments);
+                    turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments, runId);
                     break;
                 }
                 catch (error) {
@@ -457,7 +461,8 @@ export class CodexManagedRunController {
                 threadId,
                 turnId,
                 cwd,
-                goalMcp: hasGoalMcp(payload.mcpServers)
+                goalMcp: hasGoalMcp(payload.mcpServers),
+                scheduleMcp: hasScheduleMcp(payload.mcpServers)
             });
             this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });
             if (this.host.runStatus(runId) === 'CANCELLING') {
@@ -492,3 +497,6 @@ export class CodexManagedRunController {
 function hasGoalMcp(value) {
     return isPlainRecord(value) && isPlainRecord(value.myagentroam_goal);
 }
+function hasScheduleMcp(value) {
+    return isPlainRecord(value) && isPlainRecord(value.mar_schedule);
+}

package/dist/runner/codex-runner.js

@@ -3,7 +3,6 @@ import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
-import { createHash } from 'node:crypto';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
 import { codexThreadCwd, deduplicateDirectSessions, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
@@ -11,30 +10,35 @@ import { codexSessionControl } from '../codex-app-server.js';
 import { extractId } from '../util/runner-native-session-parsers.js';
 import { nodeLog } from '../operational.js';
 const CODEX_MODEL_CACHE_MS = 10 * 60 * 1_000;
-const CODEX_PROFILE_ENTRY_TTL_MS = 30 * 60 * 1_000;
 const CODEX_MODEL_FAILURE_RETRY_MS = 30 * 1_000;
 const CODEX_MODEL_PAGE_SIZE = 100;
 const CODEX_MODEL_MAX_PAGES = 6;
 export class CodexRunner extends AbstractRunner {
-    client;
     profileClientFactory;
     name = 'codex';
     discoveryScope = 'ALL_WORKSPACES';
     execution = new CodexExecutionState();
     fastEnabled = false;
-    environmentFingerprint;
-    environmentRuns = new Set();
+    runClients = new Map();
+    notificationListeners = new Set();
+    clientNotificationDisposers = new Map();
     profileCache;
     profileCacheVersion;
     profileCacheTimer;
     profileRefresh;
+    profileRefreshVersion;
     profileClients = new Set();
     profileGeneration = 0;
-    constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
+    runClientFactory;
+    constructor(client, profileClientFactory = () => new CodexAppServerClient(), runClientFactory) {
         super();
-        this.client = client;
         this.profileClientFactory = profileClientFactory;
+        this.client = client ?? new CodexAppServerClient();
+        this.runClientFactory =
+            runClientFactory ??
+                (client === undefined ? () => new CodexAppServerClient() : () => this.client);
     }
+    client;
     profile(capabilities) {
         const base = declaredRunnerProfiles({
             codexAvailable: capabilities.codex.available,
@@ -56,6 +60,14 @@ export class CodexRunner extends AbstractRunner {
         if (!capabilities.codex.available)
             return { ...base, models: [] };
         const version = capabilities.codex.version;
+        if (this.profileRefresh !== undefined && this.profileRefreshVersion !== version) {
+            this.profileGeneration += 1;
+            this.profileRefresh = undefined;
+            this.profileRefreshVersion = undefined;
+            if (this.profileCacheTimer !== undefined)
+                clearTimeout(this.profileCacheTimer);
+            this.profileCacheTimer = undefined;
+        }
         const now = Date.now();
         const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
         if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
@@ -85,8 +97,10 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            if (generation === this.profileGeneration)
+            if (generation === this.profileGeneration) {
                 this.cacheProfile(version, cache);
+                this.scheduleProfileRefresh(CODEX_MODEL_CACHE_MS, version, base, environment);
+            }
             return cache.profile;
         })
             .catch((error) => {
@@ -98,6 +112,7 @@ export class CodexRunner extends AbstractRunner {
             const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
             if (cached !== undefined) {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
+                this.scheduleProfileRefresh(CODEX_MODEL_FAILURE_RETRY_MS, version, base, environment);
                 return cached.profile;
             }
             this.cacheProfile(version, {
@@ -107,25 +122,30 @@ export class CodexRunner extends AbstractRunner {
                 successful: false,
                 retryAt: Date.now() + CODEX_MODEL_FAILURE_RETRY_MS
             });
+            this.scheduleProfileRefresh(CODEX_MODEL_FAILURE_RETRY_MS, version, base, environment);
             return { ...base, models: [] };
         })
             .finally(() => {
-            if (this.profileRefresh === refresh)
+            if (this.profileRefresh === refresh) {
                 this.profileRefresh = undefined;
+                this.profileRefreshVersion = undefined;
+            }
         });
         this.profileRefresh = refresh;
+        this.profileRefreshVersion = version;
         return refresh;
     }
     cacheProfile(version, cache) {
-        if (this.profileCacheTimer !== undefined)
-            clearTimeout(this.profileCacheTimer);
         this.profileCache = cache;
         this.profileCacheVersion = version;
+    }
+    scheduleProfileRefresh(delayMs, version, base, environment) {
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
         this.profileCacheTimer = setTimeout(() => {
             this.profileCacheTimer = undefined;
-            this.profileCache = undefined;
-            this.profileCacheVersion = undefined;
-        }, CODEX_PROFILE_ENTRY_TTL_MS);
+            void this.refreshCodexProfile(version, base, environment);
+        }, delayMs);
         this.profileCacheTimer.unref();
     }
     async fetchCodexProfile(base, environment) {
@@ -255,7 +275,8 @@ export class CodexRunner extends AbstractRunner {
     async readManagedRunnerTitle(session, nativeSessionId) {
         void session;
         await this.start();
-        return extractCodexThreads(await this.listThreads()).find((thread) => thread.id === nativeSessionId)?.title;
+        const thread = extractCodexThreads(await this.listThreads()).find((candidate) => candidate.id === nativeSessionId);
+        return thread?.titleOrigin === 'OFFICIAL' ? thread.title : undefined;
     }
     nativeImageRoots(session) {
         return [
@@ -295,13 +316,14 @@ export class CodexRunner extends AbstractRunner {
         return this.profileCache;
     }
     async resumeExternal(external, context) {
+        const threadId = external.externalSessionId;
         if (external.runner !== this.name ||
             external.nativeControl !== 'EXTERNAL' ||
-            external.externalSessionId === null ||
+            threadId === null ||
             !context.available)
             return { failureCode: 'RUNNER_UNAVAILABLE' };
         try {
-            await this.resumeThread(external.externalSessionId, external.cwd);
+            await this.withTemporaryClient((client) => client.resumeThread(threadId, external.cwd));
             const projection = context.projectionFor(external);
             if (projection !== undefined) {
                 const promoted = context.promote(projection.id);
@@ -343,7 +365,7 @@ export class CodexRunner extends AbstractRunner {
                 externalSessionId: thread.id,
                 cwd,
                 ...(thread.title === undefined ? {} : { title: thread.title }),
-                titleOrigin: 'OFFICIAL'
+                ...(thread.titleOrigin === undefined ? {} : { titleOrigin: thread.titleOrigin })
             }));
         }
         for (const entry of await discoverAllNativeSessions(this.name)) {
@@ -412,107 +434,148 @@ export class CodexRunner extends AbstractRunner {
         };
     }
     onNotification(listener) {
-        return this.client.onNotification(listener);
-    }
-    start() {
-        return this.client.start();
+        this.notificationListeners.add(listener);
+        this.attachNotifications(this.client);
+        for (const client of this.runClients.values())
+            this.attachNotifications(client);
+        return () => this.notificationListeners.delete(listener);
+    }
+    async start(runId) {
+        const client = this.clientFor(runId);
+        try {
+            await client.start();
+        }
+        catch (error) {
+            if (runId === undefined ||
+                !(error instanceof Error) ||
+                error.message !== 'CODEX_APP_SERVER_STOPPED' ||
+                this.runClients.get(runId) !== client)
+                throw error;
+            await client.start();
+        }
     }
     async recoverMissingRollout(runId, error) {
         if (!isCodexRolloutMissingError(error))
             return false;
-        if ([...this.environmentRuns].some((activeRunId) => activeRunId !== runId))
+        const client = this.clientFor(runId);
+        if ([...this.runClients].some(([activeRunId, activeClient]) => activeRunId !== runId && activeClient === client))
             return false;
-        if ([...this.execution.runs.keys()].some((activeRunId) => activeRunId !== runId))
+        if ([...this.execution.runs].some(([activeRunId]) => activeRunId !== runId && this.runClients.get(activeRunId) === client))
             return false;
         nodeLog('runner.codex.rollout.recovering', { runId });
-        await this.client.restart();
+        await client.restart();
         return true;
     }
     prepareEnvironment(environment, runId) {
-        if (Object.keys(environment).length === 0 && this.environmentFingerprint === undefined) {
-            this.environmentRuns.add(runId);
+        if (this.runClients.has(runId))
             return;
-        }
-        const fingerprint = createHash('sha256')
-            .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
-            .digest('base64url');
-        if (fingerprint === this.environmentFingerprint) {
-            this.environmentRuns.add(runId);
-            return;
-        }
-        if (this.environmentRuns.size > 0 || this.execution.runs.size > 0)
-            throw new Error('CODEX_SECRET_ENVIRONMENT_CONFLICT');
-        this.client.stop();
-        this.client.configureEnvironment(environment);
-        this.environmentFingerprint = fingerprint;
-        this.environmentRuns.add(runId);
+        const client = this.runClientFactory();
+        if (Object.keys(environment).length > 0)
+            client.configureEnvironment(environment);
+        this.attachNotifications(client);
+        this.runClients.set(runId, client);
     }
     releaseEnvironment(runId) {
-        this.environmentRuns.delete(runId);
-        if (this.environmentRuns.size !== 0 || this.environmentFingerprint === undefined)
+        const client = this.runClients.get(runId);
+        if (client === undefined)
             return;
-        this.client.stop();
-        this.client.clearEnvironment();
-        this.environmentFingerprint = undefined;
+        this.runClients.delete(runId);
+        if (client !== this.client && ![...this.runClients.values()].includes(client)) {
+            this.detachNotifications(client);
+            client.stop();
+            client.clearEnvironment();
+        }
     }
     stop() {
         this.profileGeneration += 1;
         for (const profileClient of this.profileClients)
             profileClient.stop();
         this.profileClients.clear();
+        for (const client of new Set(this.runClients.values()))
+            if (client !== this.client) {
+                this.detachNotifications(client);
+                client.stop();
+                client.clearEnvironment();
+            }
+        this.runClients.clear();
         this.client.stop();
-        if (this.environmentFingerprint !== undefined)
-            this.client.clearEnvironment();
-        this.environmentFingerprint = undefined;
-        this.environmentRuns.clear();
         if (this.profileCacheTimer !== undefined)
             clearTimeout(this.profileCacheTimer);
         this.profileCacheTimer = undefined;
         this.profileCache = undefined;
         this.profileCacheVersion = undefined;
         this.profileRefresh = undefined;
+        this.profileRefreshVersion = undefined;
+    }
+    clientFor(runId) {
+        return runId === undefined ? this.client : (this.runClients.get(runId) ?? this.client);
+    }
+    async withTemporaryClient(operation) {
+        const client = this.runClientFactory();
+        try {
+            await client.start();
+            return await operation(client);
+        }
+        finally {
+            if (client !== this.client)
+                await client.stopAndWait();
+        }
+    }
+    attachNotifications(client) {
+        if (this.clientNotificationDisposers.has(client))
+            return;
+        this.clientNotificationDisposers.set(client, client.onNotification((notification) => {
+            for (const listener of this.notificationListeners)
+                listener(notification);
+        }));
+    }
+    detachNotifications(client) {
+        this.clientNotificationDisposers.get(client)?.();
+        this.clientNotificationDisposers.delete(client);
     }
-    request(method, params) {
-        return this.client.request(method, params);
+    request(method, params, runId) {
+        return this.clientFor(runId).request(method, params);
     }
-    respond(requestId, result) {
-        this.client.respond(requestId, result);
+    respond(requestId, result, runId) {
+        this.clientFor(runId).respond(requestId, result);
     }
     listThreads() {
         return this.client.listThreads();
     }
-    startThread(cwd, configuration) {
-        return this.client.startThread(cwd, configuration);
+    startThread(cwd, configuration, runId) {
+        return this.clientFor(runId).startThread(cwd, configuration);
     }
     forkThread(threadId, cwd, lastTurnId, configuration) {
         return this.client.forkThread(threadId, cwd, lastTurnId, configuration);
     }
     async forkNative(session, boundary, title) {
-        if (session.externalSessionId === null)
+        const threadId = session.externalSessionId;
+        if (threadId === null)
             throw new Error('SESSION_REWIND_UNAVAILABLE');
-        await this.start();
         const configuration = { model: session.model, effort: session.effort, access: session.access };
-        const result = boundary === null
-            ? await this.startThread(session.cwd, configuration)
-            : await this.forkThread(session.externalSessionId, session.cwd, boundary, configuration);
-        const threadId = extractId(result, 'thread');
-        await this.setThreadName(threadId, title);
-        return threadId;
+        return this.withTemporaryClient(async (client) => {
+            const result = boundary === null
+                ? await client.startThread(session.cwd, configuration)
+                : await client.forkThread(threadId, session.cwd, boundary, configuration);
+            const forkedThreadId = extractId(result, 'thread');
+            await client.setThreadName(forkedThreadId, title);
+            return forkedThreadId;
+        });
     }
-    resumeThread(threadId, cwd, configuration) {
-        return this.client.resumeThread(threadId, cwd, configuration);
+    resumeThread(threadId, cwd, configuration, runId) {
+        return this.clientFor(runId).resumeThread(threadId, cwd, configuration);
     }
-    startTurn(threadId, text, cwd, configuration, attachments) {
-        return this.client.startTurn(threadId, text, cwd, configuration, attachments);
+    startTurn(threadId, text, cwd, configuration, attachments, runId) {
+        return this.clientFor(runId).startTurn(threadId, text, cwd, configuration, attachments);
     }
-    interruptTurn(threadId, turnId) {
-        return this.client.interruptTurn(threadId, turnId);
+    interruptTurn(threadId, turnId, runId) {
+        return this.clientFor(runId).interruptTurn(threadId, turnId);
     }
     setThreadName(threadId, name) {
         return this.client.setThreadName(threadId, name);
     }
-    listCollaborationModes() {
-        return this.client.listCollaborationModes();
+    listCollaborationModes(runId) {
+        return this.clientFor(runId).listCollaborationModes();
     }
 }
 function emptyCodexConfiguration() {