@loucompanion/forge-bridge 0.1.1-dev.32d4dd5874ee → 0.1.1-dev.440026b50fad

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

@@ -1,15 +1,148 @@
 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 { 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, completionArtifactJsonPath, completionArtifactReportPath, completionPhaseFromDispatch, completionPromptForPhase, prepareCompletionToolRuntime, readCompletionArtifact } from "../phase-completion.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;
+        }
+    }
+    if (requestEnv) {
+        for (const [key, value] of Object.entries(requestEnv)) {
+            const trimmedKey = key.trim();
+            if (trimmedKey.length > 0) {
+                env[trimmedKey] = value;
+            }
+        }
+    }
+    if (platform === "win32") {
+        normalizeWindowsDotNetEnvironment(env, parentEnv, options.homeDir ?? os.homedir());
+    }
+    return env;
+}
+function isAllowedProviderParentEnv(key, platform = process.platform) {
+    return isAllowedProviderParentEnvName(key, allowedProviderParentEnvNames)
+        || key.toUpperCase().startsWith("LC_")
+        || (platform === "win32" && isAllowedProviderParentEnvName(key, windowsAllowedProviderParentEnvNames));
+}
+function isAllowedProviderParentEnvName(key, allowedNames) {
+    return allowedNames.some((allowed) => allowed.toLowerCase() === key.toLowerCase());
+}
+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)) || "\\");
+        }
+    }
+    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);
+    }
+    if (localAppData) {
+        setEnvironmentValueIfMissing(env, "LOCALAPPDATA", localAppData);
+        setEnvironmentValueIfMissing(env, "NUGET_HTTP_CACHE_PATH", path.win32.join(localAppData, "NuGet", "v3-cache"));
+    }
+    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;
+    }
+    const homeDrive = readEnvironmentValue(env, "HOMEDRIVE") ?? readEnvironmentValue(parentEnv, "HOMEDRIVE");
+    const homePath = readEnvironmentValue(env, "HOMEPATH") ?? readEnvironmentValue(parentEnv, "HOMEPATH");
+    if (homeDrive && homePath) {
+        return `${homeDrive}${homePath}`;
+    }
+    if (homeDir && path.win32.isAbsolute(homeDir)) {
+        return homeDir;
+    }
+    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;
+    }
+    env[name] = value;
+}
 export class RoutingProviderCliService {
     realProvider;
     deterministicProvider;
@@ -22,15 +155,25 @@ export class RoutingProviderCliService {
             ? await this.deterministicProvider.runImplementation(context)
             : await this.realProvider.runImplementation(context);
     }
+    async runArchitect(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runArchitect(context)
+            : await this.realProvider.runArchitect(context);
+    }
     async runConflictResolve(context) {
         return isFakeWorkerModel(context.dispatch.execution.model)
             ? await this.deterministicProvider.runConflictResolve(context)
             : await this.realProvider.runConflictResolve(context);
     }
-    async runQa(dispatch, emit, signal) {
-        return isFakeWorkerModel(dispatch.execution.model)
-            ? await this.deterministicProvider.runQa(dispatch, emit, signal)
-            : await this.realProvider.runQa(dispatch, emit, signal);
+    async runQa(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runQa(context)
+            : await this.realProvider.runQa(context);
+    }
+    async runDraft(context) {
+        return isFakeWorkerModel(context.dispatch.execution.model)
+            ? await this.deterministicProvider.runDraft(context)
+            : await this.realProvider.runDraft(context);
     }
 }
 export class ProcessBackedProviderCliService {
@@ -40,9 +183,130 @@ export class ProcessBackedProviderCliService {
         this.processRunner = processRunner;
         this.git = git;
     }
+    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);
+        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, "spec.md"), buildDraftSpec(dispatch), "utf8");
+        const isDecomposePrompt = isDecomposeDraftKind(dispatch.draft.kind);
+        const completionTools = isDecomposePrompt
+            ? null
+            : await prepareCompletionToolRuntime({ dispatch, worktree: draftWorktree, phase: "draft" });
+        const command = buildProviderCliCommand(dispatch, {
+            worktreePath: tempDir,
+            prompt: buildDraftPrompt(dispatch),
+            completionTools: completionTools ?? undefined,
+            skipGitRepoCheck: true
+        });
+        const draftArtifactSlugs = dispatch.artifacts
+            .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
+            .map((artifact) => `${artifact.kind}:${artifact.slug}`);
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `${isDecomposePrompt ? "Structured prompt" : "Draft"} artifacts injected: ${draftArtifactSlugs.length}${draftArtifactSlugs.length ? ` (${draftArtifactSlugs.join(", ")})` : ""}. Project: ${dispatch.draft.projectName ?? dispatch.repo.name}. Repo: ${dispatch.draft.repoName ?? dispatch.repo.name}.`,
+            eventType: isDecomposePrompt ? "structured_prompt_artifacts_injected" : "draft_artifacts_injected"
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Starting provider CLI ${isDecomposePrompt ? "structured prompt" : "Draft"}: ${formatProviderCliCommand(command)}`,
+            eventType: "provider_cli_started"
+        });
+        if (completionTools) {
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: "Forge Draft completion tools configured for draft_intent -> draft_repo_context -> draft_graph_context -> draft_product_scope -> draft_work_order_plan -> draft_critic -> draft_proposal; provider must call each MCP completion tool before exit.",
+                eventType: "completion_tools_configured"
+            });
+        }
+        const outputState = createProviderOutputState(dispatch.execution.provider);
+        try {
+            const result = await this.processRunner.run({
+                command: command.command,
+                args: command.args,
+                cwd: tempDir,
+                env: providerProcessEnv(dispatch)
+            }, {
+                onStdoutLine: async (line) => {
+                    for (const event of outputState.consume(line)) {
+                        await context.emit(event);
+                    }
+                }
+            }, context.signal);
+            if (result.exitCode !== 0) {
+                throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
+            }
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: `Provider CLI ${isDecomposePrompt ? "structured prompt" : "Draft"} completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
+                eventType: "provider_cli_completed"
+            });
+            await emitProviderUsageEvent(context.emit, dispatch, outputState);
+            if (isDecomposePrompt) {
+                const structuredJson = parseJsonLine(outputState.finalMessage ?? "");
+                if (!structuredJson || typeof structuredJson !== "object" || Array.isArray(structuredJson)) {
+                    throw new Error("Provider CLI structured prompt completed but did not return a JSON object.");
+                }
+                await context.emit({
+                    role: "assistant",
+                    kind: "message",
+                    content: JSON.stringify(structuredJson),
+                    eventType: "draft_complete"
+                });
+                return {
+                    summary: "Structured prompt generated JSON through provider CLI."
+                };
+            }
+            await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
+            const proposalArtifact = await readCompletionArtifact(tempDir, dispatch.workItem.id, "draft");
+            if (!proposalArtifact) {
+                throw new Error("Provider CLI Draft completed but did not call forge.complete_draft_proposal.");
+            }
+            const proposal = parseJsonLine(proposalArtifact.verdictJson) ?? {};
+            const draftJson = proposal["draft_json"];
+            if (!draftJson || typeof draftJson !== "object" || Array.isArray(draftJson)) {
+                throw new Error("Provider CLI Draft completed but draft.proposal.json did not contain draft_json.");
+            }
+            const json = JSON.stringify(draftJson);
+            await context.emit({
+                role: "assistant",
+                kind: "message",
+                content: json,
+                eventType: "draft_complete"
+            });
+            return {
+                summary: "Draft generated through Forge Draft completion cycle.",
+                artifact: proposalArtifact,
+                artifacts: [proposalArtifact]
+            };
+        }
+        finally {
+            if (completionTools) {
+                await cleanupCompletionTools(completionTools, context.emit);
+            }
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    }
     async runImplementation(context) {
         const { dispatch, worktree } = context;
         const phase = completionPhaseFromDispatch(dispatch);
+        const developCycle = usesDevelopCycleCompletion(dispatch);
+        const debugCycle = usesDebugCycleCompletion(dispatch);
         const metadataRoot = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id);
         await fs.mkdir(metadataRoot, { recursive: true });
         const laneCommand = selectLaneCommand(dispatch.artifacts, dispatch.execution.lane, dispatch.cycleRun.phase);
