@agent-native/core 0.157.8 → 0.157.10

package/dist/cli/code-agent-connector.js

@@ -6,14 +6,25 @@ import { assertValidComputerCommandEnvelope } from "../integrations/computer-sup
 import { serializeBoundedRemoteJson } from "../integrations/remote-json-safety.js";
 import { executeDenyCodeAgentApproval, executePendingCodeAgentApproval, } from "./code-agent-executor.js";
 import { appendCodeAgentTranscriptEvent, codeAgentRunTranscriptPath, codeAgentStoreRoot, createCodeAgentRunRecord, getCodeAgentRunRecord, listCodeAgentRunRecords, normalizeCodeAgentPermissionMode, queueCodeAgentFollowUp, updateCodeAgentRunRecord, } from "./code-agent-runs.js";
+import { loadPortalEnvironment, preparePortalWorkspace, parsePortalHandoff, } from "./portal-workspace.js";
 const DEVICE_PATH_ENV = "AGENT_NATIVE_REMOTE_DEVICE_PATH";
 const COMPUTER_BRIDGE_URL_ENV = "AGENT_NATIVE_COMPUTER_BRIDGE_URL";
 const COMPUTER_BRIDGE_TOKEN_ENV = "AGENT_NATIVE_COMPUTER_BRIDGE_TOKEN";
 const COMPUTER_CAPABILITIES_ENV = "AGENT_NATIVE_COMPUTER_CAPABILITIES";
+const REMOTE_ENGINES_ENV = "AGENT_NATIVE_REMOTE_ENGINES";
 const DEFAULT_POLL_INTERVAL_MS = 2_000;
 const MAX_POLL_INTERVAL_MS = 30_000;
 const MAX_TRANSCRIPT_EVENTS_PER_BATCH = 50;
 const activeRunners = new Map();
