[codex] Fix Codex resume and subagent lifecycle routing

cli/src/agent/loopBase.ts

@@ -3,7 +3,7 @@ import type { AgentSessionBase } from './sessionBase';
 
 export type LoopLauncher<TSession> = (session: TSession) => Promise<'switch' | 'exit'>;
 
-export async function runLocalRemoteSession<TSession extends AgentSessionBase<any>>(opts: {
+export async function runLocalRemoteSession<TSession extends AgentSessionBase<any, any>>(opts: {
     session: TSession;
     startingMode?: 'local' | 'remote';
     logTag: string;
@@ -24,7 +24,7 @@ export async function runLocalRemoteSession<TSession extends AgentSessionBase<an
     });
 }
 
-export async function runLocalRemoteLoop<TSession extends AgentSessionBase<any>>(opts: {
+export async function runLocalRemoteLoop<TSession extends AgentSessionBase<any, any>>(opts: {
     session: TSession;
     startingMode?: 'local' | 'remote';
     logTag: string;

cli/src/agent/sessionBase.ts

@@ -3,13 +3,13 @@ import { MessageQueue2 } from '@/utils/MessageQueue2';
 import type { Metadata, SessionCollaborationMode, SessionEffort, SessionModel, SessionPermissionMode } from '@/api/types';
 import { logger } from '@/ui/logger';
 
-export type AgentSessionBaseOptions<Mode> = {
+export type AgentSessionBaseOptions<Mode, Message = string> = {
     api: ApiClient;
     client: ApiSessionClient;
     path: string;
     logPath: string;
     sessionId: string | null;
-    messageQueue: MessageQueue2<Mode>;
+    messageQueue: MessageQueue2<Mode, Message>;
     onModeChange: (mode: 'local' | 'remote') => void;
     mode?: 'local' | 'remote';
     sessionLabel: string;
@@ -21,12 +21,12 @@ export type AgentSessionBaseOptions<Mode> = {
     collaborationMode?: SessionCollaborationMode;
 };
 
-export class AgentSessionBase<Mode> {
+export class AgentSessionBase<Mode, Message = string> {
     readonly path: string;
     readonly logPath: string;
     readonly api: ApiClient;
     readonly client: ApiSessionClient;
-    readonly queue: MessageQueue2<Mode>;
+    readonly queue: MessageQueue2<Mode, Message>;
     protected readonly _onModeChange: (mode: 'local' | 'remote') => void;
 
     sessionId: string | null;
@@ -43,7 +43,7 @@ export class AgentSessionBase<Mode> {
     protected effort?: SessionEffort;
     protected collaborationMode?: SessionCollaborationMode;
 
-    constructor(opts: AgentSessionBaseOptions<Mode>) {
+    constructor(opts: AgentSessionBaseOptions<Mode, Message>) {
         this.path = opts.path;
         this.api = opts.api;
         this.client = opts.client;

cli/src/api/apiMachine.test.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+type FakeSocket = {
+    handlers: Map<string, (...args: any[]) => void>
+    emitted: Array<{ event: string, payload: unknown }>
+    on: (event: string, handler: (...args: any[]) => void) => FakeSocket
+    emit: (event: string, payload: unknown) => void
+    emitWithAck: (event: string, payload: unknown) => Promise<unknown>
+    close: () => void
+}
+
+const listImportableCodexSessionsMock = vi.hoisted(() => vi.fn())
+const listImportableClaudeSessionsMock = vi.hoisted(() => vi.fn())
+const fakeSocket = vi.hoisted<FakeSocket>(() => ({
+    handlers: new Map(),
+    emitted: [],
+    on(event, handler) {
+        this.handlers.set(event, handler)
+        return this
+    },
+    emit(event, payload) {
+        this.emitted.push({ event, payload })
+    },
+    emitWithAck: vi.fn(async (event: string) => {
+        if (event === 'machine-update-state') {
+            return { result: 'success', version: 1, runnerState: null }
+        }
+
+        if (event === 'machine-update-metadata') {
+            return { result: 'success', version: 1, metadata: null }
+        }
+
+        return { result: 'success', version: 1 }
+    }),
+    close() {}
+}))
+
+const importableSessionsResponse = {
+    sessions: [
+        {
+            agent: 'codex',
+            externalSessionId: 'codex-session-1',
+            cwd: '/work/project',
+            timestamp: 1712131200000,
+            transcriptPath: '/sessions/codex-session-1.jsonl',
+            previewTitle: 'Project draft',
+            previewPrompt: 'Build the project'
+        }
+    ]
+}
+
+const importableClaudeSessionsResponse = {
+    sessions: [
+        {
+            agent: 'claude',
+            externalSessionId: 'claude-session-1',
+            cwd: '/work/project',
+            timestamp: 1712131200000,
+            transcriptPath: '/sessions/claude-session-1.jsonl',
+            previewTitle: 'Continue the refactor',
+            previewPrompt: 'Continue the refactor'
+        }
+    ]
+}
+
+vi.mock('socket.io-client', () => ({
+    io: vi.fn(() => fakeSocket)
+}))
+
+vi.mock('@/codex/utils/listImportableCodexSessions', () => ({
+    listImportableCodexSessions: listImportableCodexSessionsMock
+}))
+
+vi.mock('@/claude/utils/listImportableClaudeSessions', () => ({
+    listImportableClaudeSessions: listImportableClaudeSessionsMock
+}))
+
+vi.mock('@/modules/common/registerCommonHandlers', () => ({
+    registerCommonHandlers: vi.fn()
+}))
+
+vi.mock('@/utils/invokedCwd', () => ({
+    getInvokedCwd: vi.fn(() => '/workspace')
+}))
+
+vi.mock('@/ui/logger', () => ({
+    logger: {
+        debug: vi.fn()
+    }
+}))
+
+import { ApiMachineClient } from './apiMachine'
+
+describe('ApiMachineClient list-importable-sessions RPC', () => {
+    beforeEach(() => {
+        fakeSocket.handlers.clear()
+        fakeSocket.emitted.length = 0
+        vi.mocked(fakeSocket.emitWithAck).mockClear()
+        listImportableCodexSessionsMock.mockReset()
+        listImportableClaudeSessionsMock.mockReset()
+        listImportableCodexSessionsMock.mockResolvedValue(importableSessionsResponse)
+        listImportableClaudeSessionsMock.mockResolvedValue(importableClaudeSessionsResponse)
+    })
+
+    it('registers the RPC during connect and returns scanner results by agent', async () => {
+        const machine = {
+            id: 'machine-1',
+            metadata: null,
+            metadataVersion: 0,
+            runnerState: null,
+            runnerStateVersion: 0
+        } as never
+
+        const client = new ApiMachineClient('token', machine)
+        client.connect()
+
+        const connectHandler = fakeSocket.handlers.get('connect')
+        expect(connectHandler).toBeTypeOf('function')
+        connectHandler?.()
+
+        expect(fakeSocket.emitted).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    event: 'rpc-register',
+                    payload: { method: 'machine-1:path-exists' }
+                }),
+                expect.objectContaining({
+                    event: 'rpc-register',
+                    payload: { method: 'machine-1:list-importable-sessions' }
+                })
+            ])
+        )
+
+        const rpcRequestHandler = fakeSocket.handlers.get('rpc-request')
+        expect(rpcRequestHandler).toBeTypeOf('function')
+
+        const codexResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({ agent: 'codex' })
+                },
+                resolve
+            )
+        })
+
+        expect(codexResponse).toBe(JSON.stringify(importableSessionsResponse))
+
+        const missingAgentResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({})
+                },
+                resolve
+            )
+        })
+
+        expect(missingAgentResponse).toBe(JSON.stringify({ sessions: [] }))
+        expect(listImportableCodexSessionsMock).toHaveBeenCalledTimes(1)
+
+        const claudeResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({ agent: 'claude' })
+                },
+                resolve
+            )
+        })
+
+        expect(JSON.parse(claudeResponse)).toEqual(importableClaudeSessionsResponse)
+        expect(listImportableClaudeSessionsMock).toHaveBeenCalledTimes(1)
+
+        client.shutdown()
+    })
+})

