@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599 → 0.1.1-dev.32d4dd5874ee

package/dist/session/provider-cli/provider-cli.service.d.ts

@@ -1,4 +1,5 @@
 import { GitClient } from "../../shared/git/git.js";
+import { type CompletionToolRuntime } from "../phase-completion.js";
 import type { ProviderCliService } from "./provider-cli.base.js";
 import type { ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli.types.js";
 import type { RunOnceDispatchPacket, RunnerDispatchEvent } from "../session.types.js";
@@ -55,4 +56,5 @@ export declare function formatProviderCliCommand(command: ProviderCliCommand): s
 export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket, run?: {
     readonly prompt?: string;
     readonly worktreePath?: string;
+    readonly completionTools?: CompletionToolRuntime;
 }): ProviderCliCommand;

package/dist/session/provider-cli/provider-cli.service.js

@@ -5,7 +5,9 @@ import { execFile, spawn } from "node:child_process";
 import readline from "node:readline";
 import { promisify } from "node:util";
 import { GitClient } from "../../shared/git/git.js";
+import { resolveCursorAgentDirectLaunch } from "../../shared/cursor-agent/cursor-agent.launch.js";
 import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
+import { codexMcpConfigArgs, completionArtifactJsonPath, completionArtifactReportPath, completionPhaseFromDispatch, completionPromptForPhase, prepareCompletionToolRuntime, readCompletionArtifact } from "../phase-completion.js";
 const fakeWorkerModel = "server-local-fake-worker";
 const execFileAsync = promisify(execFile);
 export class RoutingProviderCliService {
@@ -40,20 +42,22 @@ export class ProcessBackedProviderCliService {
     }
     async runImplementation(context) {
         const { dispatch, worktree } = context;
+        const phase = completionPhaseFromDispatch(dispatch);
         const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
-        const artifactRoot = path.join(metadataRoot, "artifacts");
-        await fs.mkdir(artifactRoot, { recursive: true });
+        await fs.mkdir(metadataRoot, { recursive: true });
         const laneCommand = selectLaneCommand(dispatch.artifacts, dispatch.execution.lane, dispatch.cycleRun.phase);
         if (!laneCommand) {
             throw new Error(`Lane command for lane '${dispatch.execution.lane}' phase '${dispatch.cycleRun.phase}' was not resolved.`);
         }
-        const specBody = buildSpecBody(laneCommand, dispatch.workItem);
+        const specBody = buildSpecBody(laneCommand, dispatch.workItem, phase);
         const specPath = path.join(metadataRoot, "spec.md");
         await fs.writeFile(specPath, specBody, "utf8");
         await fs.writeFile(path.join(metadataRoot, "spec.meta.json"), JSON.stringify({ schema_version: 1, status: "approved", produced_by: "forge-lane-command" }) + "\n", "utf8");
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildImplementationPrompt(dispatch)
+            prompt: buildImplementationPrompt(dispatch, phase),
+            completionTools
         });
         await context.emit({
             role: "runner",
@@ -61,19 +65,31 @@ export class ProcessBackedProviderCliService {
             content: `Starting provider CLI: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
             eventType: "provider_cli_started"
         });
-        const codexState = new CodexJsonState();
-        const result = await this.processRunner.run({
-            command: command.command,
-            args: command.args,
-            cwd: worktree.worktreePath
-        }, {
-            onStdoutLine: async (line) => {
-                const event = codexState.consume(line);
-                if (event) {
-                    await context.emit(event);
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Forge completion tools configured for ${phase}; provider must call the MCP completion tool before exit.`,
+            eventType: "completion_tools_configured"
+        });
+        const outputState = createProviderOutputState(dispatch.execution.provider);
+        let result;
+        try {
+            result = await this.processRunner.run({
+                command: command.command,
+                args: command.args,
+                cwd: worktree.worktreePath
+            }, {
+                onStdoutLine: async (line) => {
+                    const event = outputState.consume(line);
+                    if (event) {
+                        await context.emit(event);
+                    }
                 }
-            }
-        }, context.signal);
+            }, context.signal);
+        }
+        finally {
+            await cleanupCompletionTools(completionTools, context.emit);
+        }
         if (result.exitCode !== 0) {
             const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
             throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
@@ -81,42 +97,19 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Provider CLI completed: ${command.command} exit ${result.exitCode}${codexState.threadId ? ` thread ${codexState.threadId}` : ""}.`,
+            content: `Provider CLI completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
             eventType: "provider_cli_completed"
         });
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
-        const artifactPath = path.join(artifactRoot, "implementation.verdict.json");
-        const reportPath = path.join(artifactRoot, "implementation.report.md");
-        const report = buildImplementationReport(dispatch, command, committed, codexState);
-        const verdict = {
-            schema_version: 1,
-            status: "pass",
-            checks: [
-                {
-                    name: "provider_cli_exit",
-                    status: "pass",
-                    command: formatProviderCliCommand(command),
-                    exit_code: result.exitCode
-                }
-            ],
-            metrics: {
-                files_changed: committed.changedFiles.length
-            },
-            provider: dispatch.execution.provider,
-            model: dispatch.execution.model,
-            produced_by: `${dispatch.execution.provider}-cli`,
-            thread_id: codexState.threadId,
-            commit_sha: committed.commitSha,
-            content_hash: sha256(report)
-        };
-        const verdictJson = JSON.stringify(verdict);
-        await fs.writeFile(artifactPath, `${verdictJson}\n`, "utf8");
-        await fs.writeFile(reportPath, report, "utf8");
-        if (codexState.finalMessage) {
+        const completionArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, phase);
+        if (!completionArtifact) {
+            throw new Error(`Provider CLI completed but did not call the Forge ${phase} completion tool.`);
+        }
+        if (outputState.finalMessage) {
             await context.emit({
                 role: "assistant",
                 kind: "message",
-                content: codexState.finalMessage,
+                content: outputState.finalMessage,
                 eventType: "implementation_complete"
             });
         }