@@ -56,7 +320,11 @@ export class ProcessBackedProviderCliService {
         const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildImplementationPrompt(dispatch, phase),
+            prompt: debugCycle
+                ? buildDebugCyclePrompt(dispatch, phase)
+                : developCycle
+                    ? buildDevelopCyclePrompt(dispatch, phase)
+                    : buildImplementationPrompt(dispatch, phase),
             completionTools
         });
         await context.emit({
@@ -68,26 +336,33 @@ export class ProcessBackedProviderCliService {
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Forge completion tools configured for ${phase}; provider must call the MCP completion tool before exit.`,
+            content: debugCycle
+                ? "Forge Debug completion tools configured for debug_repro -> debug_root_cause -> debug_fix -> debug_regression; provider must call each MCP completion tool before exit."
+                : developCycle
+                    ? "Forge completion tools configured for implementation -> self_review -> validation; provider must call each MCP completion tool before exit."
+                    : `Forge completion tools configured for ${phase}; provider must call the MCP completion tool before exit.`,
             eventType: "completion_tools_configured"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
+        const liveCompletionEvents = new LiveCompletionArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, phase, developCycle, debugCycle, context.emit);
         let result;
         try {
+            liveCompletionEvents.start();
             result = await this.processRunner.run({
                 command: command.command,
                 args: command.args,
-                cwd: worktree.worktreePath
+                cwd: worktree.worktreePath,
+                env: providerProcessEnv(dispatch)
             }, {
                 onStdoutLine: async (line) => {
-                    const event = outputState.consume(line);
-                    if (event) {
+                    for (const event of outputState.consume(line)) {
                         await context.emit(event);
                     }
                 }
             }, context.signal);
         }
         finally {
+            await liveCompletionEvents.stop();
             await cleanupCompletionTools(completionTools, context.emit);
         }
         if (result.exitCode !== 0) {
@@ -100,17 +375,23 @@ export class ProcessBackedProviderCliService {
             content: `Provider CLI completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
             eventType: "provider_cli_completed"
         });
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
-        const completionArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, phase);
-        if (!completionArtifact) {
-            throw new Error(`Provider CLI completed but did not call the Forge ${phase} completion tool.`);
+        const completionArtifacts = await readCompletionArtifactsForRun(worktree.worktreePath, dispatch.workItem.id, phase, developCycle, debugCycle);
+        for (const artifact of completionArtifacts) {
+            if (!liveCompletionEvents.hasEmitted(completionPhaseFromArtifact(artifact))) {
+                await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, artifact);
+                await emitPhaseCompletionEvent(context.emit, artifact);
+                await emitPhaseGateEvents(context.emit, artifact);
+            }
         }