cli/src/api/apiMachine.ts

@@ -13,7 +13,14 @@ import { backoff } from '@/utils/time'
 import { getInvokedCwd } from '@/utils/invokedCwd'
 import { RpcHandlerManager } from './rpc/RpcHandlerManager'
 import { registerCommonHandlers } from '../modules/common/registerCommonHandlers'
-import type { SpawnSessionOptions, SpawnSessionResult } from '../modules/common/rpcTypes'
+import type {
+    RpcListImportableSessionsRequest,
+    RpcListImportableSessionsResponse,
+    SpawnSessionOptions,
+    SpawnSessionResult
+} from '../modules/common/rpcTypes'
+import { listImportableClaudeSessions } from '@/claude/utils/listImportableClaudeSessions'
+import { listImportableCodexSessions } from '@/codex/utils/listImportableCodexSessions'
 import { applyVersionedAck } from './versionedUpdate'
 
 interface ServerToRunnerEvents {
@@ -79,25 +86,7 @@ export class ApiMachineClient {
         })
 
         registerCommonHandlers(this.rpcHandlerManager, getInvokedCwd())
-
-        this.rpcHandlerManager.registerHandler<PathExistsRequest, PathExistsResponse>('path-exists', async (params) => {
-            const rawPaths = Array.isArray(params?.paths) ? params.paths : []
-            const uniquePaths = Array.from(new Set(rawPaths.filter((path): path is string => typeof path === 'string')))
-            const exists: Record<string, boolean> = {}
-
-            await Promise.all(uniquePaths.map(async (path) => {
-                const trimmed = path.trim()
-                if (!trimmed) return
-                try {
-                    const stats = await stat(trimmed)
-                    exists[trimmed] = stats.isDirectory()
-                } catch {
-                    exists[trimmed] = false
-                }
-            }))
-
-            return { exists }
-        })
+        this.registerMachineHandlers()
     }
 
     setRPCHandlers({ spawnSession, stopSession, requestShutdown }: MachineRpcHandlers): void {
@@ -154,6 +143,42 @@ export class ApiMachineClient {
         })
     }
 
