@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599

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

@@ -0,0 +1,705 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+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 { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
+const fakeWorkerModel = "server-local-fake-worker";
+const execFileAsync = promisify(execFile);
+export class RoutingProviderCliService {
+    realProvider;
+    deterministicProvider;
+    constructor(realProvider = new ProcessBackedProviderCliService(), deterministicProvider = new DeterministicProviderCliService()) {
+        this.realProvider = realProvider;
+        this.deterministicProvider = deterministicProvider;
+    }
+    async runImplementation(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runImplementation(context)
+            : await this.realProvider.runImplementation(context);
+    }
+    async runConflictResolve(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runConflictResolve(context)
+            : await this.realProvider.runConflictResolve(context);
+    }
+    async runQa(dispatch, emit, signal) {
+        return isFakeWorkerModel(dispatch.execution.model)
+            ? await this.deterministicProvider.runQa(dispatch, emit, signal)
+            : await this.realProvider.runQa(dispatch, emit, signal);
+    }
+}
+export class ProcessBackedProviderCliService {
+    processRunner;
+    git;
+    constructor(processRunner = new StreamingProviderProcessRunner(), git = new GitClient()) {
+        this.processRunner = processRunner;
+        this.git = git;
+    }
+    async runImplementation(context) {
+        const { dispatch, worktree } = context;
+        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
+        const artifactRoot = path.join(metadataRoot, "artifacts");
+        await fs.mkdir(artifactRoot, { 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 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 command = buildProviderCliCommand(dispatch, {
+            worktreePath: worktree.worktreePath,
+            prompt: buildImplementationPrompt(dispatch)
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            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);
+                }
+            }
+        }, context.signal);
+        if (result.exitCode !== 0) {
+            const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
+            throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+        }
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Provider CLI completed: ${command.command} exit ${result.exitCode}${codexState.threadId ? ` thread ${codexState.threadId}` : ""}.`,
+            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) {
+            await context.emit({
+                role: "assistant",
+                kind: "message",
+                content: codexState.finalMessage,
+                eventType: "implementation_complete"
+            });
+        }
+        else {
+            await context.emit({
+                role: "assistant",
+                kind: "message",
+                content: `${dispatch.execution.provider} CLI completed for ${worktree.branchName}.`,
+                eventType: "implementation_complete"
+            });
+        }
+        return {
+            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName}.`,
+            spec: {
+                repoPath: worktree.worktreePath,
+                path: specPath,
+                body: specBody,
+                producedBy: "forge-lane-command",
+                status: "approved"
+            },
+            artifact: {
+                repoPath: worktree.worktreePath,
+                path: artifactPath,
+                verdictJson,
+                report,
+                producedBy: `${dispatch.execution.provider}-cli`,
+                status: "pass"
+            }
+        };
+    }
+    async runQa(dispatch, emit, signal) {
+        const command = buildProviderCliCommand(dispatch, {
+            prompt: buildQaPrompt(dispatch)
+        });
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Starting provider CLI QA: ${formatProviderCliCommand(command)}`,
+            eventType: "provider_cli_started"
+        });
+        const codexState = new CodexJsonState();
+        const result = await this.processRunner.run({
+            command: command.command,
+            args: command.args,
+            cwd: process.cwd()
+        }, {
+            onStdoutLine: async (line) => {
+                const event = codexState.consume(line);
+                if (event) {
+                    await emit(event);
+                }
+            }
+        }, signal);
+        if (result.exitCode !== 0) {
+            const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
+            throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+        }
+        await emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Provider CLI QA completed: ${command.command} exit ${result.exitCode}${codexState.threadId ? ` thread ${codexState.threadId}` : ""}.`,
+            eventType: "provider_cli_completed"
+        });
+        return {
+            summary: `${dispatch.execution.provider} CLI QA passed.`
+        };
+    }
+    async runConflictResolve(context) {
+        const { dispatch, worktree } = context;
+        const command = buildProviderCliCommand(dispatch, {
+            worktreePath: worktree.worktreePath,
+            prompt: buildConflictResolvePrompt(dispatch, worktree.branchName)
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Starting provider CLI conflict resolve: ${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);
+                }
+            }
+        }, context.signal);
+        if (result.exitCode !== 0) {
+            const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
+            throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+        }
+        const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
+        await this.git.run(worktree.worktreePath, ["push", "origin", `HEAD:${worktree.branchName}`]);
+        await context.emit({
+            role: "assistant",
+            kind: "message",
+            content: codexState.finalMessage || `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`,
+            eventType: "conflict_resolve_complete"
+        });
+        return {
+            summary: `${dispatch.execution.provider} CLI resolved conflicts on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`
+        };
+    }
+}
+export class DeterministicProviderCliService {
+    git;
+    constructor(git = new GitClient()) {
+        this.git = git;
+    }
+    async runImplementation(context) {
+        const { dispatch, worktree } = context;
+        const providerCommand = buildProviderCliCommand(dispatch);
+        const providerCommandText = formatProviderCliCommand(providerCommand);
+        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
+        const artifactRoot = path.join(metadataRoot, "artifacts");
+        await fs.mkdir(artifactRoot, { 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)}
+## Execution
+
+- Provider: ${singleLine(dispatch.execution.provider)}
+- Model: ${singleLine(dispatch.execution.model)}
+- Command: ${providerCommandText}
+`;
+        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 changesetPath = path.join(worktree.worktreePath, "FORGE_PHASE5_CHANGESET.md");
+        const changesetBody = `# Forge Phase 5 bridge changeset\n\nWork item: ${dispatch.workItem.id}\nTitle: ${dispatch.workItem.title}\nBranch: ${worktree.branchName}\nProvider: ${singleLine(dispatch.execution.provider)}\nModel: ${singleLine(dispatch.execution.model)}\nCommand: ${providerCommandText}\n\nThis deterministic file is written by forge-bridge run-once through the shared session/worktree service path.\n`;
+        await fs.writeFile(changesetPath, changesetBody, "utf8");
+        await this.git.run(worktree.worktreePath, ["add", "FORGE_PHASE5_CHANGESET.md"]);
+        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge changeset for ${dispatch.workItem.id.slice(0, 8)}`]);
+        await context.emit({
+            role: "worker",
+            kind: "file_edit",
+            content: `Created bridge changeset at ${changesetPath}`,
+            eventType: "changeset"
+        });
+        const verdict = {
+            schema_version: 1,
+            status: "pass",
+            checks: [{ name: "forge_bridge_run_once", status: "pass" }],
+            metrics: { files_changed: 1 },
+            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");
+        await fs.writeFile(artifactPath, verdictJson + "\n", "utf8");
+        await fs.writeFile(path.join(artifactRoot, "implementation.report.md"), report, "utf8");
+        await context.emit({
+            role: "assistant",
+            kind: "message",
+            content: "Implementation complete. forge-bridge produced deterministic phase artifacts.",
+            eventType: "implementation_complete"
+        });
+        return {
+            summary: `forge-bridge completed ${worktree.branchName}.`,
+            spec: {
+                repoPath: worktree.worktreePath,
+                path: specPath,
+                body: specBody,
+                producedBy: "forge-lane-command",
+                status: "approved"
+            },
+            artifact: {
+                repoPath: worktree.worktreePath,
+                path: artifactPath,
+                verdictJson,
+                report,
+                producedBy: "forge-bridge",
+                status: "pass"
+            }
+        };
+    }
+    async runQa(dispatch, emit) {
+        await emit({
+            role: "worker",
+            kind: "message",
+            content: `Running ${dispatch.execution.provider} QA checks through forge-bridge.`,
+            eventType: "qa_analysis"
+        });
+        await emit({
+            role: "assistant",
+            kind: "message",
+            content: "All checks passed. forge-bridge QA completed.",
+            eventType: "qa_complete"
+        });
+        return {
+            summary: "forge-bridge QA passed."
+        };
+    }
+    async runConflictResolve(context) {
+        const { dispatch, worktree } = context;
+        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge conflict resolve for ${dispatch.workItem.id.slice(0, 8)}`]);
+        await context.emit({
+            role: "assistant",
+            kind: "message",
+            content: `Deterministic conflict resolve completed for ${worktree.branchName}.`,
+            eventType: "conflict_resolve_complete"
+        });
+        return {
+            summary: `forge-bridge resolved conflicts for ${worktree.branchName}.`
+        };
+    }
+}
+export class StreamingProviderProcessRunner {
+    async run(request, handlers = {}, signal) {
+        const launch = await resolveProviderProcessLaunch(request.command, request.args);
+        return await new Promise((resolve, reject) => {
+            const child = spawn(launch.command, launch.args, {
+                cwd: request.cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true
+            });
+            let stdout = "";
+            let stderr = "";
+            let settled = false;
+            const cleanup = () => {
+                signal?.removeEventListener("abort", abort);
+            };
+            const fail = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const abort = () => {
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch {
+                    // Best effort; close/error will settle the promise.
+                }
+            };
+            if (signal?.aborted) {
+                abort();
+            }
+            else {
+                signal?.addEventListener("abort", abort, { once: true });
+            }
+            child.on("error", fail);
+            const readers = [
+                readProcessLines(child.stdout, (line) => {
+                    stdout += `${line}\n`;
+                    return handlers.onStdoutLine?.(line);
+                }),
+                readProcessLines(child.stderr, (line) => {
+                    stderr += `${line}\n`;
+                    return handlers.onStderrLine?.(line);
+                })
+            ];
+            child.on("close", (code) => {
+                Promise.allSettled(readers).then((readerResults) => {
+                    const rejected = readerResults.find((result) => result.status === "rejected");
+                    if (rejected?.status === "rejected") {
+                        fail(rejected.reason);
+                        return;
+                    }
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    cleanup();
+                    resolve({
+                        exitCode: code ?? 1,
+                        stdout,
+                        stderr
+                    });
+                }).catch(fail);
+            });
+        });
+    }
+}
+async function resolveProviderProcessLaunch(command, args) {
+    if (process.platform !== "win32") {
+        return { command, args };
+    }
+    const resolved = await resolveWindowsCommand(command);
+    return resolved ? buildWindowsLaunchCommand(resolved, args) : { command, args };
+}
+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/));
+    }
+    catch {
+        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())
+        .filter((candidate) => candidate.length > 0);
+    if (normalized.length === 0) {
+        return null;
+    }
+    const preferredExtensions = [".exe", ".ps1", ".cmd", ".bat", ""];
+    for (const extension of preferredExtensions) {
+        const candidate = normalized.find((entry) => path.extname(entry).toLowerCase() === extension);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return normalized[0];
+}
+export function buildWindowsLaunchCommand(commandPath, args) {
+    const extension = path.extname(commandPath).toLowerCase();
+    if (extension === ".ps1") {
+        return {
+            command: powershellExecutable(),
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", commandPath, ...args]
+        };
+    }
+    if (extension === ".cmd" || extension === ".bat") {
+        return {
+            command: process.env.ComSpec ?? "cmd.exe",
+            args: ["/d", "/s", "/c", windowsCommandLine(commandPath, args)]
+        };
+    }
+    return { command: commandPath, args };
+}
+function powershellExecutable() {
+    const systemRoot = process.env.SystemRoot;
+    return systemRoot
+        ? path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
+        : "powershell.exe";
+}
+function windowsCommandLine(command, args) {
+    return [command, ...args].map(quoteWindowsCommandLineArg).join(" ");
+}
+function quoteWindowsCommandLineArg(value) {
+    if (value.length > 0 && !/[\s"]/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+}
+async function fileExists(inputPath) {
+    return fs.stat(inputPath).then((stat) => stat.isFile()).catch(() => false);
+}
+async function readProcessLines(stream, onLine) {
+    const reader = readline.createInterface({ input: stream });
+    try {
+        for await (const line of reader) {
+            await onLine(line);
+        }
+    }
+    finally {
+        reader.close();
+    }
+}
+function isFakeWorkerModel(model) {
+    return model.trim().toLowerCase() === fakeWorkerModel;
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}
+export function formatProviderCliCommand(command) {
+    return [command.command, ...command.args].map(singleLine).join(" ");
+}
+function yamlQuotedScalar(value) {
+    return JSON.stringify(singleLine(value));
+}
+function singleLine(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function buildProviderCliCommand(dispatch, run) {
+    const provider = dispatch.execution.provider.trim();
+    const normalizedProvider = provider.toLowerCase();
+    const model = dispatch.execution.model.trim();
+    if (normalizedProvider === "codex") {
+        const args = ["exec", "--model", model];
+        if (run) {
+            args.push("--json", "--dangerously-bypass-approvals-and-sandbox");
+            if (run.worktreePath) {
+                args.push("--cd", run.worktreePath);
+            }
+            args.push(run.prompt ?? "");
+        }
+        return { command: "codex", args };
+    }
+    if (normalizedProvider === "cursor") {
+        const args = ["--model", model];
+        if (run?.prompt) {
+            args.push("--yolo");
+            args.push(run.prompt);
+        }
+        return { command: "cursor-agent", args };
+    }
+    const args = ["--model", model];
+    if (run?.prompt) {
+        args.push(run.prompt);
+    }
+    return { command: provider, args };
+}
+function buildImplementationPrompt(dispatch) {
+    return `You are Forge's Develop lane 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.
+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.`;
+}
+function buildQaPrompt(dispatch) {
+    return `You are Forge's QA lane running locally.
+
+Review the implementation for work item ${dispatch.workItem.id}: ${dispatch.workItem.title}
+Run relevant verification when practical and finish with a concise QA verdict.`;
+}
+function buildConflictResolvePrompt(dispatch, branchName) {
+    const targetBranch = dispatch.cycleRun.requestedBase || dispatch.repo.defaultBranch || "main";
+    return `You are Forge's Conflict Resolve lane running locally in a prepared git worktree.
+
+The current branch is the pull request branch ${branchName}. Resolve merge conflicts against ${targetBranch}.
+Fetch origin, merge or rebase ${targetBranch} into ${branchName}, resolve conflicts conservatively, run relevant validation when practical, commit the resolution, and push ${branchName} to origin.
+Keep the original work item intent intact:
+- Work item: ${dispatch.workItem.id}
+- Title: ${dispatch.workItem.title}
+- Acceptance criteria: ${dispatch.workItem.acceptanceCriteria || "Not specified"}
+
+Finish with a concise summary of the conflicts resolved and verification performed.`;
+}
+async function commitWorktreeChanges(git, worktreePath, workItemId) {
+    await git.run(worktreePath, ["add", "-A"]);
+    await git.run(worktreePath, ["reset", "--", ".forge"]).catch(() => "");
+    const changedFiles = (await git.run(worktreePath, ["diff", "--cached", "--name-only"]))
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (changedFiles.length > 0) {
+        await git.run(worktreePath, ["commit", "-m", `provider cli changeset for ${workItemId.slice(0, 8)}`]);
+    }
+    else {
+        await git.run(worktreePath, ["commit", "--allow-empty", "-m", `provider cli completed for ${workItemId.slice(0, 8)}`]);
+    }
+    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 clip(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}...`;
+}
+class CodexJsonState {
+    threadId = null;
+    finalMessage = null;
+    emittedThread = false;
+    consume(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{")) {
+            return null;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            return null;
+        }
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const event = parsed;
+        const type = typeof event.type === "string" ? event.type : "";
+        if (type === "thread.started") {
+            this.threadId = stringField(event, "thread_id");
+            if (this.threadId && !this.emittedThread) {
+                this.emittedThread = true;
+                return {
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: `Codex thread started: ${this.threadId}.`,
+                    eventType: "provider_thread_started"
+                };
+            }
+        }
+        if (type === "turn.completed") {
+            return {
+                role: "runner",
+                kind: "checkpoint",
+                content: "Codex turn completed.",
+                eventType: "provider_turn_completed"
+            };
+        }
+        if (type === "turn.failed" || type === "error") {
+            return {
+                role: "runner",
+                kind: "error",
+                content: clip(trimmed, 1000),
+                eventType: "provider_cli_error"
+            };
+        }
+        if (type === "item.completed" || type === "item.updated") {
+            const item = objectField(event, "item");
+            const itemType = stringField(item, "type");
+            if (itemType === "agent_message") {
+                const text = stringField(item, "text");
+                if (text) {
+                    this.finalMessage = clip(text, 4000);
+                    return {
+                        role: "assistant",
+                        kind: "message",
+                        content: this.finalMessage,
+                        eventType: "provider_message"
+                    };
+                }
+            }
+            if (itemType === "command_execution") {
+                const command = stringField(item, "command");
+                const status = stringField(item, "status");
+                if (command) {
+                    return {
+                        role: "worker",
+                        kind: "checkpoint",
+                        content: `Codex command ${status || "completed"}: ${clip(command, 500)}`,
+                        eventType: "provider_command"
+                    };
+                }
+            }
+        }
+        return null;
+    }
+}
+function objectField(source, key) {
+    const value = source[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringField(source, key) {
+    const value = source[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}