+        const completionArtifact = completionArtifacts[0];
         if (outputState.finalMessage) {
             await context.emit({
                 role: "assistant",
                 kind: "message",
                 content: outputState.finalMessage,
-                eventType: "implementation_complete"
+                eventType: "provider_final_message"
             });
         }
         else {
@@ -118,11 +399,11 @@ export class ProcessBackedProviderCliService {
                 role: "assistant",
                 kind: "message",
                 content: `${dispatch.execution.provider} CLI completed for ${worktree.branchName}.`,
-                eventType: "implementation_complete"
+                eventType: "provider_final_message"
             });
         }
         return {
-            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName} (${phase}, ${committed.commitSha.slice(0, 12)}).`,
+            summary: `${dispatch.execution.provider} CLI completed ${worktree.branchName} (${debugCycle ? "debug cycle" : developCycle ? "develop cycle" : phase}, ${committed.commitSha.slice(0, 12)}).`,
             spec: {
                 repoPath: worktree.worktreePath,
                 path: specPath,
@@ -130,67 +411,212 @@ export class ProcessBackedProviderCliService {
                 producedBy: "forge-lane-command",
                 status: "approved"
             },
-            artifact: completionArtifact
+            artifact: completionArtifact,
+            artifacts: completionArtifacts
         };
     }
-    async runQa(dispatch, emit, signal) {
+    async runArchitect(context) {
+        const { dispatch, worktree } = context;
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "architect" });
         const command = buildProviderCliCommand(dispatch, {
-            prompt: buildQaPrompt(dispatch)
+            worktreePath: worktree.worktreePath,
+            prompt: buildArchitectPrompt(dispatch),
+            completionTools
         });
-        await emit({
+        const commandText = formatProviderCliCommand(command);
+        await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI QA: ${formatProviderCliCommand(command)}`,
+            content: `Starting provider CLI Architect: ${commandText} in ${worktree.worktreePath}`,
             eventType: "provider_cli_started"
         });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: "Forge Architect completion tools configured; provider must call forge.complete_architect_plan before exit.",
