@loucompanion/forge-bridge 0.1.3-dev.b6be5e7f9668 → 0.1.3-dev.bca7d0ccee53

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

@@ -1,148 +1,239 @@
-import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
-import { execFile, spawn } from "node:child_process";
-import readline from "node:readline";
-import { promisify } from "node:util";
+import { RepositoryCoordinatorLock } from "../../sandbox/repository-lock.js";
 import { GitClient } from "../../shared/git/git.js";
-import { resolveCursorAgentDirectLaunch } from "../../shared/cursor-agent/cursor-agent.launch.js";
-import { ensureNoSymbolicLinkPathSegments, isPathUnderRoot, sha256File } from "../qa-sidecar-validation.js";
 import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
-import { codexMcpConfigArgs, completionPhaseFromDispatch, completionPromptForDebugCycle, completionPromptForDevelopCycle, completionPromptForDraftCycle, completionPromptForPhase, completionPromptForQaCycle, completionRedactionEnv, expectedCompletionToolName, expectedDebugCompletionToolName, expectedQaCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, usesDebugCycleCompletion, usesDevelopCycleCompletion, writeCompletionArtifact, artifactRootFor, artifactRootForOwner, debugCompletionPhaseOrder, draftCompletionGateOrder, qaCompletionGateOrder } 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"];
-const allowedProviderParentEnvNames = [
-    "PATH",
-    "HOME",
-    "USERPROFILE",
-    "TMPDIR",
-    "TEMP",
-    "TMP",
-    "LANG"
-];
-const windowsAllowedProviderParentEnvNames = [
-    "SystemRoot",
-    "SystemDrive",
-    "ComSpec",
-    "PATHEXT",
-    "APPDATA",
-    "LOCALAPPDATA",
-    "USERNAME",
-    "USERDOMAIN",
-    "HOMEDRIVE",
-    "HOMEPATH",
-    "ProgramData",
-    "ProgramFiles",
-    "ProgramFiles(x86)",
-    "ProgramW6432",
-    "DOTNET_ROOT",
-    "DOTNET_ROOT(x86)",
-    "DOTNET_CLI_HOME",
-    "NUGET_PACKAGES",
-    "NUGET_HTTP_CACHE_PATH"
-];
-export function buildProviderChildEnvironment(requestEnv, options = {}) {
-    const parentEnv = options.parentEnv ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const env = {};
-    for (const [key, value] of Object.entries(parentEnv)) {
-        if (typeof value === "string" && isAllowedProviderParentEnv(key, platform)) {
-            env[key] = value;
+import { defaultWorktreeCoordinatorStateRoot } from "../../worktree/worktree-paths.js";
+import { completionPhaseFromDispatch, prepareCompletionToolRuntime, readCompletionArtifact, usesDebugCycleCompletion, usesDevelopCycleCompletion } from "../phase-completion.js";
+import { cleanupCompletionTools, commitWorktreeChanges, completionPhaseFromArtifact, emitArchitectStructuredEvents, emitCompletionArtifactRecorded, emitDecomposeGateArtifacts, emitDraftGateArtifacts, emitPhaseCompletionEvent, emitPhaseGateEvents, emitQaArtifactRecorded, emitQaStructuredEvents, enforceQaBrowserLaunchTargetGate, LiveArchitectArtifactEmitter, LiveCompletionArtifactEmitter, LiveQaArtifactEmitter, readCompletionArtifactsForRun, readQaCompletionArtifactBundle, summarizeStderr, waitForCompletionArtifact } from "./provider-cli.artifacts.js";
+import { DeterministicProviderCliService } from "./provider-cli.deterministic.js";
+import { buildArchitectPrompt, buildConflictResolvePrompt, buildDebugCyclePrompt, buildDevelopCyclePrompt, buildDraftPrompt, buildDraftSpec, buildImplementationPrompt, buildProviderCliPrompt, buildProviderCliCommand, durableDraftInput, buildPullRequestCheckRepairPrompt, buildPullRequestCommentsPrompt, buildQaPrompt, formatProviderCliCommandForCheckpoint, isDecomposeDraftDispatch, isPullRequestCheckRepairDispatch, isPullRequestCommentsDispatch } from "./provider-cli.prompts.js";
+import { StreamingProviderProcessRunner } from "./provider-cli.process.js";
+import { emitProviderUsageEvent, providerProcessEnv } from "./provider-cli.runtime.js";
+import { clip, createProviderOutputState, parseJsonLine } from "./provider-output-state.js";
+import { writeCiRepairReadinessManifest } from "./ci-repair-readiness.js";
+export { DeterministicProviderCliService } from "./provider-cli.deterministic.js";
+export { buildProviderCliCommand, codexSandboxModeForPlatform, formatProviderCliCommand, formatProviderCliCommandForCheckpoint } from "./provider-cli.prompts.js";
+export { buildProviderChildEnvironment, chooseWindowsCommandCandidate, resolveCodexNpmDirectLaunch, resolvePackageManagerDirectLaunch, resolveWindowsCommandFromPath, StreamingProviderProcessRunner } from "./provider-cli.process.js";
+export { buildWindowsLaunchCommand } from "../../shared/process/windows-launch.js";
+async function pushWorktreeBranch(git, worktreePath, branchName, repoPath, coordinator, signal, emit) {
+    await coordinator.withLock(repoPath, async () => {
+        try {
+            await git.run(worktreePath, ["push", "origin", `HEAD:${branchName}`]);
+            return;
         }
-    }
-    if (requestEnv) {
-        for (const [key, value] of Object.entries(requestEnv)) {
-            const trimmedKey = key.trim();
-            if (trimmedKey.length > 0) {
-                env[trimmedKey] = value;
+        catch (err) {
+            if (!isNonFastForwardPushError(err)) {
+                throw err;
+            }
+            await emit?.({
+                role: "runner",
+                kind: "checkpoint",
+                content: `Remote branch ${branchName} moved before push; fetching latest and rebasing local changes.`,
+                eventType: "worktree_branch_push_rebase"
+            });
+            try {
+                await git.run(worktreePath, ["fetch", "origin", remoteTrackingRefspec(branchName)]);
+                await git.run(worktreePath, ["rebase", `refs/remotes/origin/${branchName}`]);
+                await git.run(worktreePath, ["push", "origin", `HEAD:${branchName}`]);
+            }
+            catch (retryErr) {
+                throw new Error(`worktree_branch_integration_conflict: git push origin HEAD:${branchName} was rejected because the remote branch moved, and automatic fetch/rebase failed: ${errorMessage(retryErr)}`, { cause: retryErr });
             }
         }
-    }
-    if (platform === "win32") {
-        normalizeWindowsDotNetEnvironment(env, parentEnv, options.homeDir ?? os.homedir());
-    }
-    return env;
+    }, signal);
+}
+function providerOwnsBranchPublication(context) {
+    return context.dispatch.sandbox?.executionMode !== "docker";
+}
+function remoteTrackingRefspec(branchName) {
+    return `refs/heads/${branchName}:refs/remotes/origin/${branchName}`;
+}
+function isNonFastForwardPushError(err) {
+    const message = errorMessage(err).toLowerCase();
+    return message.includes("non-fast-forward")
+        || message.includes("fetch first")
+        || message.includes("tip of your current branch is behind")
+        || message.includes("updates were rejected because the tip of your current branch is behind")
+        || message.includes("stale info");
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
 }
-function isAllowedProviderParentEnv(key, platform = process.platform) {
-    return isAllowedProviderParentEnvName(key, allowedProviderParentEnvNames)
-        || key.toUpperCase().startsWith("LC_")
-        || (platform === "win32" && isAllowedProviderParentEnvName(key, windowsAllowedProviderParentEnvNames));
+const defaultProviderToolHeartbeatIntervalMs = 60_000;
+const defaultManagedVerificationProgressIntervalMs = 30_000;
+function compareManagedVerificationSnapshots(left, right) {
+    const leftOrder = managedVerificationStartedAt(left.startedAt) ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = managedVerificationStartedAt(right.startedAt) ?? Number.MAX_SAFE_INTEGER;
+    return leftOrder - rightOrder || left.commandId.localeCompare(right.commandId);
 }
-function isAllowedProviderParentEnvName(key, allowedNames) {
-    return allowedNames.some((allowed) => allowed.toLowerCase() === key.toLowerCase());
+function managedVerificationStartedAt(value) {
+    const parsed = Date.parse(value ?? "");
+    return Number.isFinite(parsed) ? parsed : null;
 }
-function normalizeWindowsDotNetEnvironment(env, parentEnv, homeDir) {
-    const systemRoot = readEnvironmentValue(env, "SystemRoot") ?? readEnvironmentValue(parentEnv, "SystemRoot") ?? "C:\\Windows";
-    const systemDrive = path.win32.parse(systemRoot).root.replace(/\\$/, "") || "C:";
-    setEnvironmentValueIfMissing(env, "SystemRoot", systemRoot);
-    setEnvironmentValueIfMissing(env, "SystemDrive", readEnvironmentValue(parentEnv, "SystemDrive") ?? systemDrive);
-    setEnvironmentValueIfMissing(env, "ComSpec", readEnvironmentValue(parentEnv, "ComSpec") ?? path.win32.join(systemRoot, "System32", "cmd.exe"));
-    setEnvironmentValueIfMissing(env, "PATHEXT", readEnvironmentValue(parentEnv, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL");
-    const userProfile = resolveWindowsUserProfile(env, parentEnv, homeDir);
-    if (userProfile) {
-        setEnvironmentValueIfMissing(env, "USERPROFILE", userProfile);
-        setEnvironmentValueIfMissing(env, "HOME", userProfile);
-        setEnvironmentValueIfMissing(env, "DOTNET_CLI_HOME", userProfile);
-        setEnvironmentValueIfMissing(env, "NUGET_PACKAGES", path.win32.join(userProfile, ".nuget", "packages"));
-        const parsed = path.win32.parse(userProfile);
-        if (parsed.root) {
-            setEnvironmentValueIfMissing(env, "HOMEDRIVE", parsed.root.replace(/\\$/, ""));
-            setEnvironmentValueIfMissing(env, "HOMEPATH", userProfile.slice(parsed.root.length - (parsed.root.endsWith("\\") ? 1 : 0)) || "\\");
+export class ManagedVerificationProgressEmitter {
+    logDirectory;
+    emit;
+    intervalMs;
+    timer = null;
+    observedStatuses = new Map();
+    completedCommands = new Set();
+    constructor(logDirectory, emit, intervalMs = defaultManagedVerificationProgressIntervalMs) {
+        this.logDirectory = logDirectory;
+        this.emit = emit;
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        if (!this.logDirectory?.trim() || this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.scan().catch(() => undefined);
+        }, Math.max(1, this.intervalMs));
+        void this.scan().catch(() => undefined);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
         }
+        await this.scan().catch(() => undefined);
     }
-    const appData = readEnvironmentValue(env, "APPDATA")
-        ?? readEnvironmentValue(parentEnv, "APPDATA")
-        ?? (userProfile ? path.win32.join(userProfile, "AppData", "Roaming") : undefined);
-    const localAppData = readEnvironmentValue(env, "LOCALAPPDATA")
-        ?? readEnvironmentValue(parentEnv, "LOCALAPPDATA")
-        ?? (userProfile ? path.win32.join(userProfile, "AppData", "Local") : undefined);
-    if (appData) {
-        setEnvironmentValueIfMissing(env, "APPDATA", appData);
+    async scan() {
+        if (!this.logDirectory?.trim())
+            return;
+        const directory = path.join(this.logDirectory, "managed-commands");
+        const names = await fs.readdir(directory).catch(() => []);
+        const snapshots = await Promise.all(names
+            .filter(name => name.endsWith(".receipt.json"))
+            .map(async (name) => parseManagedVerificationSnapshot(path.join(directory, name))));
+        const current = snapshots
+            .filter((entry) => entry !== null)
+            .sort(compareManagedVerificationSnapshots);
+        for (const snapshot of current) {
+            await this.emitTransition(snapshot);
+        }
+    }
+    async emitTransition(current) {
+        const terminal = ["pass", "fail", "timed_out", "timeout_termination_failed", "runner_error"].includes(current.status);
+        if (terminal && this.completedCommands.has(current.commandId))
+            return;
+        const previousStatus = this.observedStatuses.get(current.commandId);
+        if (previousStatus === current.status)
+            return;
+        this.observedStatuses.set(current.commandId, current.status);
+        if (terminal)
+            this.completedCommands.add(current.commandId);
+        // Starting and running are one externally meaningful state. The receipt is
+        // still refreshed on disk for UI telemetry, but repeated output/elapsed
+        // changes must not inflate the provider transcript or session history.
+        if (!terminal && previousStatus === "starting" && current.status === "running")
+            return;
+        const startedAt = managedVerificationStartedAt(current.startedAt);
+        const elapsedMs = startedAt !== null
+            ? Math.max(current.elapsedMs ?? 0, Date.now() - startedAt)
+            : current.elapsedMs;
+        const elapsed = elapsedMs === null ? "an unknown duration" : formatElapsed(elapsedMs);
+        const outputTail = current.lastOutputStream === "stderr"
+            ? current.stderrTail || current.stdoutTail
+            : current.stdoutTail || current.stderrTail;
+        const recovered = previousStatus === undefined && terminal;
+        await this.emit({
+            role: "runner",
+            kind: terminal && current.status !== "pass" ? "error" : "status",
+            content: terminal
+                ? `Managed verification ${current.status} after ${elapsed}${recovered ? " (recovered from its durable receipt)" : ""}${outputTail ? `: ${clip(outputTail, 600)}` : "."}`
+                : `QA started managed verification ${current.commandId}. Forge is supervising it; durable progress remains available in the UI while the provider continues independent work.`,
+            eventType: terminal ? "verification_completed" : "verification_waiting",
+            data: JSON.stringify({
+                command_id: current.commandId,
+                status: current.status,
+                elapsed_ms: elapsedMs,
+                output_revision: current.outputRevision,
+                last_output_at: current.lastOutputAt,
+                recovered,
+            }),
+        });
+    }
+}
+async function parseManagedVerificationSnapshot(receiptPath) {
+    try {
+        const receipt = JSON.parse(await fs.readFile(receiptPath, "utf8"));
+        const commandId = typeof receipt.command_id === "string" ? receipt.command_id : null;
+        const status = typeof receipt.status === "string" ? receipt.status : null;
+        if (!commandId || !status)
+            return null;
+        return {
+            commandId,
+            status,
+            elapsedMs: typeof receipt.elapsed_ms === "number" ? receipt.elapsed_ms : null,
+            startedAt: typeof receipt.started_at === "string" ? receipt.started_at : null,
+            outputRevision: typeof receipt.output_revision === "number" ? receipt.output_revision : null,
+            lastOutputAt: typeof receipt.last_output_at === "string" ? receipt.last_output_at : null,
+            lastOutputStream: receipt.last_output_stream === "stdout" || receipt.last_output_stream === "stderr"
+                ? receipt.last_output_stream
+                : null,
+            stdoutTail: tail(typeof receipt.stdout === "string" ? receipt.stdout : ""),
+            stderrTail: tail(typeof receipt.stderr === "string" ? receipt.stderr : ""),
+        };
     }
-    if (localAppData) {
-        setEnvironmentValueIfMissing(env, "LOCALAPPDATA", localAppData);
-        setEnvironmentValueIfMissing(env, "NUGET_HTTP_CACHE_PATH", path.win32.join(localAppData, "NuGet", "v3-cache"));
+    catch {
+        return null;
     }
-    setEnvironmentValueIfMissing(env, "DOTNET_NOLOGO", "1");
-    setEnvironmentValueIfMissing(env, "DOTNET_CLI_TELEMETRY_OPTOUT", "1");
-    setEnvironmentValueIfMissing(env, "DOTNET_SKIP_FIRST_TIME_EXPERIENCE", "1");
-    setEnvironmentValueIfMissing(env, "NUGET_XMLDOC_MODE", "skip");
 }
-function resolveWindowsUserProfile(env, parentEnv, homeDir) {
-    const existing = readEnvironmentValue(env, "USERPROFILE") ?? readEnvironmentValue(parentEnv, "USERPROFILE");
-    if (existing) {
-        return existing;
-    }
-    const home = readEnvironmentValue(env, "HOME") ?? readEnvironmentValue(parentEnv, "HOME");
-    if (home && path.win32.isAbsolute(home)) {
-        return home;
+function tail(value) {
+    return value.trim().split(/\r?\n/u).slice(-4).join("\n");
+}
+function formatElapsed(milliseconds) {
+    const seconds = Math.max(0, Math.round(milliseconds / 1000));
+    const minutes = Math.floor(seconds / 60);
+    return minutes > 0 ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
+}
+class ProviderToolActivityHeartbeat {
+    outputState;
+    emit;
+    intervalMs;
+    timer = null;
+    constructor(outputState, emit, intervalMs) {
+        this.outputState = outputState;
+        this.emit = emit;
+        this.intervalMs = intervalMs;
     }
-    const homeDrive = readEnvironmentValue(env, "HOMEDRIVE") ?? readEnvironmentValue(parentEnv, "HOMEDRIVE");
-    const homePath = readEnvironmentValue(env, "HOMEPATH") ?? readEnvironmentValue(parentEnv, "HOMEPATH");
-    if (homeDrive && homePath) {
-        return `${homeDrive}${homePath}`;
+    async consume(line) {
+        const events = this.outputState.consume(line);
+        this.sync();
+        for (const event of events) {
+            await this.emit(event);
+        }
     }
-    if (homeDir && path.win32.isAbsolute(homeDir)) {
-        return homeDir;
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
     }
-    const systemDrive = readEnvironmentValue(env, "SystemDrive") ?? readEnvironmentValue(parentEnv, "SystemDrive") ?? "C:";
-    const username = readEnvironmentValue(env, "USERNAME") ?? readEnvironmentValue(parentEnv, "USERNAME");
-    return username ? path.win32.join(systemDrive, "Users", username) : undefined;
-}
-function readEnvironmentValue(env, name) {
-    const entry = Object.entries(env).find(([key]) => key.toLowerCase() === name.toLowerCase());
-    const value = entry?.[1];
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
-function setEnvironmentValueIfMissing(env, name, value) {
-    if (readEnvironmentValue(env, name)) {
-        return;
+    sync() {
+        if (!this.outputState.hasActiveToolCall) {
+            this.stop();
+            return;
+        }
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            if (!this.outputState.hasActiveToolCall) {
+                this.stop();
+                return;
+            }
+            void this.emit({
+                role: "runner",
+                kind: "status",
+                content: "A supervised provider tool is still running.",
+                eventType: "provider_tool_heartbeat",
+            }).catch(() => undefined);
+        }, Math.max(1, this.intervalMs));
     }
-    env[name] = value;
 }
+const fakeWorkerModel = "server-local-fake-worker";
 export class RoutingProviderCliService {
     realProvider;
     deterministicProvider;
@@ -160,6 +251,11 @@ export class RoutingProviderCliService {
             ? await this.deterministicProvider.runArchitect(context)
             : await this.realProvider.runArchitect(context);
     }
+    async runCiRepair(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runCiRepair(context)
+            : await this.realProvider.runCiRepair(context);
+    }
     async runConflictResolve(context) {
         return isFakeWorkerModel(context.dispatch.execution.model)
             ? await this.deterministicProvider.runConflictResolve(context)
@@ -179,34 +275,38 @@ export class RoutingProviderCliService {
 export class ProcessBackedProviderCliService {
     processRunner;
     git;
-    constructor(processRunner = new StreamingProviderProcessRunner(), git = new GitClient()) {
+    providerToolHeartbeatIntervalMs;
+    publicationCoordinator;
+    constructor(processRunner = new StreamingProviderProcessRunner(), git = new GitClient(), providerToolHeartbeatIntervalMs = defaultProviderToolHeartbeatIntervalMs, publicationCoordinator = new RepositoryCoordinatorLock(defaultWorktreeCoordinatorStateRoot())) {
         this.processRunner = processRunner;
         this.git = git;
+        this.providerToolHeartbeatIntervalMs = providerToolHeartbeatIntervalMs;
+        this.publicationCoordinator = publicationCoordinator;
     }
     async runDraft(context) {
         const { dispatch } = context;
         if (!dispatch.draft) {
             throw new Error("Draft dispatch context is missing.");
         }
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "forge-bridge-draft-"));
-        const draftWorktree = {
-            repoPath: tempDir,
-            worktreePath: tempDir,
-            branchName: "draft",
-            baseBranch: dispatch.cycleRun.baseBranch || dispatch.repo.defaultBranch || "draft",
-            cleanupWorktrees: true
-        };
-        const metadataRoot = path.join(tempDir, ".forge", "work-items", dispatch.workItem.id);
+        const { worktree } = context;
+        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
         await fs.mkdir(metadataRoot, { recursive: true });
-        await fs.writeFile(path.join(metadataRoot, "draft-input.json"), JSON.stringify(dispatch.draft, null, 2) + "\n", "utf8");
+        await fs.writeFile(path.join(metadataRoot, "draft-input.json"), JSON.stringify(durableDraftInput(dispatch), null, 2) + "\n", "utf8");
         await fs.writeFile(path.join(metadataRoot, "spec.md"), buildDraftSpec(dispatch), "utf8");
+        const stagedAttachments = await stageDraftAttachments(dispatch, metadataRoot);
         const decomposeDraft = isDecomposeDraftDispatch(dispatch);
-        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree: draftWorktree, phase: decomposeDraft ? "decompose" : "draft" });
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: decomposeDraft ? "decompose" : "draft", runtimeEnvironment: context.runtimeEnvironment });
+        const draftPrompt = buildDraftPrompt(dispatch, { attachmentReferences: stagedAttachments.textReferences });
+        const providerPrompt = buildProviderCliPrompt(dispatch, draftPrompt, context.runtimeEnvironment);
+        const pipePromptToStdin = shouldPipePromptToStdin(dispatch.execution.provider, providerPrompt, usesManagedWindowsHost(dispatch));
         const command = buildProviderCliCommand(dispatch, {
-            worktreePath: tempDir,
-            prompt: buildDraftPrompt(dispatch),
+            worktreePath: worktree.worktreePath,
+            prompt: draftPrompt,
+            promptFromStdin: pipePromptToStdin,
             completionTools: completionTools ?? undefined,
-            skipGitRepoCheck: true
+            skipGitRepoCheck: false,
+            imagePaths: stagedAttachments.imagePaths,
+            runtimeEnvironment: context.runtimeEnvironment
         });
         const draftArtifactSlugs = dispatch.artifacts
             .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
@@ -220,8 +320,8 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI Draft: ${formatProviderCliCommand(command)}`,
-            eventType: "provider_cli_started"
+            content: `Starting provider CLI Draft: ${formatProviderCliCommandForCheckpoint(command)}`,
+            eventType: "provider_cli_starting"
         });
         await context.emit({
             role: "runner",
@@ -232,6 +332,7 @@ export class ProcessBackedProviderCliService {
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
+        const toolHeartbeat = new ProviderToolActivityHeartbeat(outputState, context.emit, this.providerToolHeartbeatIntervalMs);
         try {
             const providerCancellation = new AbortController();
             const abortProvider = () => providerCancellation.abort();
@@ -242,16 +343,23 @@ export class ProcessBackedProviderCliService {
                 context.signal?.addEventListener("abort", abortProvider, { once: true });
             }
             try {
-                const runPromise = this.processRunner.run({
+                const runPromise = (context.processRunner ?? this.processRunner).run({
                     command: command.command,
                     args: command.args,
-                    cwd: tempDir,
-                    env: providerProcessEnv(dispatch)
+                    cwd: worktree.worktreePath,
+                    env: providerProcessEnv(dispatch, context.runtimeEnvironment),
+                    stdin: pipePromptToStdin ? providerPrompt : undefined
                 }, {
+                    onStarted: async () => {
+                        await context.emit({
+                            role: "runner",
+                            kind: "checkpoint",
+                            content: "Provider CLI Draft is supervised and ready.",
+                            eventType: "provider_cli_started"
+                        });
+                    },
                     onStdoutLine: async (line) => {
-                        for (const event of outputState.consume(line)) {
-                            await context.emit(event);
-                        }
+                        await toolHeartbeat.consume(line);
                     }
                 }, providerCancellation.signal);
                 const artifactWaitCancellation = new AbortController();
@@ -262,7 +370,7 @@ export class ProcessBackedProviderCliService {
                 else {
                     context.signal?.addEventListener("abort", abortArtifactWait, { once: true });
                 }
-                const artifactWaitPromise = waitForCompletionArtifact(tempDir, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
+                const artifactWaitPromise = waitForCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
                 let result;
                 let earlyProposalArtifact = null;
                 try {
@@ -296,8 +404,8 @@ export class ProcessBackedProviderCliService {
                 });
                 await emitProviderUsageEvent(context.emit, dispatch, outputState);
                 if (decomposeDraft) {
-                    await emitDecomposeGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-                    const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "decompose");
+                    await emitDecomposeGateArtifacts(context.emit, worktree.worktreePath, dispatch.workItem.id);
+                    const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "decompose");
                     if (!proposalArtifact) {
                         throw new Error("Provider CLI Decompose completed but did not call forge.complete_decompose_proposal.");
                     }
@@ -319,8 +427,8 @@ export class ProcessBackedProviderCliService {
                         artifacts: [proposalArtifact]
                     };
                 }
-                await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
-                const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
+                await emitDraftGateArtifacts(context.emit, worktree.worktreePath, dispatch.workItem.id);
+                const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "draft");
                 if (!proposalArtifact) {
                     throw new Error("Provider CLI Draft completed but did not call forge.complete_draft_proposal.");
                 }
@@ -347,8 +455,8 @@ export class ProcessBackedProviderCliService {
             }
         }
         finally {
+            toolHeartbeat.stop();
             await cleanupCompletionTools(completionTools, context.emit);
-            await fs.rm(tempDir, { recursive: true, force: true });
         }
     }
     async runImplementation(context) {
@@ -366,21 +474,26 @@ export class ProcessBackedProviderCliService {
         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 completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase, runtimeEnvironment: context.runtimeEnvironment });
+        const implementationPrompt = debugCycle
+            ? buildDebugCyclePrompt(dispatch, phase)
+            : developCycle
+                ? buildDevelopCyclePrompt(dispatch, phase)
+                : buildImplementationPrompt(dispatch, phase);
+        const providerPrompt = buildProviderCliPrompt(dispatch, implementationPrompt, context.runtimeEnvironment);
+        const pipePromptToStdin = shouldPipePromptToStdin(dispatch.execution.provider, providerPrompt, usesManagedWindowsHost(dispatch));
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: debugCycle
-                ? buildDebugCyclePrompt(dispatch, phase)
-                : developCycle
-                    ? buildDevelopCyclePrompt(dispatch, phase)
-                    : buildImplementationPrompt(dispatch, phase),
-            completionTools
+            prompt: implementationPrompt,
+            promptFromStdin: pipePromptToStdin,
+            completionTools,
+            runtimeEnvironment: context.runtimeEnvironment
         });
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
-            eventType: "provider_cli_started"
+            content: `Starting provider CLI: ${formatProviderCliCommandForCheckpoint(command)} in ${worktree.worktreePath}`,
+            eventType: "provider_cli_starting"
         });
         await context.emit({
             role: "runner",
@@ -393,24 +506,33 @@ export class ProcessBackedProviderCliService {
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
+        const toolHeartbeat = new ProviderToolActivityHeartbeat(outputState, context.emit, this.providerToolHeartbeatIntervalMs);
         const liveCompletionEvents = new LiveCompletionArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, phase, developCycle, debugCycle, context.emit);
         let result;
         try {
             liveCompletionEvents.start();
-            result = await this.processRunner.run({
+            result = await (context.processRunner ?? this.processRunner).run({
                 command: command.command,
                 args: command.args,
                 cwd: worktree.worktreePath,
-                env: providerProcessEnv(dispatch)
+                env: providerProcessEnv(dispatch, context.runtimeEnvironment),
+                stdin: pipePromptToStdin ? providerPrompt : undefined
             }, {
+                onStarted: async () => {
+                    await context.emit({
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: "Provider CLI is supervised and ready.",
+                        eventType: "provider_cli_started"
+                    });
+                },
                 onStdoutLine: async (line) => {
-                    for (const event of outputState.consume(line)) {
-                        await context.emit(event);
-                    }
+                    await toolHeartbeat.consume(line);
                 }
             }, context.signal);
         }
         finally {
+            toolHeartbeat.stop();
             await liveCompletionEvents.stop();
             await cleanupCompletionTools(completionTools, context.emit);
         }
@@ -426,8 +548,8 @@ export class ProcessBackedProviderCliService {
         });
         await emitProviderUsageEvent(context.emit, dispatch, outputState);
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
-        if (developCycle || debugCycle || phase === "implementation") {
-            await this.git.run(worktree.worktreePath, ["push", "origin", `HEAD:${worktree.branchName}`]);
+        if ((developCycle || debugCycle || phase === "implementation") && providerOwnsBranchPublication(context)) {
+            await pushWorktreeBranch(this.git, worktree.worktreePath, worktree.branchName, worktree.repoPath, this.publicationCoordinator, context.signal, context.emit);
             await context.emit({
                 role: "runner",
                 kind: "checkpoint",
@@ -485,18 +607,23 @@ export class ProcessBackedProviderCliService {
         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: "pending_approval", produced_by: "forge-lane-command" }) + "\n", "utf8");
-        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "architect" });
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "architect", runtimeEnvironment: context.runtimeEnvironment });
+        const architectPrompt = buildArchitectPrompt(dispatch);
+        const providerPrompt = buildProviderCliPrompt(dispatch, architectPrompt, context.runtimeEnvironment);
+        const pipePromptToStdin = shouldPipePromptToStdin(dispatch.execution.provider, providerPrompt, usesManagedWindowsHost(dispatch));
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildArchitectPrompt(dispatch),
-            completionTools
+            prompt: architectPrompt,
+            promptFromStdin: pipePromptToStdin,
+            completionTools,
+            runtimeEnvironment: context.runtimeEnvironment
         });
-        const commandText = formatProviderCliCommand(command);
+        const commandText = formatProviderCliCommandForCheckpoint(command);
         await context.emit({
             role: "runner",
             kind: "checkpoint",
             content: `Starting provider CLI Architect: ${commandText} in ${worktree.worktreePath}`,
-            eventType: "provider_cli_started"
+            eventType: "provider_cli_starting"
         });
         await context.emit({
             role: "runner",
@@ -505,24 +632,31 @@ export class ProcessBackedProviderCliService {
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
+        const toolHeartbeat = new ProviderToolActivityHeartbeat(outputState, context.emit, this.providerToolHeartbeatIntervalMs);
         const liveArchitectEvents = new LiveArchitectArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, context.emit);
         let result;
         try {
             liveArchitectEvents.start();
-            result = await this.processRunner.run({
+            result = await (context.processRunner ?? this.processRunner).run({
                 command: command.command,
                 args: command.args,
                 cwd: worktree.worktreePath,
-                env: providerProcessEnv(dispatch)
+                env: providerProcessEnv(dispatch, context.runtimeEnvironment),
+                stdin: pipePromptToStdin ? providerPrompt : undefined
             }, {
-                onStdoutLine: async (line) => {
-                    for (const event of outputState.consume(line)) {
-                        await context.emit(event);
-                    }
-                }
+                onStarted: async () => {
+                    await context.emit({
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: "Provider CLI Architect is supervised and ready.",
+                        eventType: "provider_cli_started"
+                    });
+                },
+                onStdoutLine: async (line) => await toolHeartbeat.consume(line)
             }, context.signal);
         }
         finally {
+            toolHeartbeat.stop();
             await liveArchitectEvents.stop();
             await cleanupCompletionTools(completionTools, context.emit);
         }
@@ -576,18 +710,23 @@ export class ProcessBackedProviderCliService {
         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: "qa" });
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "qa", runtimeEnvironment: context.runtimeEnvironment });
+        const qaPrompt = buildQaPrompt(dispatch, specBody);
+        const providerPrompt = buildProviderCliPrompt(dispatch, qaPrompt, context.runtimeEnvironment);
+        const pipePromptToStdin = shouldPipePromptToStdin(dispatch.execution.provider, providerPrompt, usesManagedWindowsHost(dispatch));
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildQaPrompt(dispatch, specBody),
-            completionTools
+            prompt: qaPrompt,
+            promptFromStdin: pipePromptToStdin,
+            completionTools,
+            runtimeEnvironment: context.runtimeEnvironment
         });
-        const commandText = formatProviderCliCommand(command);
+        const commandText = formatProviderCliCommandForCheckpoint(command);
         await context.emit({
             role: "runner",
             kind: "checkpoint",
             content: `Starting provider CLI QA: ${commandText} in ${worktree.worktreePath}`,
-            eventType: "provider_cli_started"
+            eventType: "provider_cli_starting"
         });
         await context.emit({
             role: "runner",
@@ -596,24 +735,34 @@ export class ProcessBackedProviderCliService {
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
+        const toolHeartbeat = new ProviderToolActivityHeartbeat(outputState, context.emit, this.providerToolHeartbeatIntervalMs);
+        const verificationProgress = new ManagedVerificationProgressEmitter(context.runtimeEnvironment?.FORGE_LOG_DIR, context.emit);
         const liveQaEvents = new LiveQaArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, dispatch, context.emit);
         let result;
         try {
             liveQaEvents.start();
-            result = await this.processRunner.run({
+            verificationProgress.start();
+            result = await (context.processRunner ?? this.processRunner).run({
                 command: command.command,
                 args: command.args,
                 cwd: worktree.worktreePath,
-                env: providerProcessEnv(dispatch)
+                env: providerProcessEnv(dispatch, context.runtimeEnvironment),
+                stdin: pipePromptToStdin ? providerPrompt : undefined
             }, {
-                onStdoutLine: async (line) => {
-                    for (const event of outputState.consume(line)) {
-                        await context.emit(event);
-                    }
-                }
+                onStarted: async () => {
+                    await context.emit({
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: "Provider CLI QA is supervised and ready.",
+                        eventType: "provider_cli_started"
+                    });
+                },
+                onStdoutLine: async (line) => await toolHeartbeat.consume(line)
             }, context.signal);
         }
         finally {
+            toolHeartbeat.stop();
+            await verificationProgress.stop();
             await liveQaEvents.stop();
             await cleanupCompletionTools(completionTools, context.emit);
         }
@@ -635,7 +784,7 @@ export class ProcessBackedProviderCliService {
                 ? "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.");
         }
-        enforceQaBrowserLaunchTargetGate(dispatch, qaArtifact);
+        await enforceQaBrowserLaunchTargetGate(dispatch, qaArtifact);
         if (!liveQaEvents.hasEmitted()) {
             await emitQaArtifactRecorded(context.emit, worktree.worktreePath, qaArtifact);
             await emitQaStructuredEvents(context.emit, qaArtifact);
@@ -659,2412 +808,216 @@ export class ProcessBackedProviderCliService {
             artifacts: [qaArtifact]
         };
     }
+    async runCiRepair(context) {
+        return await this.runPullRequestRepair(context, "ci_repair");
+    }
     async runConflictResolve(context) {
+        return await this.runPullRequestRepair(context, "conflict_resolve");
+    }
+    async runPullRequestRepair(context, route) {
         const { dispatch, worktree } = context;
-        const addressComments = isPullRequestCommentsDispatch(dispatch);
+        const repairChecks = route === "ci_repair" || isPullRequestCheckRepairDispatch(dispatch);
+        const addressComments = !repairChecks && isPullRequestCommentsDispatch(dispatch);
+        let repairSpec = null;
+        let repairEnvironment = context.runtimeEnvironment;
+        let completionTools = null;
+        if (repairChecks) {
+            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);
+            if (!laneCommand) {
+                throw new Error(`CI repair readiness failed: lane command for '${dispatch.execution.lane}' was not resolved, so the approved spec cannot be materialized.`);
+            }
+            const specBody = buildSpecBody(laneCommand, dispatch.workItem, "ci_repair");
+            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");
+            repairSpec = {
+                repoPath: worktree.worktreePath,
+                path: specPath,
+                body: specBody,
+                producedBy: "forge-lane-command",
+                status: "approved",
+            };
+            const readiness = await writeCiRepairReadinessManifest(dispatch, worktree.worktreePath, specPath, context.runtimeEnvironment);
+            repairEnvironment = readiness.environment;
+            completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "ci_repair", runtimeEnvironment: repairEnvironment });
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: `CI repair readiness contract prepared at ${path.relative(worktree.worktreePath, readiness.path).replaceAll(path.sep, "/")}; approved spec, attempt URLs, browser readiness, and local-equivalence policy are available before provider start.`,
+                eventType: "ci_repair_readiness_ready",
+            });
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: "Forge CI repair completion tool configured; provider must call forge.complete_ci_repair before Bridge-owned commit and push.",
+                eventType: "completion_tools_configured",
+            });
+        }
+        const repairPrompt = repairChecks
+            ? buildPullRequestCheckRepairPrompt(dispatch, worktree.branchName)
+            : addressComments
+                ? buildPullRequestCommentsPrompt(dispatch, worktree.branchName)
+                : buildConflictResolvePrompt(dispatch, worktree.branchName);
+        const providerPrompt = buildProviderCliPrompt(dispatch, repairPrompt, repairEnvironment);
+        const pipePromptToStdin = shouldPipePromptToStdin(dispatch.execution.provider, providerPrompt, usesManagedWindowsHost(dispatch));
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: addressComments
-                ? buildPullRequestCommentsPrompt(dispatch, worktree.branchName)
-                : buildConflictResolvePrompt(dispatch, worktree.branchName)
+            prompt: repairPrompt,
+            promptFromStdin: pipePromptToStdin,
+            completionTools: completionTools ?? undefined,
+            runtimeEnvironment: repairEnvironment
         });
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI ${addressComments ? "PR comment address" : "conflict resolve"}: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
-            eventType: "provider_cli_started"
+            content: `Starting provider CLI ${repairChecks ? "CI repair" : addressComments ? "PR comment address" : "conflict resolve"}: ${formatProviderCliCommandForCheckpoint(command)} in ${worktree.worktreePath}`,
+            eventType: "provider_cli_starting"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
-        const result = await this.processRunner.run({
-            command: command.command,
-            args: command.args,
-            cwd: worktree.worktreePath,
-            env: providerProcessEnv(dispatch)
-        }, {
-            onStdoutLine: async (line) => {
-                for (const event of outputState.consume(line)) {
-                    await context.emit(event);
+        const toolHeartbeat = new ProviderToolActivityHeartbeat(outputState, context.emit, this.providerToolHeartbeatIntervalMs);
+        let result;
+        try {
+            result = await (context.processRunner ?? this.processRunner).run({
+                command: command.command,
+                args: command.args,
+                cwd: worktree.worktreePath,
+                env: providerProcessEnv(dispatch, repairEnvironment),
+                stdin: pipePromptToStdin ? providerPrompt : undefined
+            }, {
+                onStarted: async () => {
+                    await context.emit({
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: `Provider CLI ${repairChecks ? "CI repair" : addressComments ? "PR comment address" : "conflict resolve"} is supervised and ready.`,
+                        eventType: "provider_cli_started"
+                    });
+                },
+                onStdoutLine: async (line) => {
+                    await toolHeartbeat.consume(line);
                 }
+            }, context.signal);
+        }
+        finally {
+            toolHeartbeat.stop();
+            if (completionTools) {
+                await cleanupCompletionTools(completionTools, context.emit);
             }
-        }, 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 emitProviderUsageEvent(context.emit, dispatch, outputState);
-        await context.emit({
-            role: "assistant",
-            kind: "message",
-            content: outputState.finalMessage || (addressComments
-                ? `${dispatch.execution.provider} CLI addressed pull request comments for ${worktree.branchName}.`
-                : `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`),
-            eventType: addressComments ? "pr_comments_complete" : "conflict_resolve_complete"
-        });
-        return {
-            summary: addressComments
-                ? `${dispatch.execution.provider} CLI addressed PR comments on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`
-                : `${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 runDraft(context) {
-        const content = JSON.stringify(deterministicDraftPayload(context.dispatch));
-        await context.emit({
-            role: "assistant",
-            kind: "message",
-            content,
-            eventType: "draft_complete"
-        });
-        await context.emit(buildProviderUsageEvent(context.dispatch, estimatedDeterministicUsage()));
-        return { summary: "forge-bridge generated deterministic draft." };
-    }
-    async runImplementation(context) {
-        const { dispatch, worktree } = context;
-        const phase = completionPhaseFromDispatch(dispatch);
-        const developCycle = usesDevelopCycleCompletion(dispatch);
-        const debugCycle = usesDebugCycleCompletion(dispatch);
-        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, phase)}
-## 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 phases = debugCycle
-            ? debugCompletionPhaseOrder
-            : 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)
-            }, isDebugCompletionPhaseForProvider(completionPhase)
-                ? expectedDebugCompletionToolName(completionPhase)
-                : 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.`);
+        let repairArtifact = null;
+        if (repairChecks) {
+            repairArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "ci_repair");
+            if (!repairArtifact) {
+                throw new Error("Provider CLI completed but did not call forge.complete_ci_repair. Forge did not commit or push the repair.");
             }
-            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} (${debugCycle ? "debug cycle" : developCycle ? "develop cycle" : phase}).`,
-            spec: {
-                repoPath: worktree.worktreePath,
-                path: specPath,
-                body: specBody,
-                producedBy: "forge-lane-command",
-                status: "approved"
-            },
-            artifact: completionArtifacts[0],
-            artifacts: completionArtifacts
-        };
-    }
-    async runArchitect(context) {
-        const { dispatch, worktree } = context;
-        const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
-        await fs.mkdir(metadataRoot, { recursive: true });
-        const specBody = `---\ntitle: "${dispatch.workItem.title}"\nstatus: pending_approval\nproduced_by: forge-bridge\n---\n\n# ${dispatch.workItem.title}\n\nArchitect plan pending approval.\n`;
-        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: "pending_approval", produced_by: "forge-bridge" }) + "\n", "utf8");
-        await writeCompletionArtifact({
-            worktreePath: worktree.worktreePath,
-            workItemId: dispatch.workItem.id,
-            phase: "architect",
-            producedBy: "forge-bridge",
-            redactionSecrets: exactRedactionSecrets(dispatch),
-            architectCycle: true
-        }, expectedCompletionToolName("architect"), deterministicArchitectPayload(dispatch));
-        const artifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "architect");
-        if (!artifact) {
-            throw new Error("Deterministic provider did not produce the Forge Architect completion artifact.");
-        }
-        await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, artifact);
-        await emitArchitectStructuredEvents(context.emit, worktree.worktreePath, dispatch.workItem.id, artifact);
-        await context.emit({
-            role: "assistant",
-            kind: "message",
-            content: "Architect plan complete. forge-bridge produced deterministic planning artifacts.",
-            eventType: "architect_complete"
-        });
-        return {
-            summary: "forge-bridge completed Architect plan (deterministic).",
-            spec: {
-                repoPath: worktree.worktreePath,
-                path: specPath,
-                body: specBody,
-                producedBy: "forge-bridge",
-                status: "pending_approval"
-            },
-            artifact,
-            artifacts: [artifact]
-        };
-    }
-    async runQa(context) {
-        const { dispatch, worktree } = context;
-        await context.emit({
-            role: "worker",
-            kind: "message",
-            content: `Planning ${dispatch.execution.provider} QA checks through forge-bridge.`,
-            eventType: "qa_plan"
-        });
-        const qaBrowser = dispatch.qaBrowser;
-        const launchTarget = qaBrowser?.launchTarget ?? null;
-        const missingLaunchTarget = qaBrowser?.required === true && !hasLaunchTarget(launchTarget);
-        const browserSidecar = !missingLaunchTarget && qaBrowser?.required === true && launchTarget
-            ? deterministicBrowserSidecar(dispatch.workItem.id, launchTarget, dispatch.cycleRun.ownerType, dispatch.cycleRun.ownerId)
-            : null;
-        const browserChecks = browserSidecar && launchTarget
-            ? [deterministicBrowserCheck(launchTarget, browserSidecar.relativePath)]
-            : [];
-        const sidecars = await writeQaSidecarFiles(worktree.worktreePath, browserSidecar ? [browserSidecar] : []);
-        const summary = missingLaunchTarget
-            ? "QA blocked because browser testing is required but no app launch target was provided."
-            : "All checks passed. forge-bridge QA completed.";
-        const criterion = dispatch.workItem.acceptanceCriteria.trim() || "Forge QA evidence exists";
-        for (const gate of qaCompletionGateOrder) {
-            await writeCompletionArtifact({
-                worktreePath: worktree.worktreePath,
-                workItemId: dispatch.workItem.id,
-                phase: "qa",
-                producedBy: "forge-bridge",
-                redactionSecrets: exactRedactionSecrets(dispatch),
-                qaCycle: true,
-                ownerType: dispatch.cycleRun.ownerType ?? undefined,
-                ownerId: dispatch.cycleRun.ownerId ?? undefined
-            }, expectedQaCompletionToolName(gate), deterministicQaGatePayload({
-                gate,
-                criterion,
-                summary,
-                missingLaunchTarget,
-                browserChecks,
-                sidecars
-            }));
-            const gateArtifact = await readQaGateArtifact(qaArtifactRootForDispatch(worktree.worktreePath, dispatch.workItem.id, dispatch), gate);
-            if (gateArtifact) {
-                await emitQaGateAccepted(context.emit, worktree.worktreePath, gateArtifact, nextQaGate(gate));
+            if ((repairArtifact.status ?? "").trim().toLowerCase() !== "pass") {
+                throw new Error(`CI repair completion gate recorded ${repairArtifact.status}; Forge did not commit or push the repair.`);
             }
+            await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, repairArtifact);
+            await emitPhaseCompletionEvent(context.emit, repairArtifact);
+            await emitPhaseGateEvents(context.emit, repairArtifact);
         }
-        const qaArtifact = await readQaCompletionArtifactBundle(worktree.worktreePath, dispatch.workItem.id, dispatch.cycleRun.ownerType, dispatch.cycleRun.ownerId);
-        if (!qaArtifact) {
-            throw new Error("Deterministic QA did not produce the complete durable QA artifact bundle.");
+        const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
+        if (providerOwnsBranchPublication(context)) {
+            await pushWorktreeBranch(this.git, worktree.worktreePath, worktree.branchName, worktree.repoPath, this.publicationCoordinator, context.signal, context.emit);
         }
-        await emitQaArtifactRecorded(context.emit, worktree.worktreePath, qaArtifact);
-        await emitQaStructuredEvents(context.emit, qaArtifact);
-        await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
-        return {
-            summary: missingLaunchTarget ? "forge-bridge QA blocked." : "forge-bridge QA passed.",
-            artifact: qaArtifact,
-            artifacts: [qaArtifact]
-        };
-    }
-    async runConflictResolve(context) {
-        const { dispatch, worktree } = context;
-        const addressComments = isPullRequestCommentsDispatch(dispatch);
-        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge ${addressComments ? "pr comments" : "conflict resolve"} for ${dispatch.workItem.id.slice(0, 8)}`]);
-        await context.emit(buildProviderUsageEvent(dispatch, estimatedDeterministicUsage()));
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
         await context.emit({
             role: "assistant",
             kind: "message",
-            content: addressComments
-                ? `Deterministic PR comment addressing completed for ${worktree.branchName}.`
-                : `Deterministic conflict resolve completed for ${worktree.branchName}.`,
-            eventType: addressComments ? "pr_comments_complete" : "conflict_resolve_complete"
+            content: outputState.finalMessage || (repairChecks
+                ? `${dispatch.execution.provider} CLI repaired pull request checks for ${worktree.branchName}.`
+                : addressComments
+                    ? `${dispatch.execution.provider} CLI addressed pull request comments for ${worktree.branchName}.`
+                    : `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`),
+            eventType: repairChecks ? "pr_checks_complete" : addressComments ? "pr_comments_complete" : "conflict_resolve_complete"
         });
         return {
-            summary: addressComments
-                ? `forge-bridge addressed PR comments for ${worktree.branchName}.`
-                : `forge-bridge resolved conflicts for ${worktree.branchName}.`
-        };
-    }
-}
-function phaseCompleteEventType(phase) {
-    return phase === "implementation" ? "implementation_complete" : `${phase}_complete`;
-}
-function isDebugCompletionPhaseForProvider(phase) {
-    return debugCompletionPhaseOrder.includes(phase);
-}
-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 === "debug_repro") {
-        return {
-            status: "pass",
-            summary: "forge-bridge reproduced the bug deterministically.",
-            repro_steps: ["Run the deterministic fake-worker debug reproduction."],
-            observed: "The configured bug scenario is reproducible in deterministic bridge mode.",
-            expected: "The bug scenario should be fixed before QA handoff.",
-            evidence: [{ kind: "changeset", path: "FORGE_PHASE5_CHANGESET.md", content_hash: changesetHash }]
-        };
-    }
-    if (phase === "debug_root_cause") {
-        return {
-            status: "pass",
-            summary: "forge-bridge isolated a deterministic root cause.",
-            root_cause: "The deterministic fake-worker bug is represented by the generated changeset evidence.",
-            evidence: [{ kind: "changeset", path: "FORGE_PHASE5_CHANGESET.md", content_hash: changesetHash }],
-            eliminated_alternatives: [{ summary: "No alternate deterministic fake-worker path was implicated." }],
-            risk_area: "forge-bridge deterministic debug lane"
-        };
-    }
-    if (phase === "debug_fix") {
-        return {
-            status: "pass",
-            summary: "forge-bridge applied a deterministic debug fix.",
-            changed_files: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Recorded deterministic debug fix evidence." }],
-            tests_added_or_updated: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Deterministic debug evidence doubles as fake-worker regression coverage." }],
-            remaining_risks: [],
-            resolved_findings: (dispatch.qaRework?.findingIds ?? []).map((qaId) => ({
-                qa_id: qaId,
-                status: "resolved",
-                summary: `Resolved deterministic QA finding ${qaId}.`,
-                evidence: { path: "FORGE_PHASE5_CHANGESET.md", content_hash: changesetHash },
-                changed_files: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Recorded deterministic debug fix evidence." }],
-                tests_added_or_updated: [{ path: "FORGE_PHASE5_CHANGESET.md", summary: "Deterministic fake-worker regression evidence." }],
-                regression_evidence: [{ command: "forge-bridge deterministic debug regression", status: "pass" }]
-            }))
-        };
-    }
-    if (phase === "debug_regression") {
-        return {
-            status: "pass",
-            summary: "forge-bridge proved the deterministic debug regression is QA-ready.",
-            commands: [{ command: "forge-bridge deterministic debug regression", exit_code: 0, status: "pass", summary: "Deterministic debug regression completed." }],
-            required_regressions: ["Original deterministic repro no longer fails."],
-            build_status: "not_applicable",
-            test_status: "pass",
-            repro_negative: true,
-            qa_ready: true
-        };
-    }
-    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: []
+            summary: repairChecks
+                ? `${dispatch.execution.provider} CLI repaired PR checks on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`
+                : addressComments
+                    ? `${dispatch.execution.provider} CLI addressed PR comments on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`
+                    : `${dispatch.execution.provider} CLI resolved conflicts on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`,
+            spec: repairSpec,
+            artifact: repairArtifact,
+            artifacts: repairArtifact ? [repairArtifact] : [],
         };
     }
-    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
-    };
-}
-function deterministicArchitectPayload(dispatch) {
-    const planId = `architect-${dispatch.workItem.id.replace(/-/g, "")}`;
-    return {
-        status: "pass",
-        summary: "forge-bridge produced a deterministic Architect plan.",
-        implementation_plan: {
-            schema_version: 1,
-            plan_id: planId,
-            story_id: dispatch.workItem.id,
-            phases: [
-                { id: "phase-1", name: "Foundation", tasks: ["task-1"], gate: "phase-1-gate" }
-            ],
-            tasks: [
-                {
-                    id: "task-1",
-                    title: `Implement ${dispatch.workItem.title}`,
-                    phase: "phase-1",
-                    summary: "Deterministic bridge Architect task proving MCP artifact contract persistence.",
-                    acceptance_criteria: [dispatch.workItem.acceptanceCriteria || `Preserve story intent for ${dispatch.workItem.title}`],
-                    tests: [
-                        { command: "dotnet test /home/dillon/repos/Forge/Forge.sln --filter Architect", purpose: "Architect bridge contract regression" }
-                    ]
-                }
-            ],
-            dependencies: [],
-            phase_gates: [
-                { id: "phase-1-gate", phase: "phase-1", checks: ["Task tests pass", "Artifacts validate"] }
-            ]
-        },
-        qa_plan: {
-            schema_version: 1,
-            plan_id: planId,
-            final_qa: [
-                { id: "qa-1", coverage: `Verify Architect plan artifacts and pending approval status for ${dispatch.workItem.title}` }
-            ]
-        },
-        report_markdown: `# Architect Report\n\nWork item: ${dispatch.workItem.id}\nTitle: ${dispatch.workItem.title}\n\nVerdict: pass\n\nDeterministic bridge Architect plan produced for pending approval.\n`
-    };
 }
-function deterministicQaGatePayload(options) {
-    const blocked = options.missingLaunchTarget;
-    const skippedBecauseBlocked = blocked
-        ? {
-            status: "skipped",
-            summary: "Skipped because browser QA was blocked by missing launch target.",
-            reason: "Upstream browser QA blocker prevents meaningful downstream evidence."
+async function stageDraftAttachments(dispatch, metadataRoot) {
+    const attachments = dispatch.draft?.attachments ?? [];
+    const stageable = attachments.filter((attachment) => (attachment.kind === "text" && typeof attachment.textContent === "string")
+        || (attachment.kind === "image" && typeof attachment.contentBase64 === "string"));
+    if (stageable.length === 0) {
+        return { textReferences: [], imagePaths: [] };
+    }
+    const attachmentRoot = path.join(metadataRoot, "draft-attachments");
+    const worktreeRoot = path.resolve(metadataRoot, "../../..");
+    await fs.mkdir(attachmentRoot, { recursive: true });
+    const textReferences = [];
+    const imagePaths = [];
+    for (const attachment of stageable) {
+        const fileName = `${String(attachment.index + 1).padStart(2, "0")}-${safeAttachmentFileName(attachment.fileName)}`;
+        const absolutePath = path.join(attachmentRoot, fileName);
+        if (attachment.kind === "text") {
+            await fs.writeFile(absolutePath, attachment.textContent ?? "", { encoding: "utf8", mode: 0o600 });
+            textReferences.push({ index: attachment.index, path: path.relative(worktreeRoot, absolutePath).replaceAll(path.sep, "/") });
+            continue;
         }
-        : null;
-    switch (options.gate) {
-        case "qa_plan":
-            return {
-                status: "pass",
-                summary: "Deterministic QA plan recorded.",
-                checklist: [
-                    "Review the validated work item against acceptance criteria.",
-                    "Run deterministic regression evidence.",
-                    "Confirm no in-scope QA findings remain."
-                ],
-                acceptance_criteria: [options.criterion]
-            };
-        case "qa_regression":
-            return {
-                status: "pass",
-                summary: "Deterministic regression QA completed.",
-                commands: [
-                    {
-                        command: "forge-bridge deterministic QA",
-                        exit_code: 0,
-                        status: "pass",
-                        summary: "Deterministic regression evidence completed."
-                    }
-                ],
-                notes: "Regression gate passed in deterministic fake-worker mode."
-            };
-        case "qa_api":
-            return {
-                status: "skipped",
-                summary: "No API/backend surface was identified for deterministic QA.",
-                reason: "The deterministic fake-worker changeset does not exercise API/backend behavior."
-            };
-        case "qa_manual_web":
-            return blocked
-                ? {
-                    status: "blocked",
-                    summary: "Browser QA could not run because no app launch target was provided.",
-                    blocker_reason: "missing_app_launch_target"
-                }
-                : options.browserChecks.length > 0
-                    ? {
-                        status: "pass",
-                        summary: "Deterministic browser QA exercised the configured launch target.",
-                        browser_checks: options.browserChecks,
-                        sidecars: options.sidecars,
-                        notes: "Browser sidecar evidence recorded."
-                    }
-                    : {
-                        status: "skipped",
-                        summary: "Manual web QA was not required for this deterministic run.",
-                        reason: "Forge did not require browser QA and no launch target was necessary."
-                    };
-        case "qa_bug_repro":
-            return skippedBecauseBlocked ?? {
-                status: "skipped",
-                summary: "No failed QA observation required bug reproduction.",
-                reason: "No defects or candidate bugs were observed."
-            };
-        case "qa_findings":
-            return skippedBecauseBlocked ?? {
-                status: "pass",
-                summary: "No QA findings or candidate bugs were identified.",
-                findings: [],
-                candidate_bugs: []
-            };
-        case "qa_verdict":
-            return {
-                status: blocked ? "blocked" : "pass",
-                summary: options.summary,
-                checklist: [
-                    "Review the validated work item against acceptance criteria.",
-                    "Run deterministic regression evidence.",
-                    blocked ? "Record missing browser launch target blocker." : "Confirm no in-scope QA findings remain."
-                ],
-                tested_acceptance_criteria: blocked ? [] : [options.criterion],
-                commands: blocked
-                    ? []
-                    : [
-                        {
-                            command: "forge-bridge deterministic QA",
-                            exit_code: 0,
-                            status: "pass",
-                            summary: "Deterministic QA command completed."
-                        }
-                    ],
-                browser_checks: blocked ? [] : options.browserChecks,
-                sidecars: blocked ? [] : options.sidecars,
-                notes: options.summary,
-                findings: [],
-                candidate_bugs: [],
-                blocker_reason: blocked ? "missing_app_launch_target" : null,
-                report_markdown: `# QA report\n\n${options.summary}\n`
-            };
-    }
-}
-const qaArtifactFileNames = {
-    plan: "qa.plan.json",
-    evidence: "qa.evidence.json",
-    findings: "qa.findings.json",
-    verdict: "qa.verdict.json",
-    report: "qa.report.md"
-};
-const qaGateArtifactFileNames = {
-    qa_plan: "qa.plan.json",
-    qa_regression: "qa.regression.json",
-    qa_api: "qa.api.json",
-    qa_manual_web: "qa.manual-web.json",
-    qa_bug_repro: "qa.bug-repro.json",
-    qa_findings: "qa.findings.json",
-    qa_verdict: "qa.verdict.json"
-};
-function hasLaunchTarget(target) {
-    return Boolean(target?.url?.trim()
-        || target?.ready_url?.trim()
-        || target?.command?.trim()
-        || (target?.routes ?? []).some((route) => route.trim().length > 0));
-}
-function deterministicBrowserSidecar(workItemId, target, ownerType, ownerId) {
-    const route = primaryLaunchRoute(target);
-    return {
-        relativePath: qaArtifactRelativePath(workItemId, "qa/screenshots/deterministic-browser-check.txt", ownerType, ownerId),
-        content: `Deterministic Forge QA browser evidence\nRoute: ${route}\nConsole errors: []\nNetwork errors: []\nResponsive checks: desktop, mobile\n`
-    };
-}
-function deterministicBrowserCheck(target, screenshotPath) {
-    const route = primaryLaunchRoute(target);
-    return {
-        route,
-        url: route,
-        status: "pass",
-        summary: "Deterministic browser QA exercised the configured launch target.",
-        actions: ["open launch target", "walk acceptance criteria", "check console/network summaries", "check responsive viewport"],
-        screenshots: [screenshotPath],
-        console_errors: [],
-        network_errors: [],
-        responsive_checks: ["desktop", "mobile"]
-    };
-}
-function primaryLaunchRoute(target) {
-    return target.ready_url?.trim()
-        || target.url?.trim()
-        || target.routes.find((route) => route.trim().length > 0)?.trim()
-        || "app launch command";
-}
-async function writeQaSidecarFiles(worktreePath, files) {
-    const sidecars = [];
-    for (const file of files) {
-        const fullPath = path.resolve(worktreePath, file.relativePath);
-        const relativePath = path.relative(worktreePath, fullPath).split(path.sep).join("/");
-        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-            throw new Error(`QA sidecar path must stay under the worktree: ${file.relativePath}`);
-        }
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, file.content, "utf8");
-        sidecars.push({
-            path: relativePath,
-            content_hash: sha256(file.content),
-            bytes: Buffer.byteLength(file.content, "utf8")
-        });
-    }
-    return sidecars;
-}
-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, ownerType, ownerId) {
-    const artifact = await readCompletionArtifact(worktreePath, workItemId, "qa", ownerType, ownerId);
-    if (!artifact || !await hasCompleteQaArtifactBundle(worktreePath, workItemId, ownerType, ownerId)) {
-        return null;
-    }
-    const artifactRoot = ownerType && ownerId
-        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
-        : artifactRootFor(worktreePath, workItemId);
-    const planJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.plan), "utf8");
-    const evidenceJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.evidence), "utf8");
-    const findingsJson = await fs.readFile(path.join(artifactRoot, qaArtifactFileNames.findings), "utf8");
-    await validateQaBundleSidecarReferences(worktreePath, workItemId, ownerType, ownerId);
-    return {
-        ...artifact,
-        planJson,
-        evidenceJson,
-        findingsJson
-    };
-}
-async function hasCompleteQaArtifactBundle(worktreePath, workItemId, ownerType, ownerId) {
-    const artifactRoot = ownerType && ownerId
-        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
-        : 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;
-}
-function enforceQaBrowserLaunchTargetGate(dispatch, artifact) {
-    const qaBrowser = dispatch.qaBrowser;
-    if (!qaBrowser?.required || hasLaunchTarget(qaBrowser.launchTarget ?? null)) {
-        return;
-    }
-    const verdict = parseJsonLine(artifact.verdictJson) ?? {};
-    const status = normalizedString(stringField(verdict, "status") ?? artifact.status ?? "");
-    const blockerReason = normalizedString(stringField(verdict, "blocker_reason") ?? "");
-    if (status !== "blocked" || blockerReason !== "missing_app_launch_target") {
-        throw new Error("QA browser testing is required but no app launch target was provided; provider must return blocked with blocker_reason missing_app_launch_target.");
-    }
-}
-async function validateQaBundleSidecarReferences(worktreePath, workItemId, ownerType, ownerId) {
-    const artifactRoot = ownerType && ownerId
-        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
-        : artifactRootFor(worktreePath, workItemId);
-    const evidence = await readJsonObjectFile(path.join(artifactRoot, qaArtifactFileNames.evidence));
-    const sidecars = arrayField(evidence, "sidecars");
-    if (sidecars.length === 0) {
-        return;
-    }
-    const qaSidecarRoot = path.resolve(artifactRoot, "qa");
-    for (const [index, sidecar] of sidecars.entries()) {
-        const sidecarPath = stringField(sidecar, "path");
-        const expectedHash = stringField(sidecar, "content_hash");
-        const expectedBytes = sidecar.bytes;
-        if (!sidecarPath || !expectedHash || typeof expectedBytes !== "number" || !Number.isFinite(expectedBytes) || expectedBytes <= 0) {
-            throw new Error(`QA sidecar ${index} must include path, content_hash, and positive bytes.`);
-        }
-        if (path.isAbsolute(sidecarPath)) {
-            throw new Error(`QA sidecar ${index} path must be relative to the worktree.`);
-        }
-        const fullPath = path.resolve(worktreePath, sidecarPath);
-        if (!isPathUnderRoot(qaSidecarRoot, fullPath)) {
-            const ownerDirectory = ownerType && ownerId && ownerType.trim().toLowerCase() === "story" ? "stories" : "work-items";
-            const ownerSegment = ownerType && ownerId ? ownerId : workItemId;
-            throw new Error(`QA sidecar ${index} path must be under .forge/${ownerDirectory}/${ownerSegment}/artifacts/qa/.`);
-        }
-        const stat = await fs.lstat(fullPath).catch((error) => {
-            if (isNodeError(error) && error.code === "ENOENT") {
-                throw new Error(`QA sidecar ${index} file does not exist: ${sidecarPath}`);
-            }
-            throw error;
-        });
-        if (!stat.isFile() || stat.isSymbolicLink()) {
-            throw new Error(`QA sidecar ${index} must reference a regular file.`);
-        }
-        await ensureNoSymbolicLinkPathSegments(qaSidecarRoot, path.dirname(fullPath), `QA sidecar ${index} path must not traverse symbolic links.`);
-        if (stat.size !== expectedBytes) {
-            throw new Error(`QA sidecar ${index} bytes do not match the referenced file.`);
-        }
-        const actualHash = await sha256File(fullPath);
-        if (actualHash !== expectedHash.trim().toLowerCase()) {
-            throw new Error(`QA sidecar ${index} content_hash does not match the referenced file.`);
-        }
-    }
-}
-async function emitQaStructuredEvents(emit, artifact) {
-    const artifactRoot = path.dirname(artifact.path);
-    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"
-    });
-}
-function qaArtifactRootForDispatch(worktreePath, workItemId, dispatch) {
-    return dispatch.cycleRun.ownerType && dispatch.cycleRun.ownerId
-        ? artifactRootForOwner(worktreePath, dispatch.cycleRun.ownerType, dispatch.cycleRun.ownerId)
-        : artifactRootFor(worktreePath, workItemId);
-}
-async function readQaGateArtifact(artifactRoot, gate) {
-    const artifactPath = path.join(artifactRoot, qaGateArtifactFileNames[gate]);
-    try {
-        const stat = await fs.stat(artifactPath);
-        if (!stat.isFile()) {
-            return null;
-        }
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-    const payload = await readJsonObjectFile(artifactPath);
-    return {
-        gate,
-        path: artifactPath,
-        status: stringField(payload, "status") ?? "unknown",
-        producedBy: stringField(payload, "produced_by") ?? stringField(payload, "producedBy") ?? undefined,
-        contentHash: stringField(payload, "content_hash") ?? undefined
-    };
-}
-function nextQaGate(gate) {
-    const index = qaCompletionGateOrder.indexOf(gate);
-    return index >= 0 ? qaCompletionGateOrder[index + 1] ?? null : null;
-}
-async function emitQaGateAccepted(emit, worktreePath, artifact, nextGate) {
-    const relativePath = path.relative(worktreePath, artifact.path).split(path.sep).join("/");
-    await emit({
-        role: "hook",
-        kind: artifact.status === "blocked" ? "error" : "checkpoint",
-        content: `phase_gate: ${artifact.gate} artifact accepted with status ${artifact.status}.`,
-        eventType: "phase_gate",
-        data: JSON.stringify({
-            phase: "qa",
-            qa_gate: artifact.gate,
-            status: artifact.status,
-            artifact_relative_paths: [relativePath],
-            content_hash: artifact.contentHash ?? null,
-            produced_by: artifact.producedBy ?? null
-        })
-    });
-    if (!nextGate) {
-        return;
-    }
-    await emit({
-        role: "hook",
-        kind: "checkpoint",
-        content: `phase_progression: ${artifact.gate} -> ${nextGate}`,
-        eventType: "phase_gate",
-        data: JSON.stringify({
-            phase: "qa",
-            from_gate: artifact.gate,
-            to_gate: nextGate
-        })
-    });
-}
-class LiveQaArtifactEmitter {
-    worktreePath;
-    workItemId;
-    dispatch;
-    emit;
-    emittedBundle = false;
-    emittedGates = new Set();
-    timer = null;
-    pending = Promise.resolve();
-    constructor(worktreePath, workItemId, dispatch, emit) {
-        this.worktreePath = worktreePath;
-        this.workItemId = workItemId;
-        this.dispatch = dispatch;
-        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.emittedBundle;
-    }
-    pollQueued() {
-        this.pending = this.pending
-            .then(() => this.poll())
-            .catch(() => undefined);
-        return this.pending;
-    }
-    async poll() {
-        await this.emitAvailableGateEvents();
-        if (this.emittedBundle) {
-            return;
-        }
-        const artifact = await readQaCompletionArtifactBundle(this.worktreePath, this.workItemId, this.dispatch.cycleRun.ownerType, this.dispatch.cycleRun.ownerId);
-        if (!artifact) {
-            return;
-        }
-        enforceQaBrowserLaunchTargetGate(this.dispatch, artifact);
-        this.emittedBundle = true;
-        await emitQaArtifactRecorded(this.emit, this.worktreePath, artifact);
-        await emitQaStructuredEvents(this.emit, artifact);
-    }
-    async emitAvailableGateEvents() {
-        const artifactRoot = qaArtifactRootForDispatch(this.worktreePath, this.workItemId, this.dispatch);
-        for (const gate of qaCompletionGateOrder) {
-            if (this.emittedGates.has(gate)) {
-                continue;
-            }
-            const artifact = await readQaGateArtifact(artifactRoot, gate);
-            if (!artifact) {
-                return;
-            }
-            this.emittedGates.add(gate);
-            await emitQaGateAccepted(this.emit, this.worktreePath, artifact, nextQaGate(gate));
-        }
-    }
-}
-class LiveArchitectArtifactEmitter {
-    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 || !await hasCompleteArchitectArtifactBundle(this.worktreePath, this.workItemId)) {
-            return;
-        }
-        const artifact = await readCompletionArtifact(this.worktreePath, this.workItemId, "architect");
-        if (!artifact) {
-            return;
-        }
-        this.emitted = true;
-        await emitCompletionArtifactRecorded(this.emit, this.worktreePath, artifact);
-        await emitArchitectStructuredEvents(this.emit, this.worktreePath, this.workItemId, artifact);
-    }
-}
-async function hasCompleteArchitectArtifactBundle(worktreePath, workItemId) {
-    const artifactRoot = artifactRootFor(worktreePath, workItemId);
-    for (const fileName of ["implementation.plan.json", "qa.plan.json", "architect.verdict.json", "architect.report.md"]) {
-        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 emitArchitectStructuredEvents(emit, worktreePath, workItemId, artifact) {
-    const artifactRoot = artifactRootFor(worktreePath, workItemId);
-    const implementationPlan = await readJsonObjectFile(path.join(artifactRoot, "implementation.plan.json"));
-    const qaPlan = await readJsonObjectFile(path.join(artifactRoot, "qa.plan.json"));
-    const verdict = parseJsonLine(artifact.verdictJson) ?? {};
-    const status = stringField(verdict, "status") ?? artifact.status ?? "unknown";
-    const planId = stringField(implementationPlan, "plan_id") ?? "unknown";
-    await emit({
-        role: "worker",
-        kind: "checkpoint",
-        content: `Architect plan recorded: ${planId} with ${arrayField(implementationPlan, "phases").length} phases and ${arrayField(implementationPlan, "tasks").length} tasks.`,
-        eventType: "architect_plan"
-    });
-    await emit({
-        role: "worker",
-        kind: "checkpoint",
-        content: `Architect QA seed recorded with ${arrayField(qaPlan, "final_qa").length} final QA items.`,
-        eventType: "architect_qa_seed"
-    });
-    await emit({
-        role: "hook",
-        kind: status === "pass" ? "checkpoint" : "error",
-        content: `architect_mcp_complete: ${status === "pass" ? "accepted" : "recorded"} - ${stringField(verdict, "summary") ?? "Architect completion payload recorded."}`,
-        eventType: "architect_mcp_complete"
-    });
-}
-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, ownerType, ownerId) {
-    if (ownerType && ownerId) {
-        const ownerDirectory = ownerType.trim().toLowerCase() === "story" ? "stories" : "work-items";
-        return [".forge", ownerDirectory, ownerId, "artifacts", fileName].join("/");
-    }
-    return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
-}
-async function emitCompletionArtifactRecorded(emit, worktreePath, artifact) {
-    const relativePath = path.relative(worktreePath, artifact.path) || path.basename(artifact.path);
-    await emit({
-        role: "tool",
-        kind: "checkpoint",
-        content: `Forge completion tool validation passed for ${artifact.phase ?? "unknown"} (${artifact.status}).`,
-        eventType: "completion_tool_validation_passed",
-        data: JSON.stringify({
-            phase: artifact.phase ?? "unknown",
-            status: artifact.status,
-            artifact_relative_paths: [relativePath.split(path.sep).join("/")]
-        })
-    });
-    await emit({
-        role: "tool",
-        kind: "tool_result",
-        content: `Forge completion tool recorded ${artifact.phase ?? "unknown"} artifact ${relativePath} (${artifact.status}).`,
-        eventType: "completion_tool_artifact_recorded",
-        data: JSON.stringify({
-            phase: artifact.phase ?? "unknown",
-            status: artifact.status,
-            artifact_relative_paths: [relativePath.split(path.sep).join("/")]
-        })
-    });
-}
-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 === "debug_repro"
-                ? "phase_progression: debug_repro -> debug_root_cause"
-                : phase === "debug_root_cause"
-                    ? "phase_progression: debug_root_cause -> debug_fix"
-                    : phase === "debug_fix"
-                        ? "phase_progression: debug_fix -> debug_regression"
-                        : phase === "debug_regression"
-                            ? "phase_progression: debug_regression -> QA ready"
-                            : "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 === "architect" || phase === "debug_repro" || phase === "debug_root_cause" || phase === "debug_fix" || phase === "debug_regression"
-        ? phase
-        : "implementation";
-}
-class LiveCompletionArtifactEmitter {
-    worktreePath;
-    workItemId;
-    emit;
-    phases;
-    emitted = new Set();
-    timer = null;
-    pending = Promise.resolve();
-    constructor(worktreePath, workItemId, phase, developCycle, debugCycle, emit) {
-        this.worktreePath = worktreePath;
-        this.workItemId = workItemId;
-        this.emit = emit;
-        if (debugCycle && isDebugCompletionPhaseForProvider(phase)) {
-            this.phases = debugCompletionPhaseOrder.slice(debugCompletionPhaseOrder.indexOf(phase));
-        }
-        else {
-            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, debugCycle) {
-    if (!developCycle && !debugCycle) {
-        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 expectedPhases = debugCycle && isDebugCompletionPhaseForProvider(phase)
-        ? debugCompletionPhaseOrder.slice(debugCompletionPhaseOrder.indexOf(phase))
-        : ["implementation", "self_review", "validation"];
-    const artifacts = [];
-    for (const expectedPhase of expectedPhases) {
-        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 ${expectedPhase} 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 providerProcessEnv(dispatch) {
-    const env = {
-        ...completionRedactionEnv(exactRedactionSecrets(dispatch)),
-        ...providerCredentialEnv(dispatch)
-    };
-    return Object.keys(env).length > 0 ? env : undefined;
-}
-function providerCredentialEnv(dispatch) {
-    const secret = dispatch.apiKeySecretGrant?.secret;
-    if (!secret || !dispatch.execution.requiresApiKeySecretGrant) {
-        return {};
-    }
-    const provider = dispatch.execution.provider.trim().toLowerCase();
-    if (provider === "codex" || provider === "openai") {
-        return { OPENAI_API_KEY: secret };
-    }
-    return {};
-}
-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: buildProviderChildEnvironment(request.env),
-                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 cursorDirect = await resolveCursorAgentDirectLaunch(command, args);
-    if (cursorDirect) {
-        return cursorDirect;
-    }
-    const resolved = await resolveWindowsCommand(command);
-    return resolved ? buildWindowsLaunchCommand(resolved, args) : { command, args };
-}
-async function resolveWindowsCommand(command) {
-    if (path.isAbsolute(command)) {
-        return command;
-    }
-    try {
-        const result = await execFileAsync("where.exe", [command], { timeout: 2000 });
-        return chooseWindowsCommandCandidate(result.stdout.split(/\r?\n/));
-    }
-    catch {
-        return 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 readProcessLines(stream, onLine) {
-    const reader = readline.createInterface({ input: stream });
-    try {
-        for await (const line of reader) {
-            await onLine(line);
-        }
-    }
-    finally {
-        reader.close();
-    }
+        const imageContent = decodeDraftImageAttachment(attachment.contentBase64 ?? "", attachment.fileName, attachment.index);
+        await fs.writeFile(absolutePath, imageContent, { mode: 0o600 });
+        imagePaths.push(absolutePath);
+    }
+    return { textReferences, imagePaths };
+}
+function decodeDraftImageAttachment(contentBase64, fileName, index) {
+    const normalized = contentBase64.replace(/\s+/gu, "");
+    if (normalized.length === 0 || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(normalized)) {
+        throw new Error(`Draft image attachment ${index + 1} (${fileName}) is not valid base64.`);
+    }
+    const decoded = Buffer.from(normalized, "base64");
+    if (decoded.length === 0 || decoded.toString("base64") !== normalized) {
+        throw new Error(`Draft image attachment ${index + 1} (${fileName}) is not valid base64.`);
+    }
+    return decoded;
+}
+function safeAttachmentFileName(fileName) {
+    const sanitized = path.basename(fileName || "attachment.txt")
+        .replace(/[^a-zA-Z0-9._-]/gu, "_")
+        .replace(/[. ]+$/gu, "") || "attachment.txt";
+    const maxFileNameLength = 120;
+    const clipped = clipFileName(sanitized, maxFileNameLength);
+    const extension = path.extname(clipped);
+    const stem = path.basename(clipped, extension).replace(/[. ]+$/gu, "") || "attachment";
+    const windowsReservedName = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/iu;
+    const safeStem = stem === "." || stem === ".." || windowsReservedName.test(stem) ? `attachment-${stem.replaceAll(".", "_")}` : stem;
+    return clipFileName(`${safeStem}${extension}`, maxFileNameLength);
+}
+function clipFileName(fileName, maxLength) {
+    if (fileName.length <= maxLength) {
+        return fileName;
+    }
+    const originalExtension = path.extname(fileName);
+    const extension = originalExtension.length > maxLength - 1
+        ? originalExtension.slice(0, maxLength - 1)
+        : originalExtension;
+    const stem = path.basename(fileName, originalExtension);
+    const maxStemLength = Math.max(1, maxLength - extension.length);
+    return `${stem.slice(0, maxStemLength)}${extension}`;
+}
+const providerPromptStdinThreshold = 8_000;
+function shouldPipePromptToStdin(provider, prompt, force = false) {
+    return provider.trim().toLowerCase() === "codex"
+        && (force || Buffer.byteLength(prompt, "utf8") > providerPromptStdinThreshold);
+}
+function usesManagedWindowsHost(dispatch) {
+    return process.platform === "win32" && dispatch.sandbox?.executionMode === "host";
 }
 function isFakeWorkerModel(model) {
     return model.trim().toLowerCase() === fakeWorkerModel;
 }
-function sha256(content) {
-    return crypto.createHash("sha256").update(content).digest("hex");
-}
-function buildDraftSpec(dispatch) {
-    return `# Draft Generation Context
-
-Project: ${dispatch.draft?.projectName ?? dispatch.repo.name}
-Repository: ${dispatch.draft?.repoName ?? dispatch.repo.name}
-Draft kind: ${dispatch.draft?.kind ?? "draft"}
-
-## User Prompt
-
-${dispatch.draft?.userPrompt ?? ""}
-`;
-}
-async function emitDraftGateArtifacts(emit, worktreePath, workItemId) {
-    const draftArtifactFiles = {
-        draft_intent: "draft.intent.json",
-        draft_repo_context: "draft.repo-context.json",
-        draft_graph_context: "draft.graph-context.json",
-        draft_product_scope: "draft.product-scope.json",
-        draft_work_order_plan: "draft.work-order-plan.json",
-        draft_critic: "draft.critic.json",
-        draft_proposal: "draft.proposal.json"
-    };
-    for (const gate of draftCompletionGateOrder) {
-        const actualPath = path.join(worktreePath, ".forge", "work-items", workItemId, "artifacts", draftArtifactFiles[gate]);
-        if (!await fileExists(actualPath)) {
-            continue;
-        }
-        const relativePath = path.relative(worktreePath, actualPath).split(path.sep).join("/");
-        await emit({
-            role: "tool",
-            kind: "tool_result",
-            content: `Forge Draft completion tool recorded ${gate} artifact ${relativePath}.`,
-            eventType: "completion_tool_artifact_recorded",
-            data: JSON.stringify({ phase: "draft", draft_gate: gate, artifact_relative_paths: [relativePath] })
-        });
-        await emit({
-            role: "hook",
-            kind: "checkpoint",
-            content: `phase_gate: ${gate} artifact accepted with status pass.`,
-            eventType: "phase_gate"
-        });
-        const next = draftCompletionGateOrder[draftCompletionGateOrder.indexOf(gate) + 1];
-        if (next) {
-            await emit({
-                role: "hook",
-                kind: "checkpoint",
-                content: `phase_progression: ${gate} -> ${next}`,
-                eventType: "phase_gate"
-            });
-        }
-    }
-}
-async function emitDecomposeGateArtifacts(emit, worktreePath, workItemId) {
-    const decomposeArtifactFiles = {
-        decompose_subject_intake: "decompose.subject-intake.json",
-        decompose_context_review: "decompose.context-review.json",
-        decompose_breakdown_strategy: "decompose.breakdown-strategy.json",
-        decompose_child_items: "decompose.child-items.json",
-        decompose_dependency_graph: "decompose.dependency-graph.json",
-        decompose_critic: "decompose.critic.json",
-        decompose_proposal: "decompose.proposal.json"
-    };
-    const gates = Object.keys(decomposeArtifactFiles);
-    for (const gate of gates) {
-        const actualPath = path.join(worktreePath, ".forge", "work-items", workItemId, "artifacts", decomposeArtifactFiles[gate]);
-        if (!await fileExists(actualPath)) {
-            continue;
-        }
-        const relativePath = path.relative(worktreePath, actualPath).split(path.sep).join("/");
-        await emit({
-            role: "tool",
-            kind: "tool_result",
-            content: `Forge Decompose completion tool recorded ${gate} artifact ${relativePath}.`,
-            eventType: "completion_tool_artifact_recorded",
-            data: JSON.stringify({ phase: "decompose", decompose_gate: gate, artifact_relative_paths: [relativePath] })
-        });
-        await emit({
-            role: "hook",
-            kind: "checkpoint",
-            content: `phase_gate: ${gate} artifact accepted with status pass.`,
-            eventType: "phase_gate"
-        });
-        const next = gates[gates.indexOf(gate) + 1];
-        if (next) {
-            await emit({
-                role: "hook",
-                kind: "checkpoint",
-                content: `phase_progression: ${gate} -> ${next}`,
-                eventType: "phase_gate"
-            });
-        }
-    }
-}
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function buildDraftPrompt(dispatch) {
-    const draft = dispatch.draft;
-    if (!draft) {
-        throw new Error("Draft prompt is missing.");
-    }
-    const decomposeDraft = isDecomposeDraftDispatch(dispatch);
-    const draftArtifacts = dispatch.artifacts
-        .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
-        .map((artifact) => `## ${artifact.kind}: ${artifact.slug}\n${artifact.body.trim()}`)
-        .join("\n\n");
-    const artifactSection = draftArtifacts
-        ? `\n\n# Injected Draft command/skills/hooks\n\n${draftArtifacts}`
-        : "";
-    const projectSection = [
-        draft.projectName ? `Project: ${draft.projectName}` : null,
-        draft.repoName ? `Repository: ${draft.repoName}` : null
-    ].filter(Boolean).join("\n");
-    const scopedProjectSection = projectSection ? `\n\n# Selected project context\n\n${projectSection}` : "";
-    return `${draft.systemPrompt}${scopedProjectSection}${artifactSection}
-
-Draft kind: ${draft.kind}
-
-${draft.userPrompt}
-
-${decomposeDraft
-        ? `Use the injected command/skills/hooks as lane instructions. You must call each Forge Decompose MCP completion tool in order. Do not claim Decompose is complete until forge.complete_decompose_proposal accepts the final proposal_json.
-
-Complete these gates in order: decompose_subject_intake -> decompose_context_review -> decompose_breakdown_strategy -> decompose_child_items -> decompose_dependency_graph -> decompose_critic -> decompose_proposal.
-
-The final proposal_json object must contain summary, optional blockedReason, and candidates.`
-        : `${completionPromptForDraftCycle("draft_intent")}
-
-Use the injected command/skills/hooks as lane instructions. You must call each Forge Draft MCP completion tool in order. Do not claim the Draft is complete until forge.complete_draft_proposal accepts the final draft_json.`}
-
-Do not modify source files.`;
-}
-function isDecomposeDraftKind(kind) {
-    return kind === "work_order_decomposition" || kind === "feature_decomposition";
-}
-function isDecomposeDraftDispatch(dispatch) {
-    return dispatch.execution.lane.trim().toLowerCase() === "decompose"
-        || dispatch.session.lane.trim().toLowerCase() === "decompose"
-        || isDecomposeDraftKind(dispatch.draft?.kind?.trim().toLowerCase());
-}
-function summarizeStderr(stderr) {
-    const trimmed = stderr.trim();
-    return trimmed ? `: ${clip(trimmed, 1000)}` : "";
-}
-async function waitForCompletionArtifact(worktreePath, workItemId, phase, signal) {
-    while (!signal?.aborted) {
-        const artifact = await readCompletionArtifact(worktreePath, workItemId, phase);
-        if (artifact) {
-            return artifact;
-        }
-        await delay(1000, signal);
-    }
-    throw new Error(`${phase} proposal artifact wait was cancelled.`);
-}
-async function delay(ms, signal) {
-    if (!signal) {
-        await new Promise((resolve) => setTimeout(resolve, ms));
-        return;
-    }
-    const abortSignal = signal;
-    if (abortSignal.aborted) {
-        return;
-    }
-    await new Promise((resolve) => {
-        const timeout = setTimeout(done, ms);
-        const abort = () => done();
-        function done() {
-            clearTimeout(timeout);
-            abortSignal.removeEventListener("abort", abort);
-            resolve();
-        }
-        abortSignal.addEventListener("abort", abort, { once: true });
-        if (abortSignal.aborted) {
-            done();
-        }
-    });
-}
-function deterministicDraftPayload(dispatch) {
-    const kind = dispatch.draft?.kind ?? "work_item";
-    if (kind === "work_order_decomposition") {
-        return {
-            summary: "Fake decompose proposed a Feature DAG for the Work Order.",
-            blockedReason: "",
-            candidates: [
-                {
-                    origin: "agent",
-                    key: "intake-submission",
-                    title: "Customer intake submission",
-                    summary: "Collect, validate, de-duplicate, and confirm incoming customer requests.",
-                    planningPacket: "# Customer intake submission\n\nPlan Stories for request form validation, attachment support, duplicate prevention, and submission confirmation.",
-                    sortOrder: 10,
-                    dependsOn: []
-                },
-                {
-                    origin: "agent",
-                    key: "review-queue",
-                    title: "Reviewer triage queue",
-                    summary: "Provide reviewer triage, assignment, notes, status transitions, and audit trail.",
-                    planningPacket: "# Reviewer triage queue\n\nPlan Stories for queue filtering, assignment, reviewer notes, status changes, and immutable audit trail.",
-                    sortOrder: 20,
-                    dependsOn: ["intake-submission"]
-                }
-            ]
-        };
-    }
-    if (kind === "feature_decomposition") {
-        return {
-            summary: "Fake decompose proposed a Story DAG for the Feature.",
-            blockedReason: "",
-            candidates: [
-                {
-                    origin: "agent",
-                    key: "foundation",
-                    title: "Build the feature foundation",
-                    description: "Create the persistence, API, and UI shell needed by the feature.",
-                    acceptanceCriteria: "Scenario: Foundation exists\nGiven the Feature is selected\nWhen the foundation is delivered\nThen downstream Stories can build on stable contracts",
-                    points: 3,
-                    sortOrder: 10,
-                    dependsOn: []
-                },
-                {
-                    origin: "agent",
-                    key: "workflow-behavior",
-                    title: "Implement the primary workflow behavior",
-                    description: "Implement the main user-visible behavior for the feature after the foundation is ready.",
-                    acceptanceCriteria: "Scenario: Workflow behavior works\nGiven the foundation Story is complete\nWhen the user performs the primary workflow\nThen the expected state change and feedback are visible",
-                    points: 5,
-                    sortOrder: 20,
-                    dependsOn: ["foundation"]
-                },
-                {
-                    origin: "agent",
-                    key: "audit-and-tests",
-                    title: "Add audit coverage and regression tests",
-                    description: "Add audit/evidence behavior and automated regression coverage for the feature.",
-                    acceptanceCriteria: "Scenario: Feature is verifiable\nGiven the workflow behavior is complete\nWhen validation runs\nThen audit evidence and tests cover the expected outcomes",
-                    points: 3,
-                    sortOrder: 30,
-                    dependsOn: ["workflow-behavior"]
-                }
-            ]
-        };
-    }
-    if (kind === "work_order") {
-        return {
-            title: "Deterministic runner Work Order draft",
-            summary: "Forge Runner generated this deterministic Work Order draft.",
-            objective: "Validate runner-backed Draft generation.",
-            planningPacket: "Runner-backed draft generation returned a Work Order JSON payload.",
-            decompositionContext: "Use this deterministic fixture only in bridge tests.",
-            assumptions: ["Forge Runner dispatch is available."],
-            warnings: []
-        };
-    }
-    if (kind === "story") {
-        return {
-            title: "Deterministic runner Story draft",
-            description: "Forge Runner generated this deterministic Story draft.",
-            acceptanceCriteria: "Given runner-backed Draft generation, when Forge requests a Story draft, then JSON is returned.",
-            points: 3
-        };
-    }
-    return {
-        title: "Deterministic runner Work Item draft",
-        description: "Forge Runner generated this deterministic Work Item draft.",
-        acceptanceCriteria: "Given runner-backed Draft generation, when Forge requests a draft, then JSON is returned.",
-        reproSteps: "Run Draft with a Forge Runner provider selected.",
-        systemInfo: "forge-bridge deterministic provider",
-        points: 1
-    };
-}
-export function formatProviderCliCommand(command) {
-    return [command.command, ...command.args].map(singleLine).join(" ");
-}
-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 = run ? ["-s", codexSandboxModeForPlatform(), "-a", "never", "exec"] : ["exec"];
-        if (run?.completionTools) {
-            args.push(...codexMcpConfigArgs(run.completionTools));
-        }
-        args.push("--model", model);
-        if (run) {
-            args.push("--json");
-            if (run.worktreePath) {
-                args.push("--cd", run.worktreePath);
-            }
-            if (run.skipGitRepoCheck) {
-                args.push("--skip-git-repo-check");
-            }
-            args.push(run.prompt ?? "");
-        }
-        return { command: "codex", args };
-    }
-    if (normalizedProvider === "cursor") {
-        const args = ["--print", "--output-format", "stream-json", "--model", model];
-        if (run?.worktreePath) {
-            args.push("--workspace", run.worktreePath);
-        }
-        if (run?.prompt) {
-            args.push("--yolo", "--approve-mcps", "--trust", run.prompt);
-        }
-        return { command: "cursor-agent", args };
-    }
-    const args = ["--model", model];
-    if (run?.prompt) {
-        args.push(run.prompt);
-    }
-    return { command: provider, args };
-}
-export function codexSandboxModeForPlatform(platform = process.platform) {
-    return platform === "win32" ? "danger-full-access" : "workspace-write";
-}
-function buildArchitectPrompt(dispatch) {
-    return `You are Forge's Architect lane running locally in a prepared git worktree.
-
-Work item: ${dispatch.workItem.id} — ${dispatch.workItem.title}
-
-Plan only. Do not implement source changes, do not create Develop phase artifacts, and do not mark the spec approved.
-Read injected Forge context under .forge plus the repository shape, then produce a repo-grounded implementation DAG with task tests, phase gates, final QA coverage, and a pending-approval spec.
-Implementation DAG tasks are Develop child tasks only: include focused repo/product implementation changes. Do not create child Develop tasks for parent-story QA, sign-off, materialized child inventory, child-count evidence, parent plan artifact checks, or final integrated acceptance proof; put those checks in qa_plan.final_qa.
-${architectRevisionInstruction(dispatch)}
-Forge owns protocol files: write Architect artifacts only through the completion MCP tool.
-
-${completionPromptForPhase("architect")}
-
-Finish only after calling forge.complete_architect_plan with implementation_plan, qa_plan, status, summary, and report/report_markdown.`;
-}
-function architectRevisionInstruction(dispatch) {
-    if (!dispatch.architectRevision) {
-        return "";
-    }
-    return `
-Architect revision context:
-- Previous plan id: ${dispatch.architectRevision.priorPlanId}
-- Previous content hash: ${dispatch.architectRevision.priorContentHash}
-- Reviewer feedback: ${dispatch.architectRevision.feedback}
-Revise the prior plan in response to the feedback. Preserve accepted scope and only change what the feedback requires.`;
-}
-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 and any prior phase artifacts required by this phase.
-${phaseWorkInstruction(phase)}
-${qaReworkImplementationInstruction(dispatch)}
-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.
-
-${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.
-${qaReworkImplementationInstruction(dispatch)}
-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 buildDebugCyclePrompt(dispatch, phase = completionPhaseFromDispatch(dispatch)) {
-    return `You are Forge's Debug lane running locally in a prepared git worktree for a bug work item.
-
-Read .forge/work-items/${dispatch.workItem.id}/spec.md, reproduce or characterize the bug, isolate root cause, apply the smallest safe fix, then prove the regression in this same provider session.
-Start in the ${phase.replace(/_/g, " ")} gate. Do not stop after a passing Debug gate; continue through the next Debug MCP instruction returned by the tool server until debug_regression is accepted or the current gate records a non-pass blocker.
-${debugQaReworkInstruction(dispatch)}
-Use the repository's existing conventions. Run focused tests when practical, especially the original repro and required regressions.
-Forge owns protocol files: worktree prep, injected .forge commands/hooks/skills, Debug verdict artifacts, reports, and commits.
-Read Forge-provided context under .forge when needed, but do not edit .forge files or create Forge Debug artifacts by hand.
-
-${completionPromptForDebugCycle(isDebugCompletionPhaseForProvider(phase) ? phase : "debug_repro")}
-
-Finish with a concise summary of changed files and verification after the debug_regression completion tool has accepted the work, or after the current Debug gate tool records a non-pass blocker.`;
-}
-function qaReworkImplementationInstruction(dispatch) {
-    if (!dispatch.qaRework) {
-        return "";
-    }
-    return `
-QA rework context:
-- Attempt ${dispatch.qaRework.attempt}/${dispatch.qaRework.maxAttempts}
-- Rework packet: ${dispatch.qaRework.packetPath}
-- Required QA finding IDs: ${dispatch.qaRework.findingIds.join(", ")}
-Read the packet JSON and fix or explicitly dispute each listed finding. The implementation completion artifact must include resolved_findings entries for every required QA ID with qa_id, status, summary, evidence, changed_files, tests_added_or_updated, and regression_evidence.
-Use only these resolved_findings status values: resolved, disputed, or not_reproduced. Use resolved when the finding was fixed; do not use fixed.`;
-}
-function debugQaReworkInstruction(dispatch) {
-    if (!dispatch.qaRework) {
-        return "";
-    }
-    return `
-QA rework context for Debug:
-- Attempt ${dispatch.qaRework.attempt}/${dispatch.qaRework.maxAttempts}
-- Rework packet: ${dispatch.qaRework.packetPath}
-- Required QA finding IDs: ${dispatch.qaRework.findingIds.join(", ")}
-Read the packet JSON, reproduce or characterize each listed finding, fix or explicitly dispute it, and include resolved_findings entries for every required QA ID in forge.complete_debug_fix with qa_id, status, summary, evidence, changed_files, tests_added_or_updated, and regression_evidence.
-Use only these resolved_findings status values: resolved, disputed, or not_reproduced. Use resolved when the finding was fixed; do not use fixed.`;
-}
-function qaReworkRetestInstruction(dispatch) {
-    if (!dispatch.qaRework) {
-        return "";
-    }
-    return `
-QA retest context:
-- Rework attempt ${dispatch.qaRework.attempt}/${dispatch.qaRework.maxAttempts}
-- Rework packet: ${dispatch.qaRework.packetPath}
-- Priority finding IDs: ${dispatch.qaRework.findingIds.join(", ")}
-Prioritize retesting the listed QA findings and their required regressions before deciding pass, needs_rework, or blocked.`;
-}
-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 QA.";
-    }
-    return "Implement the work item and keep the change focused.";
-}
-function qaBrowserInstruction(dispatch) {
-    const qaBrowser = dispatch.qaBrowser;
-    const qaScope = dispatch.qaScope;
-    if (!qaBrowser) {
-        return "Browser/app launch context: not provided by Forge.";
-    }
-    const scopeAuthority = qaScope
-        ? qaScope.source === "heuristic"
-            ? "Forge's transient heuristic fallback"
-            : "persisted QA scope"
-        : "Forge heuristics";
-    const scopeEvidence = qaScope
-        ? `\n- QA scope required evidence: ${qaScope.required_evidence.length > 0 ? qaScope.required_evidence.join(", ") : "none"}\n- QA scope not applicable: ${qaScope.not_applicable.length > 0 ? qaScope.not_applicable.join(", ") : "none"}${qaScope.rationale ? `\n- QA scope rationale: ${qaScope.rationale}` : ""}`
-        : "";
-    const launchTarget = qaBrowser.launchTarget;
-    if (qaBrowser.required && !hasLaunchTarget(launchTarget ?? null)) {
-        return `Browser/app launch context:\n- UI/browser QA is required for this item by ${scopeAuthority}.\n- No app launch target was provided.\n- Return blocked with blocker_reason: missing_app_launch_target instead of pretending browser testing occurred.${scopeEvidence}\n- Artifact sidecars path when available: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
-    }
-    if (!launchTarget) {
-        return `Browser/app launch context:\n- UI/browser QA is not required by ${scopeAuthority} for this item.\n- If you determine browser testing is needed, return blocked with blocker_reason: missing_app_launch_target unless you can safely identify a launch target from the repo.${scopeEvidence}\n- Browser sidecars path: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
-    }
-    const routes = launchTarget.routes.length > 0 ? launchTarget.routes.join(", ") : "not specified";
-    return `Browser/app launch context:\n- Browser QA required: ${qaBrowser.required ? `yes, by ${scopeAuthority}` : `no by ${scopeAuthority}, unless the diff/AC requires it`}\n- URL: ${launchTarget.url || "not specified"}\n- Ready URL: ${launchTarget.ready_url || "not specified"}\n- Launch command: ${launchTarget.command || "not specified"}\n- Working directory: ${launchTarget.working_directory || "repo root"}\n- Routes to cover: ${routes}\n- Notes: ${launchTarget.notes || "none"}${scopeEvidence}\n- Browser sidecars path: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
-}
-function storyQaInstruction(dispatch) {
-    const storyQa = dispatch.storyQa;
-    if (!storyQa) {
-        return "";
-    }
-    const childLines = storyQa.childTasks.map((child) => {
-        const dependencies = child.dependencyWorkItemIds.length > 0
-            ? child.dependencyWorkItemIds.join(", ")
-            : "none";
-        const validation = child.validationArtifact
-            ? `${child.validationArtifact.status} (${child.validationArtifact.path || "artifact path unavailable"})`
-            : "missing";
-        const childQa = child.qaArtifact
-            ? `${child.qaArtifact.status} (${child.qaArtifact.path || "artifact path unavailable"})`
-            : "not present";
-        return `- ${child.title} (${child.workItemId}, architect ${child.architectTaskId}, phase ${child.phaseId}/${child.phaseOrder}); deps: ${dependencies}; validation: ${validation}; child QA: ${childQa}`;
-    }).join("\n");
-    const finalQa = storyQa.finalQaChecks.length > 0
-        ? storyQa.finalQaChecks.map((check) => `- ${check}`).join("\n")
-        : "- No final QA checks were provided in qa.plan.final_qa.";
-    return `Story QA integration context:
-- Story work item: ${storyQa.storyWorkItemId}
-- Plan: ${storyQa.planId} / ${storyQa.planContentHash}
-- Story worktree: ${storyQa.worktreeKey}
-- Branch: ${storyQa.branch}
-- Architect implementation.plan.json provided: ${storyQa.implementationPlanJson ? "yes" : "no"}
-- Architect qa.plan.json provided: ${storyQa.qaPlanJson ? "yes" : "no"}
-Materialized child tasks and evidence:
-${childLines || "- No child tasks were provided."}
-Architect final QA checks:
-${finalQa}
-This is parent Story QA: inspect the integrated Story result, all current-plan child specs/evidence, and the final worktree state. Do not treat the final child task as separately signed off.`;
-}
-function buildQaPrompt(dispatch, laneSpec) {
-    return `You are Forge's QA lane running locally in a prepared git worktree.
-
-First read and follow the injected QA lane command at .forge/work-items/${dispatch.workItem.id}/spec.md. It defines the required gated QA skill workflow for this run.
-
-Injected QA lane command and work item spec:
-${laneSpec}
-
----
-
-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."}
-
-${storyQaInstruction(dispatch)}
-Inspect the validated implementation and Forge artifacts under .forge/work-items/${dispatch.workItem.id}/artifacts/ when present, especially implementation, self-review, and validation evidence.
-${qaBrowserInstruction(dispatch)}
-${qaReworkRetestInstruction(dispatch)}
-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/routes, actions, observed results, screenshots/traces when available, console errors, failed network requests, and responsive checks. Store browser sidecars under .forge/work-items/${dispatch.workItem.id}/artifacts/qa/.
-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.
-
-${completionPromptForQaCycle()}
-
-Finish with a concise summary only after forge.complete_qa_verdict accepts the QA bundle.`;
-}
-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.`;
-}
-function buildPullRequestCommentsPrompt(dispatch, branchName) {
-    const pr = dispatch.pullRequest;
-    const targetBranch = pr?.targetBranch || dispatch.cycleRun.requestedBase || dispatch.repo.defaultBranch || "main";
-    const prLocator = pr
-        ? `PR #${pr.number}${pr.url ? ` (${pr.url})` : ""}`
-        : "the open pull request for this work item";
-    return `You are Forge's Pull Request Comments lane running locally in a prepared git worktree.
-
-The current branch is the pull request branch ${branchName}. Address unresolved review comments on ${prLocator}.
-PR context:
-- Provider: ${pr?.provider || "not provided"}
-- Source branch: ${pr?.sourceBranch || branchName}
-- Target branch: ${targetBranch}
-- Unresolved comments: ${pr?.unresolvedThreads ?? "unknown"}
-
-Use the PR URL, local git metadata, and available GitHub tooling/auth to inspect unresolved review threads. Make focused code or test changes that answer the feedback, commit the changes, and push ${branchName} to origin.
-After the push succeeds, Forge will resolve the addressed review threads through the pull request API.
-If the review thread contents are unavailable, stop with a clear summary of what could not be accessed instead of guessing.
-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 comments addressed and verification performed.`;
-}
-function isPullRequestCommentsDispatch(dispatch) {
-    return dispatch.cycleRun.kind.trim().toLowerCase() === "pr_comments";
-}
-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(() => "");
-    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 messageFromError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function clip(value, maxLength) {
-    if (value.length <= maxLength) {
-        return value;
-    }
-    return `${value.slice(0, maxLength)}...`;
-}
-function createProviderOutputState(provider) {
-    return provider.trim().toLowerCase() === "cursor"
-        ? new CursorStreamJsonState()
-        : new CodexJsonState();
-}
-class CursorStreamJsonState {
-    sessionId = null;
-    finalMessage = null;
-    emittedSession = false;
-    accumulatedUsage = null;
-    get sessionLabel() {
-        return this.sessionId ? `session ${this.sessionId}` : null;
-    }
-    get usage() {
-        return this.accumulatedUsage;
-    }
-    consume(line) {
-        const event = parseJsonLine(line);
-        if (!event) {
-            return [];
-        }
-        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 = text;
-                return [{
-                        role: "assistant",
-                        kind: "message",
-                        content: clip(text, 4000),
-                        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 = result;
-            }
-            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 [];
-    }
-    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;
-        }
-        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 [];
-        }
-        const type = stringField(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") {
-            this.accumulateUsage(event);
-            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(line.trim(), 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 = text;
-                    return [{
-                            role: "assistant",
-                            kind: "message",
-                            content: clip(text, 4000),
-                            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"
-                        }];
-                }
-            }
-        }
-        const mcpEvents = formatCodexMcpToolCallEvents(type, event);
-        if (mcpEvents.length > 0) {
-            return mcpEvents;
-        }
-        return [];
-    }
-    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 formatCodexMcpToolCallEvents(type, event) {
-    if (type !== "item.started" && type !== "item.updated" && type !== "item.completed") {
-        return [];
-    }
-    const item = objectField(event, "item");
-    const itemType = stringField(item, "type") ?? "";
-    const serverName = mcpServerName(item);
-    const toolName = mcpToolName(item);
-    const isMcpItem = itemType.toLowerCase().includes("mcp")
-        || Boolean(serverName)
-        || (toolName ? isForgeCompletionTool(toolName) || toolName.toLowerCase().includes("mcp") : false);
-    if (!isMcpItem || !toolName) {
-        return [];
-    }
-    const status = normalizedString(stringField(item, "status")
-        ?? stringField(event, "status")
-        ?? (type === "item.started" ? "started" : type === "item.completed" ? "completed" : "updated"));
-    const failed = status === "failed" || status === "error" || status === "cancelled" || Boolean(item.error);
-    const completed = failed || type === "item.completed" || status === "completed" || status === "succeeded" || status === "success";
-    const started = type === "item.started" || status === "started" || status === "running" || status === "in_progress";
-    const data = safeProviderMcpData(item, serverName ?? "unknown", toolName, status);
-    const label = `${serverName ?? "unknown"}.${toolName}`;
-    if (failed) {
-        const summary = mcpErrorSummary(item) ?? "MCP tool call failed.";
-        const events = [{
-                role: "tool",
-                kind: "error",
-                content: `MCP tool call failed: ${label} - ${summary}`,
-                eventType: "provider_mcp_call_failed",
-                data
-            }];
-        if (isForgeCompletionTool(toolName)) {
-            events.push({
-                role: "tool",
-                kind: "error",
-                content: `Forge completion tool validation failed: ${label} - ${summary}`,
-                eventType: "completion_tool_validation_failed",
-                data
-            });
-        }
-        return events;
-    }
-    if (completed) {
-        return [{
-                role: "tool",
-                kind: "checkpoint",
-                content: `MCP tool call completed: ${label}.`,
-                eventType: "provider_mcp_call_completed",
-                data
-            }];
-    }
-    if (started) {
-        return [{
-                role: "tool",
-                kind: "checkpoint",
-                content: `MCP tool call started: ${label}.`,
-                eventType: "provider_mcp_call_started",
-                data
-            }];
-    }
-    return [];
-}
-function mcpServerName(item) {
-    return stringField(item, "server")
-        ?? stringField(item, "server_name")
-        ?? stringField(item, "mcp_server")
-        ?? stringField(objectField(item, "mcp"), "server")
-        ?? stringField(objectField(item, "mcp"), "server_name");
-}
-function mcpToolName(item) {
-    return stringField(item, "tool")
-        ?? stringField(item, "tool_name")
-        ?? stringField(item, "name")
-        ?? stringField(objectField(item, "function"), "name")
-        ?? stringField(objectField(item, "mcp"), "tool")
-        ?? stringField(objectField(item, "mcp"), "tool_name");
-}
-function mcpErrorSummary(item) {
-    const direct = stringField(item, "error")
-        ?? stringField(item, "error_message")
-        ?? stringField(item, "message");
-    if (direct) {
-        return clip(direct, 600);
-    }
-    const error = objectField(item, "error");
-    return stringField(error, "message")
-        ?? stringField(error, "summary")
-        ?? stringField(objectField(item, "result"), "error")
-        ?? null;
-}
-function safeProviderMcpData(item, serverName, toolName, status) {
-    const elapsedMs = numericField(item, "elapsed_ms") ?? numericField(item, "duration_ms");
-    return JSON.stringify(stripUndefined({
-        server_name: serverName,
-        tool_name: toolName,
-        status,
-        elapsed_ms: elapsedMs,
-        error_summary: mcpErrorSummary(item)
-    }));
-}
-function isForgeCompletionTool(toolName) {
-    const normalized = toolName.trim().toLowerCase();
-    return normalized.startsWith("forge.complete_")
-        || normalized.startsWith("complete_")
-        || normalized.includes("forge.complete_")
-        || normalized.includes("complete_architect_plan");
-}
-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;
-}
-function numericField(source, key) {
-    const value = source[key];
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function stripUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}
-function normalizedString(value) {
-    return value.trim().toLowerCase().replace(/-/g, "_");
-}
-function isNodeError(error) {
-    return error instanceof Error && "code" in error;
-}