+    private registerMachineHandlers(): void {
+        this.rpcHandlerManager.registerHandler<PathExistsRequest, PathExistsResponse>('path-exists', async (params) => {
+            const rawPaths = Array.isArray(params?.paths) ? params.paths : []
+            const uniquePaths = Array.from(new Set(rawPaths.filter((path): path is string => typeof path === 'string')))
+            const exists: Record<string, boolean> = {}
+
+            await Promise.all(uniquePaths.map(async (path) => {
+                const trimmed = path.trim()
+                if (!trimmed) return
+                try {
+                    const stats = await stat(trimmed)
+                    exists[trimmed] = stats.isDirectory()
+                } catch {
+                    exists[trimmed] = false
+                }
+            }))
+
+            return { exists }
+        })
+
+        this.rpcHandlerManager.registerHandler<RpcListImportableSessionsRequest, RpcListImportableSessionsResponse>(
+            'list-importable-sessions',
+            async (params) => {
+                if (params?.agent === 'codex') {
+                    return await listImportableCodexSessions()
+                }
+
+                if (params?.agent === 'claude') {
+                    return await listImportableClaudeSessions()
+                }
+
+                return { sessions: [] }
+            }
+        )
+    }
+
     async updateMachineMetadata(handler: (metadata: MachineMetadata | null) => MachineMetadata): Promise<void> {
         await backoff(async () => {
             const updated = handler(this.machine.metadata)

cli/src/api/types.ts

@@ -131,7 +131,9 @@ export const MessageMetaSchema = z.object({
     customSystemPrompt: z.string().nullable().optional(),
     appendSystemPrompt: z.string().nullable().optional(),
     allowedTools: z.array(z.string()).nullable().optional(),
-    disallowedTools: z.array(z.string()).nullable().optional()
+    disallowedTools: z.array(z.string()).nullable().optional(),
+    isSidechain: z.boolean().optional(),
+    sidechainKey: z.string().optional()
 })
 
 export type MessageMeta = z.infer<typeof MessageMetaSchema>

cli/src/claude/claudeRemote.ts

@@ -11,6 +11,7 @@ import { systemPrompt } from "./utils/systemPrompt";
 import { PermissionResult } from "./sdk/types";
 import { getHapiBlobsDir } from "@/constants/uploadPaths";
 import { getDefaultClaudeCodePath } from "./sdk/utils";
+import { extractExplicitResumeSessionId } from "./utils/explicitResume";
 
 export async function claudeRemote(opts: {
 
@@ -47,27 +48,12 @@ export async function claudeRemote(opts: {
 
     // Extract --resume from claudeArgs if present (for first spawn)
     if (!startFrom && opts.claudeArgs) {
-        for (let i = 0; i < opts.claudeArgs.length; i++) {
-            if (opts.claudeArgs[i] === '--resume') {
-                // Check if next arg exists and looks like a session ID
-                if (i + 1 < opts.claudeArgs.length) {
-                    const nextArg = opts.claudeArgs[i + 1];
-                    // If next arg doesn't start with dash and contains dashes, it's likely a UUID
-                    if (!nextArg.startsWith('-') && nextArg.includes('-')) {
-                        startFrom = nextArg;
-                        logger.debug(`[claudeRemote] Found --resume with session ID: ${startFrom}`);
-                        break;
-                    } else {
-                        // Just --resume without UUID - SDK doesn't support this
-                        logger.debug('[claudeRemote] Found --resume without session ID - not supported in remote mode');
-                        break;
-                    }
-                } else {
-                    // --resume at end of args - SDK doesn't support this
-                    logger.debug('[claudeRemote] Found --resume without session ID - not supported in remote mode');
-                    break;
-                }
-            }
+        const explicitResumeSessionId = extractExplicitResumeSessionId(opts.claudeArgs);
+        if (explicitResumeSessionId) {
+            startFrom = explicitResumeSessionId;
+            logger.debug(`[claudeRemote] Found --resume with session ID: ${startFrom}`);
+        } else if (opts.claudeArgs.includes('--resume')) {
+            logger.debug('[claudeRemote] Found --resume without session ID - not supported in remote mode');
         }
     }