+            eventType: "completion_tools_configured"
+        });
         const outputState = createProviderOutputState(dispatch.execution.provider);
-        const result = await this.processRunner.run({
-            command: command.command,
-            args: command.args,
-            cwd: process.cwd()
-        }, {
-            onStdoutLine: async (line) => {
-                const event = outputState.consume(line);
-                if (event) {
-                    await emit(event);
+        const liveArchitectEvents = new LiveArchitectArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, context.emit);
+        let result;
+        try {
+            liveArchitectEvents.start();
+            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);
+                    }
                 }
-            }
-        }, signal);
+            }, context.signal);
+        }
+        finally {
+            await liveArchitectEvents.stop();
+            await cleanupCompletionTools(completionTools, context.emit);
+        }
         if (result.exitCode !== 0) {
             const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
             throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
         }
-        await emit({
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Provider CLI Architect completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
+            eventType: "provider_cli_completed"
+        });
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
+        const architectArtifact = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "architect");
+        if (!architectArtifact) {
+            throw new Error("Provider CLI Architect completed but did not call the Forge Architect completion tool.");
+        }
+        if (!liveArchitectEvents.hasEmitted()) {
+            await emitCompletionArtifactRecorded(context.emit, worktree.worktreePath, architectArtifact);
+            await emitArchitectStructuredEvents(context.emit, worktree.worktreePath, dispatch.workItem.id, architectArtifact);
+        }
+        await context.emit({
+            role: "assistant",
+            kind: "message",
+            content: outputState.finalMessage || `${dispatch.execution.provider} CLI produced an Architect plan for ${worktree.branchName}.`,
+            eventType: "architect_complete"
+        });
+        const specPath = path.join(worktree.worktreePath, ".forge", "work-items", dispatch.workItem.id, "spec.md");
+        const specBody = await fs.readFile(specPath, "utf8").catch(() => `# ${dispatch.workItem.title}\n\nArchitect plan pending approval.\n`);
+        return {
+            summary: `${dispatch.execution.provider} CLI Architect plan produced.`,
+            spec: {
+                repoPath: worktree.worktreePath,
+                path: specPath,
+                body: specBody,
+                producedBy: `${dispatch.execution.provider}-cli`,
+                status: "pending_approval"
+            },
+            artifact: architectArtifact,
+            artifacts: [architectArtifact]
+        };
+    }
+    async runQa(context) {
+        const { dispatch, worktree } = context;
+        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(`Lane command for lane '${dispatch.execution.lane}' phase '${dispatch.cycleRun.phase}' was not resolved.`);
+        }
+        const specBody = buildSpecBody(laneCommand, dispatch.workItem, "qa");
+        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 command = buildProviderCliCommand(dispatch, {
+            worktreePath: worktree.worktreePath,
+            prompt: buildQaPrompt(dispatch, specBody),
+            completionTools
+        });
+        const commandText = formatProviderCliCommand(command);
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Starting provider CLI QA: ${commandText} in ${worktree.worktreePath}`,
+            eventType: "provider_cli_started"
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: "Forge QA completion tools configured; provider must call all seven QA MCP gates before exit.",
+            eventType: "completion_tools_configured"
+        });
+        const outputState = createProviderOutputState(dispatch.execution.provider);
+        const liveQaEvents = new LiveQaArtifactEmitter(worktree.worktreePath, dispatch.workItem.id, dispatch, context.emit);
+        let result;
+        try {
+            liveQaEvents.start();
+            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);
+                    }
+                }
+            }, context.signal);
+        }
+        finally {
+            await liveQaEvents.stop();
+            await cleanupCompletionTools(completionTools, context.emit);
+        }
+        if (result.exitCode !== 0) {
+            const stderr = clip(result.stderr.trim() || result.stdout.trim(), 1200);
+            throw new Error(`${command.command} exited ${result.exitCode}${stderr ? `: ${stderr}` : ""}`);
+        }
+        await context.emit({
             role: "runner",
             kind: "checkpoint",
             content: `Provider CLI QA completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
             eventType: "provider_cli_completed"
         });
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
+        const qaArtifact = await readQaCompletionArtifactBundle(worktree.worktreePath, dispatch.workItem.id, dispatch.cycleRun.ownerType, dispatch.cycleRun.ownerId);
+        if (!qaArtifact) {
+            const verdictOnly = await readCompletionArtifact(worktree.worktreePath, dispatch.workItem.id, "qa");
+            throw new Error(verdictOnly
+                ? "Provider CLI QA completed but did not produce the complete durable QA artifact bundle."
+                : "Provider CLI QA completed but did not call the Forge QA completion tool.");
+        }
+        enforceQaBrowserLaunchTargetGate(dispatch, qaArtifact);
+        if (!liveQaEvents.hasEmitted()) {
+            await emitQaArtifactRecorded(context.emit, worktree.worktreePath, qaArtifact);
+            await emitQaStructuredEvents(context.emit, qaArtifact);
+        }
+        const status = (qaArtifact.status ?? "unknown").trim().toLowerCase();
+        const statusSummary = status === "pass"
+            ? "passed"
+            : status === "blocked"
+                ? "blocked"
+                : "found rework";
         return {
-            summary: `${dispatch.execution.provider} CLI QA passed.`
+            summary: `${dispatch.execution.provider} CLI QA ${statusSummary}.`,
+            spec: {
+                repoPath: worktree.worktreePath,
+                path: specPath,
+                body: specBody,
+                producedBy: "forge-lane-command",
+                status: "approved"
+            },
+            artifact: qaArtifact,
+            artifacts: [qaArtifact]
         };
     }
     async runConflictResolve(context) {
         const { dispatch, worktree } = context;
+        const addressComments = isPullRequestCommentsDispatch(dispatch);
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
-            prompt: buildConflictResolvePrompt(dispatch, worktree.branchName)
+            prompt: addressComments
+                ? buildPullRequestCommentsPrompt(dispatch, worktree.branchName)
+                : buildConflictResolvePrompt(dispatch, worktree.branchName)
         });
         await context.emit({
             role: "runner",
             kind: "checkpoint",
-            content: `Starting provider CLI conflict resolve: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
+            content: `Starting provider CLI ${addressComments ? "PR comment address" : "conflict resolve"}: ${formatProviderCliCommand(command)} in ${worktree.worktreePath}`,
             eventType: "provider_cli_started"
         });
         const outputState = createProviderOutputState(dispatch.execution.provider);
         const result = await this.processRunner.run({
             command: command.command,
             args: command.args,
-            cwd: worktree.worktreePath
+            cwd: worktree.worktreePath,
+            env: providerProcessEnv(dispatch)
         }, {
             onStdoutLine: async (line) => {
-                const event = outputState.consume(line);
-                if (event) {
+                for (const event of outputState.consume(line)) {
                     await context.emit(event);
                 }
             }
@@ -201,14 +627,19 @@ export class ProcessBackedProviderCliService {
         }
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
         await this.git.run(worktree.worktreePath, ["push", "origin", `HEAD:${worktree.branchName}`]);
+        await emitProviderUsageEvent(context.emit, dispatch, outputState);
         await context.emit({
             role: "assistant",
             kind: "message",
-            content: outputState.finalMessage || `${dispatch.execution.provider} CLI resolved merge conflicts for ${worktree.branchName}.`,
-            eventType: "conflict_resolve_complete"
+            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: `${dispatch.execution.provider} CLI resolved conflicts on ${worktree.branchName} (${committed.commitSha.slice(0, 12)}).`
+            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)}).`
         };
     }
 }
