@loucompanion/forge-bridge 0.1.1-dev.af36c7fa102b → 0.1.1-dev.caea7216568f

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

@@ -5,10 +5,13 @@ 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, completionPhaseFromDispatch, completionPromptForPhase, prepareCompletionToolRuntime, readCompletionArtifact } from "../phase-completion.js";
+import { codexMcpConfigArgs, completionPhaseFromDispatch, completionPromptForDevelopCycle, completionPromptForPhase, completionRedactionEnv, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, usesDevelopCycleCompletion, writeCompletionArtifact, artifactRootFor } from "../phase-completion.js";
+import { addUsage, buildProviderUsageEvent, emptyUsage, hasUsage, readUsageNumber } from "./provider-usage.js";
 const fakeWorkerModel = "server-local-fake-worker";
 const execFileAsync = promisify(execFile);
+const developCyclePhaseOrder = ["implementation", "self_review", "validation"];
 export class RoutingProviderCliService {
     realProvider;
     deterministicProvider;
@@ -26,10 +29,10 @@ export class RoutingProviderCliService {
             ? 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);
+    async runQa(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runQa(context)
+            : await this.realProvider.runQa(context);
     }
 }
 export class ProcessBackedProviderCliService {
@@ -42,6 +45,7 @@ export class ProcessBackedProviderCliService {
     async runImplementation(context) {
         const { dispatch, worktree } = context;
         const phase = completionPhaseFromDispatch(dispatch);
+        const developCycle = usesDevelopCycleCompletion(dispatch);
         const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
         await fs.mkdir(metadataRoot, { recursive: true });
         const laneCommand = selectLaneCommand(dispatch.artifacts, dispatch.execution.lane, dispatch.cycleRun.phase);
@@ -55,7 +59,7 @@ export class ProcessBackedProviderCliService {
         const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildImplementationPrompt(dispatch, phase),
+            prompt: developCycle ? buildDevelopCyclePrompt(dispatch, phase) : buildImplementationPrompt(dispatch, phase),
             completionTools
         });
         await context.emit({
@@ -67,19 +71,24 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Forge completion tools configured for ${phase}; provider must call the MCP completion tool before exit.`,
+            content: developCycle
+                ? "Forge completion tools configured for implementation -> self_review -> validation; provider must call each MCP completion tool before exit."
+                : `Forge completion tools configured for ${phase}; provider must call the MCP completion tool before exit.`,
             eventType: "completion_tools_configured"
         });
-        const codexState = new CodexJsonState();
+        const outputState = createProviderOutputState(dispatch.execution.provider);
+        const liveCompletionEvents = new LiveCompletionArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, phase, developCycle, context.emit);
         let result;
         try {
+            liveCompletionEvents.start();
             result = await this.processRunner.run({
                 command: command.command,
                 args: command.args,
-                cwd: worktree.worktreePath
+                cwd: worktree.worktreePath,
+                env: providerRedactionEnv(dispatch)
             }, {
                 onStdoutLine: async (line) => {
-                    const event = codexState.consume(line);
+                    const event = outputState.consume(line);
                     if (event) {
                         await context.emit(event);
                     }
@@ -87,6 +96,7 @@ export class ProcessBackedProviderCliService {
             }, context.signal);
         }
         finally {
+            await liveCompletionEvents.stop();
             await cleanupCompletionTools(completionTools, context.emit);
         }
         if (result.exitCode !== 0) {
@@ -96,20 +106,26 @@ 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"
         });
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
-        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.`);
+        const completionArtifacts = await readCompletionArtifactsForRun(worktree.worktreePath, dispatch.workItem.id, phase, developCycle);
+        for (const artifact of completionArtifacts) {
+            if (!liveCompletionEvents.hasEmitted(completionPhaseFromArtifact(artifact))) {
+                await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, artifact);
+                await emitPhaseCompletionEvent(context.emit, artifact);
+                await emitPhaseGateEvents(context.emit, artifact);
+            }
         }
-        if (codexState.finalMessage) {
+        const completionArtifact = completionArtifacts[0];
+        if (outputState.finalMessage) {
             await context.emit({
                 role: "assistant",
                 kind: "message",
-                content: codexState.finalMessage,
-                eventType: "implementation_complete"
+                content: outputState.finalMessage,
+                eventType: "provider_final_message"
             });
         }
         else {
@@ -117,11 +133,11 @@ export class ProcessBackedProviderCliService {
                 role: "assistant",
                 kind: "message",
                 content: `${dispatch.execution.provider} CLI completed for ${worktree.branchName}.`,
-                eventType: "implementation_complete"
+                eventType: "provider_final_message"
             });
         }
         return {
-            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName} (${phase}, ${committed.commitSha.slice(0, 12)}).`,
+            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName} (${developCycle ? "develop cycle" : phase}, ${committed.commitSha.slice(0, 12)}).`,
             spec: {
                 repoPath: worktree.worktreePath,
                 path: specPath,
@@ -129,44 +145,86 @@ export class ProcessBackedProviderCliService {
                 producedBy: "forge-lane-command",
                 status: "approved"
             },
-            artifact: completionArtifact
+            artifact: completionArtifact,
+            artifacts: completionArtifacts
         };
     }
-    async runQa(dispatch, emit, signal) {
+    async runQa(context) {
+        const { dispatch, worktree } = context;
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "qa" });
         const command = buildProviderCliCommand(dispatch, {
-            prompt: buildQaPrompt(dispatch)
+            worktreePath: worktree.worktreePath,
+            prompt: buildQaPrompt(dispatch),
+            completionTools
         });
-        await emit({
+        const commandText = formatProviderCliCommand(command);
+        await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI QA: ${formatProviderCliCommand(command)}`,
+            content: `Starting provider CLI QA: ${commandText} in ${worktree.worktreePath}`,
             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);
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: "Forge QA completion tool configured; provider must call forge.complete_qa before exit.",
+            eventType: "completion_tools_configured"
+        });
+        const outputState = createProviderOutputState(dispatch.execution.provider);
+        const liveQaEvents = new LiveQaArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, context.emit);
+        let result;
+        try {
+            liveQaEvents.start();
+            result = await this.processRunner.run({
+                command: command.command,
+                args: command.args,
+                cwd: worktree.worktreePath,
+                env: providerRedactionEnv(dispatch)
+            }, {
+                onStdoutLine: async (line) => {
+                    const event = outputState.consume(line);
+                    if (event) {
+                        await context.emit(event);
+                    }
                 }
-            }
-        }, signal);
+            }, context.signal);
+        }
+        finally {
+            await liveQaEvents.stop();
+            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}` : ""}`);
         }
-        await emit({
+        await context.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"
         });
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
+        const qaArtifact = await readQaCompletionArtifactBundle(worktree.worktreePath, dispatch.workItem.id);
+        if (!qaArtifact) {
+            const verdictOnly = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "qa");
+            throw new Error(verdictOnly
+                ? "Provider CLI QA completed but did not produce the complete durable QA artifact bundle."
+                : "Provider CLI QA completed but did not call the Forge QA completion tool.");
+        }
+        if (!liveQaEvents.hasEmitted()) {
+            await emitQaArtifactRecorded(context.emit, worktree.worktreePath, qaArtifact);
+            await emitQaStructuredEvents(context.emit, worktree.worktreePath, dispatch.workItem.id, qaArtifact);
+        }
+        const status = (qaArtifact.status ?? "unknown").trim().toLowerCase();
+        const statusSummary = status === "pass"
+            ? "passed"
+            : status === "blocked"
+                ? "blocked"
+                : "found rework";
         return {
-            summary: `${dispatch.execution.provider} CLI QA passed.`
+            summary: `${dispatch.execution.provider} CLI QA ${statusSummary}.`,
+            artifact: qaArtifact,
+            artifacts: [qaArtifact]
         };
     }
     async runConflictResolve(context) {
@@ -181,14 +239,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);
                 }
@@ -200,10 +258,11 @@ export class ProcessBackedProviderCliService {
         }
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
         await this.git.run(worktree.worktreePath, ["push", "origin", `HEAD:${worktree.branchName}`]);
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
         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 {
@@ -219,6 +278,7 @@ export class DeterministicProviderCliService {
     async runImplementation(context) {
         const { dispatch, worktree } = context;
         const phase = completionPhaseFromDispatch(dispatch);
+        const developCycle = usesDevelopCycleCompletion(dispatch);
         const providerCommand = buildProviderCliCommand(dispatch);
         const providerCommandText = formatProviderCliCommand(providerCommand);
         const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
@@ -249,27 +309,34 @@ export class DeterministicProviderCliService {
             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"
-        });
+        const phases = developCycle
+            ? ["implementation", "self_review", "validation"]
+            : [phase];
+        const completionArtifacts = [];
+        for (const completionPhase of phases) {
+            await writeCompletionArtifact({
+                worktreePath: worktree.worktreePath,
+                workItemId: dispatch.workItem.id,
+                phase: completionPhase,
+                producedBy: "forge-bridge",
+                redactionSecrets: exactRedactionSecrets(dispatch)
+            }, expectedCompletionToolName(completionPhase), deterministicCompletionPayload(completionPhase, dispatch, changesetBody));
+            const completionArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, completionPhase);
+            if (!completionArtifact) {
+                throw new Error(`Deterministic provider did not produce the Forge ${completionPhase} completion artifact.`);
+            }
+            completionArtifacts.push(completionArtifact);
+            await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, completionArtifact);
+            await context.emit({
+                role: "assistant",
+                kind: "message",
+                content: `${completionPhase.replace(/_/g, " ")} complete. forge-bridge produced deterministic phase artifacts.`,
+                eventType: phaseCompleteEventType(completionPhase)
+            });
+        }
+        await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
         return {
-            summary: `forge-bridge completed ${worktree.branchName}.`,
+            summary: `forge-bridge completed ${worktree.branchName} (${developCycle ? "develop cycle" : phase}).`,
             spec: {
                 repoPath: worktree.worktreePath,
                 path: specPath,
@@ -277,36 +344,42 @@ export class DeterministicProviderCliService {
                 producedBy: "forge-lane-command",
                 status: "approved"
             },
-            artifact: {
-                repoPath: worktree.worktreePath,
-                path: artifactPath,
-                verdictJson,
-                report,
-                producedBy: "forge-bridge",
-                status: "pass"
-            }
+            artifact: completionArtifacts[0],
+            artifacts: completionArtifacts
         };
     }
-    async runQa(dispatch, emit) {
-        await emit({
+    async runQa(context) {
+        const { dispatch, worktree } = context;
+        await context.emit({
             role: "worker",
             kind: "message",
-            content: `Running ${dispatch.execution.provider} QA checks through forge-bridge.`,
-            eventType: "qa_analysis"
+            content: `Planning ${dispatch.execution.provider} QA checks through forge-bridge.`,
+            eventType: "qa_plan"
         });
-        await emit({
-            role: "assistant",
-            kind: "message",
-            content: "All checks passed. forge-bridge QA completed.",
-            eventType: "qa_complete"
+        const summary = "All checks passed. forge-bridge QA completed.";
+        const qaArtifact = await writeQaArtifacts({
+            worktreePath: worktree.worktreePath,
+            workItemId: dispatch.workItem.id,
+            acceptanceCriteria: dispatch.workItem.acceptanceCriteria,
+            producedBy: "forge-bridge",
+            provider: dispatch.execution.provider,
+            model: dispatch.execution.model,
+            command: "forge-bridge deterministic QA",
+            summary
         });
+        await emitQaArtifactRecorded(context.emit, worktree.worktreePath, qaArtifact);
+        await emitQaStructuredEvents(context.emit, worktree.worktreePath, dispatch.workItem.id, qaArtifact);
+        await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
         return {
-            summary: "forge-bridge QA passed."
+            summary: "forge-bridge QA passed.",
+            artifact: qaArtifact,
+            artifacts: [qaArtifact]
         };
     }
     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(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
         await context.emit({
             role: "assistant",
             kind: "message",
@@ -318,12 +391,483 @@ export class DeterministicProviderCliService {
         };
     }
 }
+function phaseCompleteEventType(phase) {
+    return phase === "implementation" ? "implementation_complete" : `${phase}_complete`;
+}
+function deterministicCompletionPayload(phase, dispatch, changesetBody) {
+    const changesetHash = sha256(changesetBody);
+    const criterion = dispatch.workItem.acceptanceCriteria || "Deterministic bridge changeset exists";
+    if (phase === "implementation") {
+        return {
+            status: "pass",
+            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,
+                    evidence: `FORGE_PHASE5_CHANGESET.md was committed with content hash ${changesetHash}.`,
+                    status: "satisfied"
+                }
+            ],
+            known_gaps: [],
+            next_phase_context: "Review FORGE_PHASE5_CHANGESET.md and the bridge commit before validation."
+        };
+    }
+    if (phase === "self_review") {
+        return {
+            status: "pass",
+            summary: "forge-bridge fake worker completed deterministic self-review.",
+            reviewed_diff: true,
+            findings: [],
+            security_review: {
+                status: "pass",
+                notes: "No secret handling, auth, or destructive behavior changes were introduced by the deterministic changeset."
+            },
+            edge_case_review: {
+                status: "pass",
+                notes: "The deterministic fake-worker changeset is intentionally narrow and repeatable."
+            },
+            design_review: {
+                status: "not_applicable",
+                screenshots: [],
+                notes: "No UI changes."
+            },
+            deterministic_comparison: {
+                status: "pass",
+                command_or_tool: "git diff --stat HEAD~1..HEAD",
+                notes: `Reviewed deterministic changeset with content hash ${changesetHash}.`
+            },
+            fixes_applied: [],
+            remaining_risks: []
+        };
+    }
+    return {
+        status: "pass",
+        summary: "forge-bridge fake worker completed deterministic validation.",
+        commands: [
+            {
+                command: "git status --short && git diff --check",
+                exit_code: 0,
+                status: "pass",
+                summary: "Deterministic validation command completed for the fake-worker changeset."
+            }
+        ],
+        acceptance_criteria: [
+            {
+                criterion,
+                evidence: `FORGE_PHASE5_CHANGESET.md exists with content hash ${changesetHash}.`,
+                status: "satisfied"
+            }
+        ],
+        build_status: "pass",
+        test_status: "pass",
+        lint_status: "not_applicable",
+        design_status: "not_applicable",
+        drift_checks: [
+            {
+                command_or_tool: "git diff --check",
+                status: "pass",
+                summary: "No deterministic drift or whitespace errors were reported for the fake-worker changeset."
+            }
+        ],
+        ready_for_dev_test: true
+    };
+}
+const qaArtifactFileNames = {
+    plan: "qa.plan.json",
+    evidence: "qa.evidence.json",
+    findings: "qa.findings.json",
+    verdict: "qa.verdict.json",
+    report: "qa.report.md"
+};
+async function writeQaArtifacts(request) {
+    const artifactRoot = artifactRootFor(request.worktreePath, request.workItemId);
+    await fs.mkdir(artifactRoot, { recursive: true });
+    const criterion = request.acceptanceCriteria.trim() || "Forge QA evidence exists";
+    const relativeEvidencePath = qaArtifactRelativePath(request.workItemId, qaArtifactFileNames.evidence);
+    const relativeFindingsPath = qaArtifactRelativePath(request.workItemId, qaArtifactFileNames.findings);
+    const relativeReportPath = qaArtifactRelativePath(request.workItemId, qaArtifactFileNames.report);
+    const planJson = jsonText({
+        schema_version: 1,
+        phase: "qa",
+        checklist: [
+            "Review the validated work item against acceptance criteria.",
+            "Run relevant provider QA verification.",
+            "Confirm no in-scope QA findings remain."
+        ],
+        acceptance_criteria: [criterion]
+    });
+    const evidenceJson = jsonText({
+        schema_version: 1,
+        phase: "qa",
+        commands: [
+            {
+                command: request.command,
+                exit_code: 0,
+                status: "pass",
+                summary: `${request.provider} QA completed successfully.`
+            }
+        ],
+        browser_checks: [],
+        notes: request.summary
+    });
+    const findingsJson = jsonText({
+        schema_version: 1,
+        phase: "qa",
+        findings: [],
+        candidate_bugs: []
+    });
+    const verdictJson = jsonText({
+        schema_version: 1,
+        phase: "qa",
+        status: "pass",
+        summary: request.summary,
+        tested_acceptance_criteria: [criterion],
+        finding_ids: [],
+        candidate_bug_ids: [],
+        blocker_reason: null,
+        evidence_path: relativeEvidencePath,
+        findings_path: relativeFindingsPath,
+        report_path: relativeReportPath
+    });
+    const report = `# QA report\n\n${request.summary}\n\n- Provider: ${singleLine(request.provider)}\n- Model: ${singleLine(request.model)}\n- Command: ${singleLine(request.command)}\n`;
+    await fs.writeFile(path.join(artifactRoot, qaArtifactFileNames.plan), planJson, "utf8");
+    await fs.writeFile(path.join(artifactRoot, qaArtifactFileNames.evidence), evidenceJson, "utf8");
+    await fs.writeFile(path.join(artifactRoot, qaArtifactFileNames.findings), findingsJson, "utf8");
+    const verdictPath = path.join(artifactRoot, qaArtifactFileNames.verdict);
+    await fs.writeFile(verdictPath, verdictJson, "utf8");
+    await fs.writeFile(path.join(artifactRoot, qaArtifactFileNames.report), report, "utf8");
+    return {
+        repoPath: request.worktreePath,
+        path: verdictPath,
+        verdictJson,
+        report,
+        producedBy: request.producedBy,
+        status: "pass",
+        phase: "qa"
+    };
+}
+async function emitQaArtifactRecorded(emit, worktreePath, artifact) {
+    const relativePath = path.relative(worktreePath, artifact.path) || path.basename(artifact.path);
+    await emit({
+        role: "tool",
+        kind: "tool_result",
+        content: `Forge QA artifact recorded ${relativePath} (${artifact.status}).`,
+        eventType: "qa_artifact_recorded"
+    });
+    await emit({
+        role: "hook",
+        kind: "checkpoint",
+        content: `phase_gate: qa artifact accepted with status ${artifact.status}.`,
+        eventType: "phase_gate"
+    });
+}
+async function readQaCompletionArtifactBundle(worktreePath, workItemId) {
+    const artifact = await readCompletionArtifact(worktreePath, workItemId, "qa");
+    if (!artifact || !await hasCompleteQaArtifactBundle(worktreePath, workItemId)) {
+        return null;
+    }
+    return artifact;
+}
+async function hasCompleteQaArtifactBundle(worktreePath, workItemId) {
+    const artifactRoot = artifactRootFor(worktreePath, workItemId);
+    for (const fileName of Object.values(qaArtifactFileNames)) {
+        try {
+            const stat = await fs.stat(path.join(artifactRoot, fileName));
+            if (!stat.isFile()) {
+                return false;
+            }
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    return true;
+}
+async function emitQaStructuredEvents(emit, worktreePath, workItemId, artifact) {
+    const artifactRoot = artifactRootFor(worktreePath, workItemId);
+    const plan = await readJsonObjectFile(path.join(artifactRoot, qaArtifactFileNames.plan));
+    const evidence = await readJsonObjectFile(path.join(artifactRoot, qaArtifactFileNames.evidence));
+    const findings = await readJsonObjectFile(path.join(artifactRoot, qaArtifactFileNames.findings));
+    const verdict = parseJsonLine(artifact.verdictJson) ?? {};
+    const status = stringField(verdict, "status") ?? artifact.status ?? "unknown";
+    const checklist = stringArrayField(plan, "checklist");
+    await emit({
+        role: "worker",
+        kind: "message",
+        content: checklist.length > 0
+            ? `QA plan: ${checklist.join("; ")}`
+            : "QA plan recorded.",
+        eventType: "qa_plan"
+    });
+    for (const browserCheck of arrayField(evidence, "browser_checks")) {
+        await emit({
+            role: "worker",
+            kind: "checkpoint",
+            content: `QA browser check: ${summarizeQaObject(browserCheck)}`,
+            eventType: "qa_browser_check"
+        });
+    }
+    for (const finding of [...arrayField(findings, "findings"), ...arrayField(findings, "candidate_bugs")]) {
+        await emit({
+            role: "worker",
+            kind: "checkpoint",
+            content: `QA finding: ${summarizeQaObject(finding)}`,
+            eventType: "qa_finding"
+        });
+    }
+    await emit({
+        role: "assistant",
+        kind: "message",
+        content: status === "blocked"
+            ? `QA blocked: ${stringField(verdict, "summary") ?? "No summary provided."}`
+            : `QA completed with status ${status}: ${stringField(verdict, "summary") ?? "No summary provided."}`,
+        eventType: status === "blocked" ? "qa_blocked" : "qa_complete"
+    });
+}
+class LiveQaArtifactEmitter {
+    worktreePath;
+    workItemId;
+    emit;
+    emitted = false;
+    timer = null;
+    pending = Promise.resolve();
+    constructor(worktreePath, workItemId, emit) {
+        this.worktreePath = worktreePath;
+        this.workItemId = workItemId;
+        this.emit = emit;
+    }
+    start() {
+        void this.pollQueued();
+        this.timer = setInterval(() => {
+            void this.pollQueued();
+        }, 250);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.pollQueued();
+    }
+    hasEmitted() {
+        return this.emitted;
+    }
+    pollQueued() {
+        this.pending = this.pending
+            .then(() => this.poll())
+            .catch(() => undefined);
+        return this.pending;
+    }
+    async poll() {
+        if (this.emitted) {
+            return;
+        }
+        const artifact = await readQaCompletionArtifactBundle(this.worktreePath, this.workItemId);
+        if (!artifact) {
+            return;
+        }
+        this.emitted = true;
+        await emitQaArtifactRecorded(this.emit, this.worktreePath, artifact);
+        await emitQaStructuredEvents(this.emit, this.worktreePath, this.workItemId, artifact);
+    }
+}
+async function readJsonObjectFile(filePath) {
+    const content = await fs.readFile(filePath, "utf8").catch(() => "");
+    return parseJsonLine(content) ?? {};
+}
+function arrayField(source, key) {
+    const value = source[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry));
+}
+function stringArrayField(source, key) {
+    const value = source[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function summarizeQaObject(source) {
+    return clip(stringField(source, "title")
+        ?? stringField(source, "summary")
+        ?? stringField(source, "id")
+        ?? JSON.stringify(source), 500);
+}
+function qaArtifactRelativePath(workItemId, fileName) {
+    return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
+}
+function jsonText(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+async function emitCompletionArtifactRecorded(emit, worktreePath, artifact) {
+    const relativePath = path.relative(worktreePath, artifact.path) || path.basename(artifact.path);
+    await emit({
+        role: "tool",
+        kind: "tool_result",
+        content: `Forge completion tool recorded ${artifact.phase ?? "unknown"} artifact ${relativePath} (${artifact.status}).`,
+        eventType: "completion_tool_artifact_recorded"
+    });
+}
+async function emitPhaseCompletionEvent(emit, artifact) {
+    const phase = completionPhaseFromArtifact(artifact);
+    await emit({
+        role: "assistant",
+        kind: "message",
+        content: `${phase.replace(/_/g, " ")} completion artifact recorded with status ${artifact.status}.`,
+        eventType: phaseCompleteEventType(phase)
+    });
+}
+async function emitPhaseGateEvents(emit, artifact) {
+    const phase = completionPhaseFromArtifact(artifact);
+    const status = (artifact.status ?? "").trim().toLowerCase() || "unknown";
+    await emit({
+        role: "hook",
+        kind: "checkpoint",
+        content: `phase_gate: ${phase} artifact accepted with status ${status}.`,
+        eventType: "phase_gate"
+    });
+    if (status !== "pass") {
+        return;
+    }
+    const progression = phase === "implementation"
+        ? "phase_progression: implementation -> self_review"
+        : phase === "self_review"
+            ? "phase_progression: self_review -> validation"
+            : "phase_progression: validation -> QA ready";
+    await emit({
+        role: "hook",
+        kind: "checkpoint",
+        content: progression,
+        eventType: "phase_gate"
+    });
+}
+function completionPhaseFromArtifact(artifact) {
+    const phase = artifact.phase?.trim();
+    return phase === "self_review" || phase === "validation" || phase === "implementation" || phase === "qa"
+        ? phase
+        : "implementation";
+}
+class LiveCompletionArtifactEmitter {
+    worktreePath;
+    workItemId;
+    emit;
+    phases;
+    emitted = new Set();
+    timer = null;
+    pending = Promise.resolve();
+    constructor(worktreePath, workItemId, phase, developCycle, emit) {
+        this.worktreePath = worktreePath;
+        this.workItemId = workItemId;
+        this.emit = emit;
+        this.phases = developCycle
+            ? developCyclePhaseOrder.slice(developCyclePhaseOrder.indexOf(phase))
+            : [phase];
+    }
+    start() {
+        void this.pollQueued();
+        this.timer = setInterval(() => {
+            void this.pollQueued();
+        }, 250);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.pollQueued();
+    }
+    hasEmitted(phase) {
+        return this.emitted.has(phase);
+    }
+    pollQueued() {
+        this.pending = this.pending
+            .then(() => this.poll())
+            .catch(() => undefined);
+        return this.pending;
+    }
+    async poll() {
+        for (const phase of this.phases) {
+            if (this.emitted.has(phase)) {
+                continue;
+            }
+            const artifact = await readCompletionArtifact(this.worktreePath, this.workItemId, phase);
+            if (!artifact) {
+                return;
+            }
+            this.emitted.add(phase);
+            await emitCompletionArtifactRecorded(this.emit, this.worktreePath, artifact);
+            await emitPhaseCompletionEvent(this.emit, artifact);
+            await emitPhaseGateEvents(this.emit, artifact);
+            if ((artifact.status ?? "").trim().toLowerCase() !== "pass") {
+                return;
+            }
+        }
+    }
+}
+async function readCompletionArtifactsForRun(worktreePath, workItemId, phase, developCycle) {
+    if (!developCycle) {
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, phase);
+        if (!artifact) {
+            throw new Error(`Provider CLI completed but did not call the Forge ${phase} completion tool.`);
+        }
+        return [artifact];
+    }
+    const artifacts = [];
+    for (const expectedPhase of ["implementation", "self_review", "validation"]) {
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, expectedPhase);
+        if (!artifact) {
+            if (artifacts.length === 0) {
+                throw new Error("Provider CLI completed but did not call the Forge implementation completion tool.");
+            }
+            const previous = artifacts[artifacts.length - 1];
+            if ((previous.status ?? "").trim().toLowerCase() === "pass") {
+                throw new Error(`Provider CLI completed after ${previous.phase} passed but did not call the Forge ${expectedPhase} completion tool.`);
+            }
+            return artifacts;
+        }
+        artifacts.push(artifact);
+        if ((artifact.status ?? "").trim().toLowerCase() !== "pass") {
+            return artifacts;
+        }
+    }
+    return artifacts;
+}
+function providerRedactionEnv(dispatch) {
+    const env = completionRedactionEnv(exactRedactionSecrets(dispatch));
+    return Object.keys(env).length > 0 ? env : undefined;
+}
+function exactRedactionSecrets(dispatch) {
+    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+}
+async function emitProviderUsageEvent(emit, dispatch, outputState) {
+    const usage = outputState.usage;
+    if (hasUsage(usage)) {
+        await emit(buildProviderUsageEvent(dispatch, usage));
+    }
+}
+function estimatedDeterministicUsage() {
+    return addUsage(emptyUsage("estimated"), {
+        inputTokens: 1000,
+        outputTokens: 400,
+        source: "estimated"
+    });
+}
 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,
+                env: request.env ? { ...process.env, ...request.env } : undefined,
                 stdio: ["ignore", "pipe", "pipe"],
                 windowsHide: true
             });
@@ -392,6 +936,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 };
 }