@@ -129,7 +122,7 @@ export class ProcessBackedProviderCliService {
             });
         }
         return {
-            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName}.`,
+            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName} (${phase}, ${committed.commitSha.slice(0, 12)}).`,
             spec: {
                 repoPath: worktree.worktreePath,
                 path: specPath,
@@ -137,14 +130,7 @@ export class ProcessBackedProviderCliService {
                 producedBy: "forge-lane-command",
                 status: "approved"
             },
-            artifact: {
-                repoPath: worktree.worktreePath,
-                path: artifactPath,
-                verdictJson,
-                report,
-                producedBy: `${dispatch.execution.provider}-cli`,
-                status: "pass"
-            }
+            artifact: completionArtifact
         };
     }
     async runQa(dispatch, emit, signal) {
@@ -157,14 +143,14 @@ export class ProcessBackedProviderCliService {
             content: `Starting provider CLI QA: ${formatProviderCliCommand(command)}`,
             eventType: "provider_cli_started"
         });
-        const codexState = new CodexJsonState();
+        const outputState = createProviderOutputState(dispatch.execution.provider);
         const result = await this.processRunner.run({
             command: command.command,
             args: command.args,
             cwd: process.cwd()
         }, {
             onStdoutLine: async (line) => {
-                const event = codexState.consume(line);
+                const event = outputState.consume(line);
                 if (event) {
                     await emit(event);
                 }
@@ -177,7 +163,7 @@ export class ProcessBackedProviderCliService {
         await emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Provider CLI QA completed: ${command.command} exit ${result.exitCode}${codexState.threadId ? ` thread ${codexState.threadId}` : ""}.`,
+            content: `Provider CLI QA completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
             eventType: "provider_cli_completed"
         });
         return {
@@ -196,14 +182,14 @@ export class ProcessBackedProviderCliService {
             content: `Starting provider CLI conflict resolve: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
             eventType: "provider_cli_started"
         });
-        const codexState = new CodexJsonState();
+        const outputState = createProviderOutputState(dispatch.execution.provider);
         const result = await this.processRunner.run({
             command: command.command,
             args: command.args,
             cwd: worktree.worktreePath
         }, {
             onStdoutLine: async (line) => {
-                const event = codexState.consume(line);
+                const event = outputState.consume(line);
                 if (event) {
                     await context.emit(event);
                 }
@@ -218,7 +204,7 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "assistant",
             kind: "message",
-            content: codexState.finalMessage || `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`,
+            content: outputState.finalMessage || `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`,
             eventType: "conflict_resolve_complete"
         });
         return {
@@ -233,6 +219,7 @@ export class DeterministicProviderCliService {
     }
     async runImplementation(context) {
         const { dispatch, worktree } = context;
+        const phase = completionPhaseFromDispatch(dispatch);
         const providerCommand = buildProviderCliCommand(dispatch);
         const providerCommandText = formatProviderCliCommand(providerCommand);
         const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
@@ -242,7 +229,7 @@ export class DeterministicProviderCliService {
         if (!laneCommand) {
             throw new Error(`Lane command for lane '${dispatch.execution.lane}' phase '${dispatch.cycleRun.phase}' was not resolved.`);
         }
-        const specBody = `${buildSpecBody(laneCommand, dispatch.workItem)}
+        const specBody = `${buildSpecBody(laneCommand, dispatch.workItem, phase)}
 ## Execution
 
 - Provider: ${singleLine(dispatch.execution.provider)}
@@ -265,17 +252,31 @@ export class DeterministicProviderCliService {
         });
         const verdict = {
             schema_version: 1,
+            phase: "implementation",
             status: "pass",
-            checks: [{ name: "forge_bridge_run_once", status: "pass" }],
-            metrics: { files_changed: 1 },
+            summary: "forge-bridge produced a deterministic implementation changeset.",
+            plan: [{ step: "Create deterministic changeset", status: "done" }],
+            changed_files: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Recorded deterministic bridge evidence." }],
+            tests_added_or_updated: [{ name: "forge_bridge_run_once", evidence: "The bridge committed FORGE_PHASE5_CHANGESET.md." }],
+            docs_added_or_updated: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Deterministic evidence document created for the run." }],
+            acceptance_criteria: [
+                {
+                    criterion: dispatch.workItem.acceptanceCriteria || "Deterministic bridge changeset exists",
+                    evidence: `FORGE_PHASE5_CHANGESET.md was committed with content hash ${sha256(changesetBody)}.`,
+                    status: "satisfied"
+                }
+            ],
+            known_gaps: [],
+            next_phase_context: "Review FORGE_PHASE5_CHANGESET.md and the bridge commit before validation.",
             produced_by: "forge-bridge",
             content_hash: sha256(changesetBody)
         };
         const verdictJson = JSON.stringify(verdict);
         const report = `# Implementation report\n\nforge-bridge prepared \`${worktree.branchName}\` and created \`${changesetPath}\`.\n`;
-        const artifactPath = path.join(artifactRoot, "implementation.verdict.json");
+        const artifactPath = completionArtifactJsonPath(worktree.worktreePath, dispatch.workItem.id, "implementation");
+        const reportPath = completionArtifactReportPath(worktree.worktreePath, dispatch.workItem.id, "implementation");
         await fs.writeFile(artifactPath, verdictJson + "\n", "utf8");
-        await fs.writeFile(path.join(artifactRoot, "implementation.report.md"), report, "utf8");
+        await fs.writeFile(reportPath, report, "utf8");
         await context.emit({
             role: "assistant",
             kind: "message",
@@ -297,7 +298,8 @@ export class DeterministicProviderCliService {
                 verdictJson,
                 report,
                 producedBy: "forge-bridge",
-                status: "pass"
+                status: "pass",
+                phase: "implementation"
             }
         };
     }
@@ -406,6 +408,10 @@ async function resolveProviderProcessLaunch(command, args) {
     if (process.platform !== "win32") {
         return { command, args };
     }
+    const cursorDirect = await resolveCursorAgentDirectLaunch(command, args);
+    if (cursorDirect) {
+        return cursorDirect;
+    }
     const resolved = await resolveWindowsCommand(command);
     return resolved ? buildWindowsLaunchCommand(resolved, args) : { command, args };
 }
@@ -413,10 +419,6 @@ async function resolveWindowsCommand(command) {
     if (path.isAbsolute(command)) {
         return command;
     }
-    const cursorScript = await resolveCursorAgentPowerShellScript(command);
-    if (cursorScript) {
-        return cursorScript;
-    }
     try {
         const result = await execFileAsync("where.exe", [command], { timeout: 2000 });
         return chooseWindowsCommandCandidate(result.stdout.split(/\r?\n/));
@@ -425,18 +427,6 @@ async function resolveWindowsCommand(command) {
         return null;
     }
 }
-async function resolveCursorAgentPowerShellScript(command) {
-    const normalized = command.trim().toLowerCase();
-    if (normalized !== "cursor-agent" && normalized !== "agent") {
-        return null;
-    }
-    const localAppData = process.env.LOCALAPPDATA;
-    if (!localAppData) {
-        return null;
-    }
-    const script = path.join(localAppData, "cursor-agent", "cursor-agent.ps1");
-    return await fileExists(script) ? script : null;
-}
 export function chooseWindowsCommandCandidate(candidates) {
     const normalized = candidates
         .map((candidate) => candidate.trim())
@@ -518,7 +508,11 @@ export function buildProviderCliCommand(dispatch, run) {
     const normalizedProvider = provider.toLowerCase();
     const model = dispatch.execution.model.trim();
     if (normalizedProvider === "codex") {
-        const args = ["exec", "--model", model];
+        const args = ["exec"];
+        if (run?.completionTools) {
+            args.push(...codexMcpConfigArgs(run.completionTools));
+        }
+        args.push("--model", model);
         if (run) {
             args.push("--json", "--dangerously-bypass-approvals-and-sandbox");
             if (run.worktreePath) {
@@ -529,10 +523,12 @@ export function buildProviderCliCommand(dispatch, run) {
         return { command: "codex", args };
     }
     if (normalizedProvider === "cursor") {
-        const args = ["--model", model];
+        const args = ["--print", "--output-format", "stream-json", "--model", model];
+        if (run?.worktreePath) {
+            args.push("--workspace", run.worktreePath);
+        }
         if (run?.prompt) {
-            args.push("--yolo");
-            args.push(run.prompt);
+            args.push("--yolo", "--approve-mcps", "--trust", run.prompt);
         }
         return { command: "cursor-agent", args };
     }
@@ -542,14 +538,27 @@ export function buildProviderCliCommand(dispatch, run) {
     }
     return { command: provider, args };
 }
-function buildImplementationPrompt(dispatch) {
-    return `You are Forge's Develop lane running locally in a prepared git worktree.
+function buildImplementationPrompt(dispatch, phase = completionPhaseFromDispatch(dispatch)) {
+    return `You are Forge's ${phase.replace(/_/g, " ")} phase runner running locally in a prepared git worktree.
 
-Read .forge/work-items/${dispatch.workItem.id}/spec.md, implement the work item, and keep the change focused.
+Read .forge/work-items/${dispatch.workItem.id}/spec.md and any prior phase artifacts required by this phase.
+${phaseWorkInstruction(phase)}
 Use the repository's existing conventions. Run relevant tests when practical.
-The runner owns Forge protocol files: worktree prep, injected .forge commands/hooks/skills, phase verdict artifacts, reports, and commits.
-Only read the work item spec under .forge; do not edit .forge files or create Forge verdict/report artifacts.
-Finish with a concise summary of changed files and verification.`;
+Forge owns protocol files: worktree prep, injected .forge commands/hooks/skills, phase verdict artifacts, reports, and commits.
+Read Forge-provided context under .forge when needed, but do not edit .forge files or create Forge verdict/report artifacts by hand.
+
+${completionPromptForPhase(phase)}
+
+Finish with a concise summary of changed files and verification after calling the completion tool.`;
+}
+function phaseWorkInstruction(phase) {
+    if (phase === "self_review") {
+        return "Review the implementation diff, apply safe fixes when needed, and record remaining risks explicitly.";
+    }
+    if (phase === "validation") {
+        return "Run the validation commands and deterministic drift checks needed to prove the work is ready for Dev Test.";
+    }
+    return "Implement the work item and keep the change focused.";
 }
 function buildQaPrompt(dispatch) {
     return `You are Forge's QA lane running locally.
@@ -570,6 +579,19 @@ Keep the original work item intent intact:
 
 Finish with a concise summary of the conflicts resolved and verification performed.`;
 }
+async function cleanupCompletionTools(completionTools, emit) {
+    try {
+        await completionTools.cleanup();
+    }
+    catch (error) {
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Forge completion tool cleanup failed and was ignored: ${clip(messageFromError(error), 600)}`,
+            eventType: "completion_tools_cleanup_failed"
+        }).catch(() => undefined);
+    }
+}
 async function commitWorktreeChanges(git, worktreePath, workItemId) {
     await git.run(worktreePath, ["add", "-A"]);
     await git.run(worktreePath, ["reset", "--", ".forge"]).catch(() => "");
@@ -586,26 +608,8 @@ async function commitWorktreeChanges(git, worktreePath, workItemId) {
     const commitSha = (await git.run(worktreePath, ["rev-parse", "HEAD"])).trim();
     return { commitSha, changedFiles };
 }
-function buildImplementationReport(dispatch, command, committed, codexState) {
-    const files = committed.changedFiles.length > 0
-        ? committed.changedFiles.map((file) => `- ${file}`).join("\n")
-        : "- No staged repository files changed; Forge recorded an empty completion commit.";
-    return `# Implementation report
-
-Provider: ${dispatch.execution.provider}
-Model: ${dispatch.execution.model}
-Command: ${formatProviderCliCommand(command)}
-Thread: ${codexState.threadId ?? "n/a"}
-Commit: ${committed.commitSha}
-
-## Changed files
-
-${files}
-
-## Final message
-
-${codexState.finalMessage ?? "Provider CLI completed without a final assistant message."}
-`;
+function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
 }
 function clip(value, maxLength) {
     if (value.length <= maxLength) {
@@ -613,27 +617,203 @@ function clip(value, maxLength) {
     }
     return `${value.slice(0, maxLength)}...`;
 }
-class CodexJsonState {
-    threadId = null;
+function createProviderOutputState(provider) {
+    return provider.trim().toLowerCase() === "cursor"
+        ? new CursorStreamJsonState()
+        : new CodexJsonState();
+}
+class CursorStreamJsonState {
+    sessionId = null;
     finalMessage = null;
-    emittedThread = false;
+    emittedSession = false;
+    get sessionLabel() {
+        return this.sessionId ? `session ${this.sessionId}` : null;
+    }
     consume(line) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("{")) {
+        const event = parseJsonLine(line);
+        if (!event) {
             return null;
         }
-        let parsed;
-        try {
-            parsed = JSON.parse(trimmed);
+        const type = stringField(event, "type");
+        if (type === "system" && stringField(event, "subtype") === "init") {
+            this.sessionId = stringField(event, "session_id");
+            if (this.sessionId && !this.emittedSession) {
+                this.emittedSession = true;
+                return {
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: `Cursor session started: ${this.sessionId}.`,
+                    eventType: "provider_thread_started"
+                };
+            }
+        }
+        if (type === "assistant") {
+            const text = assistantMessageText(event);
+            if (text) {
+                this.finalMessage = clip(text, 4000);
+                return {
+                    role: "assistant",
+                    kind: "message",
+                    content: this.finalMessage,
+                    eventType: "provider_message"
+                };
+            }
+        }
+        if (type === "tool_call") {
+            const subtype = stringField(event, "subtype");
+            const toolCall = objectField(event, "tool_call");
+            if (subtype === "started") {
+                const summary = formatCursorToolCallStarted(toolCall);
+                if (summary) {
+                    return {
+                        role: "worker",
+                        kind: "checkpoint",
+                        content: summary,
+                        eventType: "provider_tool_call"
+                    };
+                }
+            }
+            if (subtype === "completed") {
+                const completed = formatCursorToolCallCompleted(toolCall);
+                if (completed) {
+                    return {
+                        role: "worker",
+                        kind: completed.kind,
+                        content: completed.content,
+                        eventType: completed.kind === "file_edit" ? "provider_file_edit" : "provider_tool_call"
+                    };
+                }
+            }
+        }
+        if (type === "result" && stringField(event, "subtype") === "success") {
+            const result = stringField(event, "result");
+            if (result) {
+                this.finalMessage = clip(result, 4000);
+            }
+        }
+        if (type === "error" || (type === "result" && event.is_error === true)) {
+            return {
+                role: "runner",
+                kind: "error",
+                content: clip(line.trim(), 1000),
+                eventType: "provider_cli_error"
+            };
         }
-        catch {
+        return null;
+    }
+}
+function formatCursorToolCallStarted(toolCall) {
+    const readArgs = objectField(objectField(toolCall, "readToolCall"), "args");
+    const readPath = stringField(readArgs, "path");
+    if (readPath) {
+        return `Reading ${readPath}`;
+    }
+    const writeArgs = objectField(objectField(toolCall, "writeToolCall"), "args");
+    const writePath = stringField(writeArgs, "path");
+    if (writePath) {
+        return `Writing ${writePath}`;
+    }
+    const shellArgs = objectField(objectField(toolCall, "shellToolCall"), "args");
+    const command = stringField(shellArgs, "command");
+    if (command) {
+        return `Shell command started: ${clip(command, 500)}`;
+    }
+    const fn = objectField(toolCall, "function");
+    const name = stringField(fn, "name");
+    if (name) {
+        return `Tool call started: ${name}`;
+    }
+    return null;
+}
+function formatCursorToolCallCompleted(toolCall) {
+    const writeArgs = objectField(objectField(toolCall, "writeToolCall"), "args");
+    const writePath = stringField(writeArgs, "path");
+    const writeResult = objectField(objectField(objectField(toolCall, "writeToolCall"), "result"), "success");
+    const writtenPath = stringField(writeResult, "path") ?? writePath;
+    if (writtenPath) {
+        return {
+            kind: "file_edit",
+            content: `Wrote ${writtenPath}`
+        };
+    }
+    const readArgs = objectField(objectField(toolCall, "readToolCall"), "args");
+    const readPath = stringField(readArgs, "path");
+    if (readPath) {
+        const readResult = objectField(objectField(objectField(toolCall, "readToolCall"), "result"), "success");
+        const totalLines = readResult.totalLines;
+        const lineSummary = typeof totalLines === "number" ? ` (${totalLines} lines)` : "";
+        return {
+            kind: "checkpoint",
+            content: `Read ${readPath}${lineSummary}`
+        };
+    }
+    const shellArgs = objectField(objectField(toolCall, "shellToolCall"), "args");
+    const command = stringField(shellArgs, "command");
+    if (command) {
+        return {
+            kind: "checkpoint",
+            content: `Shell command completed: ${clip(command, 500)}`
+        };
+    }
+    const fn = objectField(toolCall, "function");
+    const name = stringField(fn, "name");
+    if (name) {
+        return {
+            kind: "checkpoint",
+            content: `Tool call completed: ${name}`
+        };
+    }
+    return null;
+}
+function assistantMessageText(event) {
+    const message = objectField(event, "message");
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const parts = content
+        .map((entry) => {
+        if (!entry || typeof entry !== "object") {
             return null;
         }
-        if (!parsed || typeof parsed !== "object") {
+        const block = entry;
+        return stringField(block, "text");
+    })
+        .filter((text) => Boolean(text));
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("");
+}
+function parseJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed
+        : null;
+}
+class CodexJsonState {
+    threadId = null;
+    finalMessage = null;
+    emittedThread = false;
+    get sessionLabel() {
+        return this.threadId ? `thread ${this.threadId}` : null;
+    }
+    consume(line) {
+        const event = parseJsonLine(line);
+        if (!event) {
             return null;
         }
-        const event = parsed;
-        const type = typeof event.type === "string" ? event.type : "";
+        const type = stringField(event, "type") ?? "";
         if (type === "thread.started") {
             this.threadId = stringField(event, "thread_id");
             if (this.threadId && !this.emittedThread) {
@@ -658,7 +838,7 @@ class CodexJsonState {
             return {
                 role: "runner",
                 kind: "error",
-                content: clip(trimmed, 1000),
+                content: clip(line.trim(), 1000),
                 eventType: "provider_cli_error"
             };
         }

package/dist/session/provider-cli/provider-cli.types.d.ts

@@ -10,4 +10,5 @@ export interface ProviderCliRunResult {
     readonly summary: string;
     readonly spec?: RunnerDispatchSpec | null;
     readonly artifact?: RunnerDispatchArtifact | null;
+    readonly artifacts?: readonly RunnerDispatchArtifact[] | null;
 }