@@ -217,9 +648,22 @@ export class DeterministicProviderCliService {
     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);
@@ -229,117 +673,1147 @@ export class DeterministicProviderCliService {
         if (!laneCommand) {
             throw new Error(`Lane command for lane '${dispatch.execution.lane}' phase '${dispatch.cycleRun.phase}' was not resolved.`);
         }
-        const specBody = `${buildSpecBody(laneCommand, dispatch.workItem, 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 verdict = {
-            schema_version: 1,
-            phase: "implementation",
-            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: dispatch.workItem.acceptanceCriteria || "Deterministic bridge changeset exists",
-                    evidence: `FORGE_PHASE5_CHANGESET.md was committed with content hash ${sha256(changesetBody)}.`,
-                    status: "satisfied"
-                }
-            ],
-            known_gaps: [],
-            next_phase_context: "Review FORGE_PHASE5_CHANGESET.md and the bridge commit before validation.",
-            produced_by: "forge-bridge",
-            content_hash: sha256(changesetBody)
-        };
-        const verdictJson = JSON.stringify(verdict);
-        const report = `# Implementation report\n\nforge-bridge prepared \`${worktree.branchName}\` and created \`${changesetPath}\`.\n`;
-        const artifactPath = completionArtifactJsonPath(worktree.worktreePath, dispatch.workItem.id, "implementation");
-        const reportPath = completionArtifactReportPath(worktree.worktreePath, dispatch.workItem.id, "implementation");
-        await fs.writeFile(artifactPath, verdictJson + "\n", "utf8");
-        await fs.writeFile(reportPath, report, "utf8");
-        await context.emit({
-            role: "assistant",
-            kind: "message",
-            content: "Implementation complete. forge-bridge produced deterministic phase artifacts.",
-            eventType: "implementation_complete"
-        });
-        return {
-            summary: `forge-bridge completed ${worktree.branchName}.`,
-            spec: {
-                repoPath: worktree.worktreePath,
-                path: specPath,
-                body: specBody,
-                producedBy: "forge-lane-command",
-                status: "approved"
-            },
-            artifact: {
-                repoPath: worktree.worktreePath,
-                path: artifactPath,
-                verdictJson,
-                report,
-                producedBy: "forge-bridge",
-                status: "pass",
-                phase: "implementation"
+        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.`);
+            }
+            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));
+            }
+        }
+        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.");
+        }
+        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 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"
+        });
+        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: []
+        };
+    }
+    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."
+        }
+        : 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;
+        }
     }
-    async runQa(dispatch, emit) {
-        await emit({
-            role: "worker",
-            kind: "message",
-            content: `Running ${dispatch.execution.provider} QA checks through forge-bridge.`,
-            eventType: "qa_analysis"
-        });
-        await emit({
-            role: "assistant",
-            kind: "message",
-            content: "All checks passed. forge-bridge QA completed.",
-            eventType: "qa_complete"
-        });
-        return {
-            summary: "forge-bridge QA passed."
-        };
+    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 {};
     }
-    async runConflictResolve(context) {
-        const { dispatch, worktree } = context;
-        await this.git.run(worktree.worktreePath, ["commit", "--allow-empty", "-m", `forge bridge conflict resolve for ${dispatch.workItem.id.slice(0, 8)}`]);
-        await context.emit({
-            role: "assistant",
-            kind: "message",
-            content: `Deterministic conflict resolve completed for ${worktree.branchName}.`,
-            eventType: "conflict_resolve_complete"
-        });
-        return {
-            summary: `forge-bridge resolved conflicts for ${worktree.branchName}.`
-        };
+    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
             });
@@ -474,9 +1948,6 @@ function quoteWindowsCommandLineArg(value) {
     }
     return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
 }
-async function fileExists(inputPath) {
-    return fs.stat(inputPath).then((stat) => stat.isFile()).catch(() => false);
-}
 async function readProcessLines(stream, onLine) {
     const reader = readline.createInterface({ input: stream });
     try {
@@ -494,12 +1965,149 @@ function isFakeWorkerModel(model) {
 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 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 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}
+
+${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 extractJsonObject(content) {
+    let trimmed = content.trim();
+    if (trimmed.startsWith("```")) {
+        const firstNewline = trimmed.indexOf("\n");
+        const lastFence = trimmed.lastIndexOf("```");
+        if (firstNewline >= 0 && lastFence > firstNewline) {
+            trimmed = trimmed.slice(firstNewline + 1, lastFence).trim();
+        }
+    }
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    return start >= 0 && end >= start ? trimmed.slice(start, end + 1) : trimmed;
+}
+function summarizeStderr(stderr) {
+    const trimmed = stderr.trim();
+    return trimmed ? `: ${clip(trimmed, 1000)}` : "";
+}
+function isDecomposeDraftKind(kind) {
+    return kind === "work_order_decomposition" || kind === "feature_decomposition";
+}
+function deterministicDraftPayload(dispatch) {
+    const kind = dispatch.draft?.kind ?? "work_item";
+    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 yamlQuotedScalar(value) {
-    return JSON.stringify(singleLine(value));
-}
 function singleLine(value) {
     return value.replace(/\s+/g, " ").trim();
 }
@@ -508,16 +2116,19 @@ export function buildProviderCliCommand(dispatch, run) {
     const normalizedProvider = provider.toLowerCase();
     const model = dispatch.execution.model.trim();
     if (normalizedProvider === "codex") {
-        const args = ["exec"];
+        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", "--dangerously-bypass-approvals-and-sandbox");
+            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 };
@@ -538,11 +2149,41 @@ export function buildProviderCliCommand(dispatch, run) {
     }
     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.
@@ -551,20 +2192,162 @@ ${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 Dev Test.";
+        return "Run the validation commands and deterministic drift checks needed to prove the work is ready for QA.";
     }
     return "Implement the work item and keep the change focused.";
 }
-function buildQaPrompt(dispatch) {
-    return `You are Forge's QA lane running locally.
+function qaBrowserInstruction(dispatch) {
+    const qaBrowser = dispatch.qaBrowser;
+    if (!qaBrowser) {
+        return "Browser/app launch context: not provided by Forge.";
+    }
+    const launchTarget = qaBrowser.launchTarget;
+    if (qaBrowser.required && !hasLaunchTarget(launchTarget ?? null)) {
+        return `Browser/app launch context:\n- UI/browser QA is required for this item.\n- No app launch target was provided.\n- Return blocked with blocker_reason: missing_app_launch_target instead of pretending browser testing occurred.\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 Forge heuristics 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.\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" : "no, 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"}\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.
 
-Review the implementation for work item ${dispatch.workItem.id}: ${dispatch.workItem.title}
-Run relevant verification when practical and finish with a concise QA verdict.`;
+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";
@@ -579,6 +2362,34 @@ Keep the original work item intent intact:
 
 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();
@@ -626,37 +2437,41 @@ 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 null;
+            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"
-                };
+                return [{
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: `Cursor session started: ${this.sessionId}.`,
+                        eventType: "provider_thread_started"
+                    }];
             }
         }
         if (type === "assistant") {
             const text = assistantMessageText(event);
             if (text) {
-                this.finalMessage = clip(text, 4000);
-                return {
-                    role: "assistant",
-                    kind: "message",
-                    content: this.finalMessage,
-                    eventType: "provider_message"
-                };
+                this.finalMessage = text;
+                return [{
+                        role: "assistant",
+                        kind: "message",
+                        content: clip(text, 4000),
+                        eventType: "provider_message"
+                    }];
             }
         }
         if (type === "tool_call") {
@@ -665,41 +2480,57 @@ class CursorStreamJsonState {
             if (subtype === "started") {
                 const summary = formatCursorToolCallStarted(toolCall);
                 if (summary) {
-                    return {
-                        role: "worker",
-                        kind: "checkpoint",
-                        content: summary,
-                        eventType: "provider_tool_call"
-                    };
+                    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"
-                    };
+                    return [{
+                            role: "worker",
+                            kind: completed.kind,
+                            content: completed.content,
+                            eventType: completed.kind === "file_edit" ? "provider_file_edit" : "provider_tool_call"
+                        }];
                 }
             }
         }
         if (type === "result" && stringField(event, "subtype") === "success") {
             const result = stringField(event, "result");
             if (result) {
-                this.finalMessage = clip(result, 4000);
+                this.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 [{
+                    role: "runner",
+                    kind: "error",
+                    content: clip(line.trim(), 1000),
+                    eventType: "provider_cli_error"
+                }];
         }
-        return null;
+        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) {
@@ -805,42 +2636,47 @@ class CodexJsonState {
     threadId = null;
     finalMessage = null;
     emittedThread = false;
+    accumulatedUsage = null;
     get sessionLabel() {
         return this.threadId ? `thread ${this.threadId}` : null;
     }
+    get usage() {
+        return this.accumulatedUsage;
+    }
     consume(line) {
         const event = parseJsonLine(line);
         if (!event) {
-            return null;
+            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"
-                };
+                return [{
+                        role: "runner",
+                        kind: "checkpoint",
+                        content: `Codex thread started: ${this.threadId}.`,
+                        eventType: "provider_thread_started"
+                    }];
             }
         }
         if (type === "turn.completed") {
-            return {
-                role: "runner",
-                kind: "checkpoint",
-                content: "Codex turn completed.",
-                eventType: "provider_turn_completed"
-            };
+            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"
-            };
+            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");
@@ -848,30 +2684,154 @@ class CodexJsonState {
             if (itemType === "agent_message") {
                 const text = stringField(item, "text");
                 if (text) {
-                    this.finalMessage = clip(text, 4000);
-                    return {
-                        role: "assistant",
-                        kind: "message",
-                        content: this.finalMessage,
-                        eventType: "provider_message"
-                    };
+                    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"
-                    };
+                    return [{
+                            role: "worker",
+                            kind: "checkpoint",
+                            content: `Codex command ${status || "completed"}: ${clip(command, 500)}`,
+                            eventType: "provider_command"
+                        }];
                 }
             }
         }
-        return null;
+        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];
@@ -883,3 +2843,16 @@ 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;
+}