@@ -399,10 +947,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/));
@@ -411,18 +955,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())
@@ -519,10 +1051,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 };
     }
@@ -545,20 +1079,54 @@ ${completionPromptForPhase(phase)}
 
 Finish with a concise summary of changed files and verification after calling the completion tool.`;
 }
+function buildDevelopCyclePrompt(dispatch, phase = completionPhaseFromDispatch(dispatch)) {
+    return `You are Forge's develop-cycle runner running locally in a prepared git worktree.
+
+Read .forge/work-items/${dispatch.workItem.id}/spec.md, implement the work item, self-review the diff, then validate it in this same provider session.
+Start in the ${phase.replace(/_/g, " ")} phase. Do not stop after implementation if it passes; continue through self-review and validation using the next instruction returned by each completion tool.
+Use the repository's existing conventions. Run relevant tests when practical.
+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.
+
+${completionPromptForDevelopCycle(phase)}
+
+Finish with a concise summary of changed files and verification after the validation completion tool has accepted the work, or after the current phase tool records a non-pass blocker.`;
+}
 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 "Run the validation commands and deterministic drift checks needed to prove the work is ready for QA.";
     }
     return "Implement the work item and keep the change focused.";
 }
 function buildQaPrompt(dispatch) {
-    return `You are Forge's QA lane running locally.
+    return `You are Forge's QA lane running locally in a prepared git worktree.
+
+Work item: ${dispatch.workItem.id}
+Title: ${dispatch.workItem.title}
+Description:
+${dispatch.workItem.description || "Not provided."}
+
+Acceptance criteria:
+${dispatch.workItem.acceptanceCriteria || "Not specified."}
+
+Repro steps / scenario:
+${dispatch.workItem.reproSteps || "Not provided."}
+
+System info / environment notes:
+${dispatch.workItem.systemInfo || "Not provided."}
+
+Inspect the validated implementation and Forge artifacts under .forge/work-items/${dispatch.workItem.id}/artifacts/ when present, especially implementation, self-review, and validation evidence.
+QA is read-mostly: inspect code, run commands, and exercise browser/app flows when available, but do not edit product source or tests.
+Record concrete evidence. For UI/browser work, include browser_checks with URLs, actions, observed results, screenshots/traces when available, and console/network notes.
+Report in-scope defects as actionable findings with repro steps, expected/actual behavior, evidence, likely area, required fix, and required regression.
+Out-of-scope or follow-up issues belong in candidate_bugs instead of blocking the current item.
 
-Review the implementation for work item ${dispatch.workItem.id}: ${dispatch.workItem.title}
-Run relevant verification when practical and finish with a concise QA verdict.`;
+${completionPromptForPhase("qa")}
+
+Finish with a concise summary only after forge.complete_qa accepts the QA bundle.`;
 }
 function buildConflictResolvePrompt(dispatch, branchName) {
     const targetBranch = dispatch.cycleRun.requestedBase || dispatch.repo.defaultBranch || "main";
@@ -611,27 +1179,227 @@ 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;
+    accumulatedUsage = null;
+    get sessionLabel() {
+        return this.sessionId ? `session ${this.sessionId}` : null;
+    }
+    get usage() {
+        return this.accumulatedUsage;
+    }
     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"
+                };
+            }
         }
-        catch {
+        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);
+            }
+            this.accumulateUsage(event);
+        }
+        if (type === "error" || (type === "result" && event.is_error === true)) {
+            return {
+                role: "runner",
+                kind: "error",
+                content: clip(line.trim(), 1000),
+                eventType: "provider_cli_error"
+            };
+        }
+        return null;
+    }
+    accumulateUsage(event) {
+        const usage = objectField(event, "usage");
+        const durationMs = readUsageNumber(event, "duration_ms") || readUsageNumber(event, "duration_api_ms");
+        if (Object.keys(usage).length === 0 && durationMs === 0) {
+            return;
+        }
+        this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
+            inputTokens: readUsageNumber(usage, "inputTokens"),
+            outputTokens: readUsageNumber(usage, "outputTokens"),
+            cacheReadTokens: readUsageNumber(usage, "cacheReadTokens"),
+            cacheCreationTokens: readUsageNumber(usage, "cacheWriteTokens"),
+            providerDurationMs: durationMs > 0 ? durationMs : null,
+            source: "provider_reported"
+        });
+    }
+}
+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;
+    accumulatedUsage = null;
+    get sessionLabel() {
+        return this.threadId ? `thread ${this.threadId}` : null;
+    }
+    get usage() {
+        return this.accumulatedUsage;
+    }
+    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) {
@@ -645,6 +1413,7 @@ class CodexJsonState {
             }
         }
         if (type === "turn.completed") {
+            this.accumulateUsage(event);
             return {
                 role: "runner",
                 kind: "checkpoint",
@@ -656,7 +1425,7 @@ class CodexJsonState {
             return {
                 role: "runner",
                 kind: "error",
-                content: clip(trimmed, 1000),
+                content: clip(line.trim(), 1000),
                 eventType: "provider_cli_error"
             };
         }
@@ -690,6 +1459,19 @@ class CodexJsonState {
         }
         return null;
     }
+    accumulateUsage(event) {
+        const usage = objectField(event, "usage");
+        if (Object.keys(usage).length === 0) {
+            return;
+        }
+        this.accumulatedUsage = addUsage(this.accumulatedUsage ?? emptyUsage("provider_reported"), {
+            inputTokens: readUsageNumber(usage, "input_tokens"),
+            outputTokens: readUsageNumber(usage, "output_tokens"),
+            cacheReadTokens: readUsageNumber(usage, "cached_input_tokens"),
+            reasoningOutputTokens: readUsageNumber(usage, "reasoning_output_tokens"),
+            source: "provider_reported"
+        });
+    }
 }
 function objectField(source, key) {
     const value = source[key];
@@ -701,3 +1483,6 @@ function stringField(source, key) {
     const value = source[key];
     return typeof value === "string" && value.trim().length > 0 ? value : null;
 }
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}