+export const DEFAULT_REMOTE_EXECUTION_CAPABILITIES = {
+    backend: "desktop",
+    workloads: ["code-agent", "scheduled-code"],
+    engines: ["codex-cli", "claude-cli", "pi-cli", "opencode-cli"],
+    acceptsScheduledWork: true,
+    acceptsPortalHandoffs: true,
+    persistence: "local-files",
+    adapters: ["agent-native-code"],
+};
 export function remoteDeviceConfigPath() {
     return path.resolve(process.env[DEVICE_PATH_ENV] ??
         path.join(os.homedir(), ".agent-native", "remote-device.json"));
@@ -32,6 +43,7 @@ export function loadRemoteCodeAgentDeviceConfig(configPath = remoteDeviceConfigP
             relayUrl: firstStringValue(raw.relayUrl, raw.url, raw.baseUrl),
             deviceId: firstStringValue(raw.deviceId, raw.id),
             deviceName: firstStringValue(raw.deviceName, raw.name),
+            workspacePath: firstStringValue(raw.workspacePath, raw.workspace, raw.cwd, raw.projectPath),
             pollIntervalMs: Number.isFinite(pollIntervalMs) && pollIntervalMs > 0
                 ? Math.min(Math.max(pollIntervalMs, 500), MAX_POLL_INTERVAL_MS)
                 : undefined,
@@ -77,6 +89,7 @@ class RemoteCodeAgentConnector {
     output;
     transcriptCursors = new Map();
     remoteRunIds = new Set();
+    terminalCommandIds = new Set();
     stopped = false;
     computerBridge = loadLocalComputerBridgeConfig();
     constructor(config, relayUrl, output) {
@@ -140,6 +153,7 @@ class RemoteCodeAgentConnector {
                 "run-events",
             ],
             computerCapabilities: this.computerBridge?.capabilities ?? {},
+            executionCapabilities: remoteExecutionCapabilities(),
             activeRunIds: Array.from(this.remoteRunIds),
         });
         const commands = normalizeCommands(response);
@@ -180,25 +194,65 @@ class RemoteCodeAgentConnector {
     async computerOperation(command) {
         return dispatchComputerOperationToLocalBridge(this.computerBridge, command.params.envelope);
     }
-    createRun(command) {
+    async createRun(command) {
         const prompt = firstTextValue(command.params.prompt, command.params.message, command.params.input);
         if (!prompt) {
             return { ok: false, error: "Missing prompt." };
         }
         const goalId = firstStringValue(command.params.goalId) ?? "task";
-        const cwd = resolveCommandCwd(command.params.cwd);
+        const metadata = isObject(command.params.metadata)
+            ? command.params.metadata
+            : {};
+        let cwd = resolveCommandCwd(command.params.cwd ?? this.config.workspacePath);
+        let portalWorkspace;
+        let portalEnvironment;
+        if (metadata.portal !== undefined) {
+            try {
+                portalWorkspace = await preparePortalWorkspace({
+                    handoff: parsePortalHandoff(metadata.portal),
+                    workspacePath: this.config.workspacePath,
+                });
+                portalEnvironment = loadPortalEnvironment(portalWorkspace.environmentRoot);
+                cwd = portalWorkspace.workspacePath;
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        const requestedRunId = firstStringValue(command.params.runId);
+        if (portalWorkspace && requestedRunId && !isSafeRunId(requestedRunId)) {
+            return { ok: false, error: "Portal run id is invalid." };
+        }
+        if (portalWorkspace && requestedRunId) {
+            const existing = getCodeAgentRunRecord(requestedRunId);
+            const existingRemote = isObject(existing?.metadata?.remote)
+                ? existing.metadata.remote
+                : {};
+            if (existing &&
+                firstStringValue(existingRemote.commandId) === command.id) {
+                this.remoteRunIds.add(existing.id);
+                this.transcriptCursors.set(existing.id, { offset: 0, seq: 0 });
+                if (!activeRunners.has(existing.id)) {
+                    this.spawnRunner(existing.id, existing.cwd, existing.permissionMode, portalEnvironment?.values);
+                }
+                return { ok: true, runId: existing.id, run: existing, resumed: true };
+            }
+        }
         const permissionMode = normalizeCodeAgentPermissionMode(command.params.permissionMode) ??
             "full-auto";
         const engine = firstStringValue(command.params.engine);
         const model = firstStringValue(command.params.model);
         const effort = firstStringValue(command.params.effort, command.params.reasoningEffort);
-        const metadata = isObject(command.params.metadata)
-            ? command.params.metadata
-            : {};
         const run = createCodeAgentRunRecord({
+            ...(portalWorkspace && requestedRunId ? { id: requestedRunId } : {}),
             goalId,
             title: firstStringValue(command.params.title) ?? titleFromPrompt(prompt),
-            subtitle: "Remote coding task",
+            subtitle: portalWorkspace
+                ? `Portal on ${this.config.deviceName ?? "paired computer"}`
+                : "Remote coding task",
             status: "queued",
             phase: "queued",
             permissionMode,
@@ -213,6 +267,20 @@ class RemoteCodeAgentConnector {
                 { label: "Prompt", value: truncateForDisplay(prompt, 160) },
                 { label: "Agent", value: "Remote connector" },
                 { label: "Mode", value: permissionMode },
+                ...(portalWorkspace
+                    ? [
+                        {
+                            label: "Workspace",
+                            value: `Portal · ${portalWorkspace.workspacePath}`,
+                        },
+                        {
+                            label: "Environment",
+                            value: portalEnvironment?.files.length
+                                ? `Loaded ${portalEnvironment.files.join(", ")}`
+                                : "Using paired computer environment",
+                        },
+                    ]
+                    : []),
             ],
             metadata: {
                 ...metadata,
@@ -225,7 +293,26 @@ class RemoteCodeAgentConnector {
                     commandId: command.id,
                     deviceId: this.config.deviceId,
                     relayUrl: this.relayUrl,
+                    ...(portalWorkspace ? { remoteRunId: run.id } : {}),
                 },
+                ...(portalWorkspace
+                    ? {
+                        portal: portalWorkspace.handoff,
+                        executionResidence: {
+                            schemaVersion: 1,
+                            kind: "portal",
+                            hostId: this.config.deviceId,
+                            hostLabel: this.config.deviceName ?? os.hostname(),
+                            workspacePath: portalWorkspace.workspacePath,
+                            sourceBranch: portalWorkspace.handoff.sourceBranch,
+                            sourceCommit: portalWorkspace.handoff.commit,
+                            handoffId: portalWorkspace.handoff.handoffId,
+                            envPolicy: portalWorkspace.handoff.envPolicy,
+                            environmentFiles: portalEnvironment?.files ?? [],
+                            environmentLoadedAt: new Date().toISOString(),
+                        },
+                    }
+                    : {}),
             },
         });
         appendCodeAgentTranscriptEvent({
@@ -242,7 +329,7 @@ class RemoteCodeAgentConnector {
         });
         this.remoteRunIds.add(run.id);
         this.transcriptCursors.set(run.id, { offset: 0, seq: 0 });
-        this.spawnRunner(run.id, cwd, permissionMode);
+        this.spawnRunner(run.id, cwd, permissionMode, portalEnvironment?.values);
         return { ok: true, runId: run.id, run };
     }
     appendFollowUp(command) {
@@ -424,7 +511,7 @@ class RemoteCodeAgentConnector {
             activeRunIds: Array.from(activeRunners.keys()),
         };
     }
-    spawnRunner(runId, cwd, permissionMode) {
+    spawnRunner(runId, cwd, permissionMode, portalEnvironment) {
         if (activeRunners.has(runId))
             return;
         const invocation = resolveCodeAgentCliInvocation();
@@ -434,6 +521,7 @@ class RemoteCodeAgentConnector {
             stdio: ["ignore", "pipe", "pipe"],
             env: {
                 ...process.env,
+                ...portalEnvironment,
                 AGENT_NATIVE_CODE_AGENTS_HOME: codeAgentStoreRoot(),
                 ...(permissionMode
                     ? { AGENT_NATIVE_CODE_AGENT_PERMISSION_MODE: permissionMode }
@@ -484,28 +572,50 @@ class RemoteCodeAgentConnector {
         for (const runId of this.remoteRunIds) {
             const cursor = this.transcriptCursors.get(runId) ?? { offset: 0, seq: 0 };
             const batch = readTranscriptBatch(runId, cursor.offset);
-            if (batch.events.length === 0) {
-                this.transcriptCursors.set(runId, {
-                    offset: batch.nextOffset,
-                    seq: cursor.seq,
+            if (batch.events.length > 0) {
+                await this.postJson("/_agent-native/integrations/remote/run-events", {
+                    deviceId: this.config.deviceId,
+                    remoteRunId: runId,
+                    cursor: { offset: batch.nextOffset },
+                    events: batch.events.map((event, index) => ({
+                        seq: cursor.seq + index,
+                        event,
+                    })),
                 });
-                continue;
             }
-            await this.postJson("/_agent-native/integrations/remote/run-events", {
-                deviceId: this.config.deviceId,
-                remoteRunId: runId,
-                cursor: { offset: batch.nextOffset },
-                events: batch.events.map((event, index) => ({
-                    seq: cursor.seq + index,
-                    event,
-                })),
-            });
             this.transcriptCursors.set(runId, {
                 offset: batch.nextOffset,
                 seq: cursor.seq + batch.events.length,
             });
+            await this.reportRemoteRunTerminal(runId);
         }
     }
+    async reportRemoteRunTerminal(runId) {
+        const run = getCodeAgentRunRecord(runId);
+        if (!run || (run.status !== "completed" && run.status !== "errored")) {
+            return;
+        }
+        const remote = isObject(run.metadata?.remote) ? run.metadata.remote : {};
+        const commandId = firstStringValue(remote.commandId);
+        if (!commandId || this.terminalCommandIds.has(commandId))
+            return;
+        const errorMessage = firstStringValue(run.metadata?.error, run.metadata?.runnerError);
+        await this.postJson("/_agent-native/integrations/remote/result", {
+            deviceId: this.config.deviceId,
+            commandId,
+            kind: "create-run",
+            ok: run.status === "completed",
+            status: run.status === "completed" ? "completed" : "failed",
+            result: {
+                ok: run.status === "completed",
+                run,
+            },
+            errorMessage: run.status === "errored"
+                ? (errorMessage ?? "Remote code-agent run failed.")
+                : undefined,
+        });
+        this.terminalCommandIds.add(commandId);
+    }
     async postCommandResult(command, result) {
         let safeResult;
         try {
@@ -519,12 +629,17 @@ class RemoteCodeAgentConnector {
                     : "Connector result rejected as unsafe.",
             };
         }
+        const isAcceptedCreateRun = normalizeKind(command.kind) === "create-run" && safeResult.ok !== false;
         await this.postJson("/_agent-native/integrations/remote/result", {
             deviceId: this.config.deviceId,
             commandId: command.id,
             kind: command.kind,
             ok: safeResult.ok !== false,
-            status: safeResult.ok === false ? "failed" : "completed",
+            status: safeResult.ok === false
+                ? "failed"
+                : isAcceptedCreateRun
+                    ? "running"
+                    : "completed",
             result: safeResult,
             errorMessage: typeof safeResult.error === "string" ? safeResult.error : undefined,
         });
@@ -535,6 +650,7 @@ class RemoteCodeAgentConnector {
             method: "POST",
             headers: {
                 authorization: `Bearer ${this.config.token}`,
+                "x-agent-native-device-token": this.config.token,
                 "content-type": "application/json",
             },
             body: JSON.stringify(body),
@@ -712,6 +828,21 @@ function resolveCommandCwd(value) {
     const cwd = firstStringValue(value);
     return cwd ? path.resolve(cwd) : process.cwd();
 }
+function isSafeRunId(value) {
+    return value.length <= 160 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+}
+function remoteExecutionCapabilities() {
+    const configured = process.env[REMOTE_ENGINES_ENV]
+        ?.split(",")
+        .map((engine) => engine.trim())
+        .filter(Boolean);
+    return {
+        ...DEFAULT_REMOTE_EXECUTION_CAPABILITIES,
+        ...(configured?.length
+            ? { engines: [...new Set(configured)].slice(0, 32) }
+            : {}),
+    };
+}
 function normalizeRelayUrl(value) {
     if (!value)
         return null;

package/dist/cli/code-agent-executor.js

@@ -485,6 +485,7 @@ async function executeClaudeCliRun(options) {
     const streamToolOutputToStdout = options.streamToolOutputToStdout ??
         process.env.AGENT_NATIVE_CODE_AGENT_STRUCTURED_STDOUT !== "1";
     const assistantText = [];
+    const claudeToolNames = new Map();
     appendCodeAgentTranscriptEvent({
         runId: options.run.id,
         kind: "status",
@@ -511,7 +512,7 @@ async function executeClaudeCliRun(options) {
             effort: reasoningEffort,
             signal: options.signal,
             onEvent: (event) => {
-                const text = readClaudeParticipantAssistantText(event);
+                const text = appendClaudeParticipantTranscriptEvents(options.run.id, event, claudeToolNames);
                 if (!text)
                     return;
                 assistantText.push(text);
@@ -667,19 +668,246 @@ function normalizeClaudeCliModel(model) {
 function normalizeClaudeCliEffort(effort) {
     return effort && effort !== "auto" ? effort : undefined;
 }
-function readClaudeParticipantAssistantText(event) {
-    if (event.type !== "assistant")
-        return null;
+function appendClaudeParticipantTranscriptEvents(runId, event, toolNames) {
+    const eventType = cliStringValue(event.type);
     const message = asRecordValue(event.message);
-    const content = message?.content;
-    if (!Array.isArray(content))
-        return null;
-    const text = content
-        .filter((part) => isRecordValue(part))
-        .map((part) => (typeof part.text === "string" ? part.text : ""))
-        .filter(Boolean)
-        .join("");
-    return text.trim() || null;
+    const messageContent = Array.isArray(message?.content)
+        ? message.content.filter((part) => isRecordValue(part))
+        : [];
+    const content = messageContent.length > 0
+        ? messageContent
+        : eventType === "tool_use" || eventType === "tool_result"
+            ? [event]
+            : [];
+    let assistantText = "";
+    for (const part of content) {
+        const partType = cliStringValue(part.type);
+        if (eventType === "assistant" && partType === "text") {
+            const text = typeof part.text === "string" ? part.text : "";
+            if (!text.trim())
+                continue;
+            assistantText += text;
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "system",
+                message: text,
+                metadata: { role: "assistant", source: "claude-cli" },
+            });
+            continue;
+        }
+        if (eventType === "assistant" && partType === "thinking") {
+            const thinking = cliTranscriptValue(part.thinking ?? part.text);
+            if (!thinking)
+                continue;
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: thinking,
+                metadata: { type: "thinking", source: "claude-cli" },
+            });
+            continue;
+        }
+        if (partType === "tool_use") {
+            const toolName = cliStringValue(part.name) ?? cliStringValue(part.tool_name) ?? "tool";
+            const toolCallId = cliStringValue(part.id);
+            if (toolCallId)
+                toolNames.set(toolCallId, toolName);
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: `Running ${toolName}.`,
+                metadata: {
+                    type: "tool_start",
+                    tool: toolName,
+                    input: part.input ?? {},
+                    ...(toolCallId ? { toolCallId } : {}),
+                    source: "claude-cli",
+                },
+            });
+            continue;
+        }
+        if (partType === "tool_result") {
+            const toolCallId = cliStringValue(part.tool_use_id);
+            const toolName = cliStringValue(part.tool_name) ??
+                (toolCallId ? toolNames.get(toolCallId) : undefined) ??
+                "tool";
+            const result = cliTranscriptValue(part.content ?? part.output ?? part.result ?? "");
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: `Finished ${toolName}.`,
+                metadata: {
+                    type: "tool_done",
+                    tool: toolName,
+                    result,
+                    ...(part.is_error === true ? { isError: true } : {}),
+                    ...(toolCallId ? { toolCallId } : {}),
+                    source: "claude-cli",
+                },
+            });
+            if (toolCallId)
+                toolNames.delete(toolCallId);
+        }
+    }
+    return assistantText.trim() || null;
+}
+function appendCodexCliTranscriptEvent(runId, event) {
+    const eventType = cliStringValue(event.type);
+    const item = asRecordValue(event.item);
+    if (eventType?.startsWith("item.") && item) {
+        const itemType = cliStringValue(item.type);
+        if (itemType === "agent_message") {
+            const text = cliStringValue(item.text ?? item.message ?? item.content);
+            if (text) {
+                appendCodeAgentTranscriptEvent({
+                    runId,
+                    kind: "system",
+                    message: text,
+                    metadata: {
+                        role: "assistant",
+                        source: "codex-cli",
+                        cliEventType: eventType,
+                        itemType,
+                    },
+                });
+            }
+            return;
+        }
+        if (itemType === "reasoning") {
+            const text = cliTranscriptValue(item.text ?? item.summary);
+            if (text) {
+                appendCodeAgentTranscriptEvent({
+                    runId,
+                    kind: "status",
+                    message: text,
+                    metadata: {
+                        type: "thinking",
+                        source: "codex-cli",
+                        cliEventType: eventType,
+                        itemType,
+                    },
+                });
+            }
+            return;
+        }
+        const toolName = codexCliToolName(itemType, item);
+        if (!toolName)
+            return;
+        const toolCallId = cliStringValue(item.id);
+        const metadata = {
+            source: "codex-cli",
+            cliEventType: eventType,
+            itemType,
+            tool: toolName,
+            ...(toolCallId ? { toolCallId } : {}),
+        };
+        if (eventType === "item.started") {
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: `Running ${toolName}.`,
+                metadata: {
+                    ...metadata,
+                    type: "tool_start",
+                    input: codexCliToolInput(item),
+                },
+            });
+        }
+        else if (eventType === "item.completed") {
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: `Finished ${toolName}.`,
+                metadata: {
+                    ...metadata,
+                    type: "tool_done",
+                    result: cliTranscriptValue(codexCliToolResult(item)),
+                },
+            });
+        }
+        else {
+            appendCodeAgentTranscriptEvent({
+                runId,
+                kind: "status",
+                message: `Working with ${toolName}.`,
+                metadata: { ...metadata, type: "activity" },
+            });
+        }
+        return;
+    }
+    if (eventType === "error" || eventType === "turn.failed") {
+        const message = cliStringValue(event.message ?? event.error) ?? eventType;
+        appendCodeAgentTranscriptEvent({
+            runId,
+            kind: "status",
+            message,
+            metadata: { type: "error", source: "codex-cli", cliEventType: eventType },
+        });
+    }
+}
+function codexCliToolName(itemType, item) {
+    switch (itemType) {
+        case "command_execution":
+            return "bash";
+        case "file_change":
+            return "file-change";
+        case "mcp_tool_call":
+            return (cliStringValue(item.name) ?? cliStringValue(item.tool) ?? "mcp-tool");
+        case "web_search":
+            return "web-search";
+        case "function_call":
+            return cliStringValue(item.name) ?? "function";
+        default:
+            return itemType?.includes("tool")
+                ? (cliStringValue(item.name) ?? itemType)
+                : null;
+    }
+}
+function codexCliToolInput(item) {
+    if (typeof item.command === "string")
+        return { command: item.command };
+    return item.arguments ?? item.input ?? item.params ?? item.changes ?? {};
+}
+function codexCliToolResult(item) {
+    return (item.aggregated_output ??
+        item.output ??
+        item.result ??
+        item.error ??
+        item.content ??
+        item.status ??
+        "");
+}
+function consumeCodexJsonLine(line, onEvent) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{"))
+        return;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (isRecordValue(parsed))
+            onEvent?.(parsed);
+    }
+    catch {
+        // coercion-ok: older CLI output is intentionally ignored when it is not JSON.
+        // Older Codex versions and test doubles can still emit human-readable
+        // stdout. Keep that output available to terminal callers without making
+        // the structured transcript parser fail the run.
+    }
+}
+function cliStringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function cliTranscriptValue(value) {
+    if (typeof value === "string") {
+        return truncateBashOutput(truncateCodingOutput(value, MAX_TOOL_OUTPUT_CHARS));
+    }
+    if (value == null)
+        return "";
+    try {
+        return truncateBashOutput(truncateCodingOutput(JSON.stringify(value) ?? "", MAX_TOOL_OUTPUT_CHARS));
+    }
+    catch {
+        return truncateCodingOutput(String(value), MAX_TOOL_OUTPUT_CHARS);
+    }
 }
 function readClaudeParticipantResultText(events) {
     for (let index = events.length - 1; index >= 0; index -= 1) {
@@ -1006,6 +1234,7 @@ async function executeCodexCliRun(options) {
         "exec",
         "--color",
         "never",
+        "--json",
         "--skip-git-repo-check",
         "--ignore-user-config",
         "--output-last-message",
@@ -1034,6 +1263,9 @@ async function executeCodexCliRun(options) {
             prompt: buildCodexCliPrompt(options.run, options.prompt),
             stdout: options.stdout,
             streamToolOutputToStdout,
+            onEvent: (event) => {
+                appendCodexCliTranscriptEvent(options.run.id, event);
+            },
             signal: options.signal,
         });
         if (result.exitCode !== 0) {
@@ -1163,6 +1395,7 @@ function runCodexCliProcess(options) {
     return new Promise((resolve) => {
         let stdout = "";
         let stderr = "";
+        let pendingJson = "";
         let settled = false;
         const child = spawn("codex", options.args, {
             cwd: options.cwd,
@@ -1188,6 +1421,13 @@ function runCodexCliProcess(options) {
         child.stdout?.on("data", (chunk) => {
             const text = chunk.toString();
             stdout += text;
+            pendingJson += text;
+            let newline = pendingJson.indexOf("\n");
+            while (newline !== -1) {
+                consumeCodexJsonLine(pendingJson.slice(0, newline), options.onEvent);
+                pendingJson = pendingJson.slice(newline + 1);
+                newline = pendingJson.indexOf("\n");
+            }
             if (options.streamToolOutputToStdout ?? true) {
                 options.stdout?.write(text);
             }
@@ -1207,6 +1447,8 @@ function runCodexCliProcess(options) {
             });
         });
         child.on("exit", (exitCode, exitSignal) => {
+            if (pendingJson.trim())
+                consumeCodexJsonLine(pendingJson, options.onEvent);
             finish({ exitCode, exitSignal });
         });
         child.stdin?.end(options.prompt);

package/dist/cli/code-agent-runs.d.ts

@@ -65,6 +65,7 @@ export interface CodeAgentTranscriptEvent {
     signal?: CodeAgentTranscriptEventSignal;
 }
 export interface CreateCodeAgentRunInput {
+    id?: string;
     goalId: string;
     title: string;
     subtitle?: string;

package/dist/cli/code-agent-runs.js

@@ -65,7 +65,8 @@ export function isCodeAgentCommandAllowed(command) {
 }
 export function createCodeAgentRunRecord(input) {
     const now = new Date().toISOString();
-    const id = `${input.goalId}-${timestampSlug(now)}-${crypto.randomUUID().slice(0, 8)}`;
+    const id = input.id ??
+        `${input.goalId}-${timestampSlug(now)}-${crypto.randomUUID().slice(0, 8)}`;
     const record = {
         schemaVersion: 1,
         id,