@loucompanion/forge-bridge 0.1.1-dev.f599637d804e → 0.1.3-dev.2c3feac3af65

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

@@ -1,5 +1,6 @@
 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";
@@ -8,7 +9,7 @@ import { GitClient } from "../../shared/git/git.js";
 import { resolveCursorAgentDirectLaunch } from "../../shared/cursor-agent/cursor-agent.launch.js";
 import { ensureNoSymbolicLinkPathSegments, isPathUnderRoot, sha256File } from "../qa-sidecar-validation.js";
 import { buildSpecBody, selectLaneCommand } from "../../worktree/artifact-injector.js";
-import { codexMcpConfigArgs, completionPhaseFromDispatch, completionPromptForDebugCycle, completionPromptForDevelopCycle, completionPromptForPhase, completionPromptForQaCycle, completionRedactionEnv, expectedCompletionToolName, expectedDebugCompletionToolName, expectedQaCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, usesDebugCycleCompletion, usesDevelopCycleCompletion, writeCompletionArtifact, artifactRootFor, artifactRootForOwner, debugCompletionPhaseOrder, qaCompletionGateOrder } 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);
@@ -24,15 +25,31 @@ const allowedProviderParentEnvNames = [
 ];
 const windowsAllowedProviderParentEnvNames = [
     "SystemRoot",
+    "SystemDrive",
     "ComSpec",
     "PATHEXT",
     "APPDATA",
-    "LOCALAPPDATA"
+    "LOCALAPPDATA",
+    "USERNAME",
+    "USERDOMAIN",
+    "HOMEDRIVE",
+    "HOMEPATH",
+    "ProgramData",
+    "ProgramFiles",
+    "ProgramFiles(x86)",
+    "ProgramW6432",
+    "DOTNET_ROOT",
+    "DOTNET_ROOT(x86)",
+    "DOTNET_CLI_HOME",
+    "NUGET_PACKAGES",
+    "NUGET_HTTP_CACHE_PATH"
 ];
-function buildProviderChildEnvironment(requestEnv) {
+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(process.env)) {
-        if (typeof value === "string" && isAllowedProviderParentEnv(key)) {
+    for (const [key, value] of Object.entries(parentEnv)) {
+        if (typeof value === "string" && isAllowedProviderParentEnv(key, platform)) {
             env[key] = value;
         }
     }
@@ -44,16 +61,88 @@ function buildProviderChildEnvironment(requestEnv) {
             }
         }
     }
+    if (platform === "win32") {
+        normalizeWindowsDotNetEnvironment(env, parentEnv, options.homeDir ?? os.homedir());
+    }
     return env;
 }
-function isAllowedProviderParentEnv(key) {
+function isAllowedProviderParentEnv(key, platform = process.platform) {
     return isAllowedProviderParentEnvName(key, allowedProviderParentEnvNames)
         || key.toUpperCase().startsWith("LC_")
-        || (process.platform === "win32" && isAllowedProviderParentEnvName(key, windowsAllowedProviderParentEnvNames));
+        || (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;
@@ -81,6 +170,11 @@ export class RoutingProviderCliService {
             ? 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 {
     processRunner;
@@ -89,6 +183,174 @@ 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 decomposeDraft = isDecomposeDraftDispatch(dispatch);
+        const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree: draftWorktree, phase: decomposeDraft ? "decompose" : "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: `Draft artifacts injected: ${draftArtifactSlugs.length}${draftArtifactSlugs.length ? ` (${draftArtifactSlugs.join(", ")})` : ""}. Project: ${dispatch.draft.projectName ?? dispatch.repo.name}. Repo: ${dispatch.draft.repoName ?? dispatch.repo.name}.`,
+            eventType: "draft_artifacts_injected"
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: `Starting provider CLI Draft: ${formatProviderCliCommand(command)}`,
+            eventType: "provider_cli_started"
+        });
+        await context.emit({
+            role: "runner",
+            kind: "checkpoint",
+            content: decomposeDraft
+                ? "Forge Decompose completion tools configured for decompose_subject_intake -> decompose_context_review -> decompose_breakdown_strategy -> decompose_child_items -> decompose_dependency_graph -> decompose_critic -> decompose_proposal; provider must call each MCP completion tool before exit."
+                : "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 providerCancellation = new AbortController();
+            const abortProvider = () => providerCancellation.abort();
+            if (context.signal?.aborted) {
+                abortProvider();
+            }
+            else {
+                context.signal?.addEventListener("abort", abortProvider, { once: true });
+            }
+            try {
+                const runPromise = 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);
+                        }
+                    }
+                }, providerCancellation.signal);
+                const artifactWaitCancellation = new AbortController();
+                const abortArtifactWait = () => artifactWaitCancellation.abort();
+                if (context.signal?.aborted) {
+                    abortArtifactWait();
+                }
+                else {
+                    context.signal?.addEventListener("abort", abortArtifactWait, { once: true });
+                }
+                const artifactWaitPromise = waitForCompletionArtifact(tempDir, dispatch.workItem.id, decomposeDraft ? "decompose" : "draft", artifactWaitCancellation.signal);
+                let result;
+                let earlyProposalArtifact = null;
+                try {
+                    const terminal = await Promise.race([
+                        runPromise.then(value => ({ kind: "process", value })),
+                        artifactWaitPromise.then(value => ({ kind: "artifact", value }))
+                    ]);
+                    artifactWaitCancellation.abort();
+                    await artifactWaitPromise.catch(() => undefined);
+                    if (terminal.kind === "artifact") {
+                        earlyProposalArtifact = terminal.value;
+                        providerCancellation.abort();
+                        result = await runPromise.catch(() => ({ exitCode: 0, stdout: "", stderr: "" }));
+                    }
+                    else {
+                        result = terminal.value;
+                    }
+                }
+                finally {
+                    artifactWaitCancellation.abort();
+                    context.signal?.removeEventListener("abort", abortArtifactWait);
+                }
+                if (result.exitCode !== 0 && !earlyProposalArtifact) {
+                    throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
+                }
+                await context.emit({
+                    role: "runner",
+                    kind: "checkpoint",
+                    content: `Provider CLI Draft completed: ${command.command} exit ${result.exitCode}${outputState.sessionLabel ? ` ${outputState.sessionLabel}` : ""}.`,
+                    eventType: "provider_cli_completed"
+                });
+                await emitProviderUsageEvent(context.emit, dispatch, outputState);
+                if (decomposeDraft) {
+                    await emitDecomposeGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
+                    const proposalArtifact = earlyProposalArtifact ?? await readCompletionArtifact(tempDir, dispatch.workItem.id, "decompose");
+                    if (!proposalArtifact) {
+                        throw new Error("Provider CLI Decompose completed but did not call forge.complete_decompose_proposal.");
+                    }
+                    const proposal = parseJsonLine(proposalArtifact.verdictJson) ?? {};
+                    const proposalJson = proposal["proposal_json"] ?? proposal["decomposition_json"];
+                    if (!proposalJson || typeof proposalJson !== "object" || Array.isArray(proposalJson)) {
+                        throw new Error("Provider CLI Decompose completed but decompose.proposal.json did not contain proposal_json.");
+                    }
+                    const json = JSON.stringify(proposalJson);
+                    await context.emit({
+                        role: "assistant",
+                        kind: "message",
+                        content: json,
+                        eventType: "decompose_proposal"
+                    });
+                    return {
+                        summary: "Decomposition proposal generated through Forge Decompose completion cycle.",
+                        artifact: proposalArtifact,
+                        artifacts: [proposalArtifact]
+                    };
+                }
+                await emitDraftGateArtifacts(context.emit, tempDir, dispatch.workItem.id);
+                const proposalArtifact = earlyProposalArtifact ?? 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 {
+                context.signal?.removeEventListener("abort", abortProvider);
+            }
+        }
+        finally {
+            await cleanupCompletionTools(completionTools, context.emit);
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    }
     async runImplementation(context) {
         const { dispatch, worktree } = context;
         const phase = completionPhaseFromDispatch(dispatch);
@@ -164,6 +426,15 @@ export class ProcessBackedProviderCliService {
         });
         await emitProviderUsageEvent(context.emit, dispatch, outputState);
         const committed = await commitWorktreeChanges(this.git, worktree.worktreePath, dispatch.workItem.id);
+        if (developCycle || debugCycle || phase === "implementation") {
+            await this.git.run(worktree.worktreePath, ["push", "origin", `HEAD:${worktree.branchName}`]);
+            await context.emit({
+                role: "runner",
+                kind: "checkpoint",
+                content: `Pushed ${worktree.branchName} to origin after ${phase} completion.`,
+                eventType: "worktree_branch_pushed"
+            });
+        }
         const completionArtifacts = await readCompletionArtifactsForRun(worktree.worktreePath, dispatch.workItem.id, phase, developCycle, debugCycle);
         for (const artifact of completionArtifacts) {
             if (!liveCompletionEvents.hasEmitted(completionPhaseFromArtifact(artifact))) {
@@ -204,6 +475,16 @@ export class ProcessBackedProviderCliService {
     }
     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 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, "architect");
+        const specPath = path.join(metadataRoot, "spec.md");
+        await fs.writeFile(specPath, specBody, "utf8");
+        await fs.writeFile(path.join(metadataRoot, "spec.meta.json"), JSON.stringify({ schema_version: 1, status: "pending_approval", produced_by: "forge-lane-command" }) + "\n", "utf8");
         const completionTools = await prepareCompletionToolRuntime({ dispatch, worktree, phase: "architect" });
         const command = buildProviderCliCommand(dispatch, {
             worktreePath: worktree.worktreePath,
@@ -270,15 +551,13 @@ export class ProcessBackedProviderCliService {
             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`,
+                producedBy: "forge-lane-command",
                 status: "pending_approval"
             },
             artifact: architectArtifact,
@@ -435,6 +714,17 @@ 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);
@@ -1741,6 +2031,283 @@ 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 emitDecomposeGateArtifacts(emit, worktreePath, workItemId) {
+    const decomposeArtifactFiles = {
+        decompose_subject_intake: "decompose.subject-intake.json",
+        decompose_context_review: "decompose.context-review.json",
+        decompose_breakdown_strategy: "decompose.breakdown-strategy.json",
+        decompose_child_items: "decompose.child-items.json",
+        decompose_dependency_graph: "decompose.dependency-graph.json",
+        decompose_critic: "decompose.critic.json",
+        decompose_proposal: "decompose.proposal.json"
+    };
+    const gates = Object.keys(decomposeArtifactFiles);
+    for (const gate of gates) {
+        const actualPath = path.join(worktreePath, ".forge", "work-items", workItemId, "artifacts", decomposeArtifactFiles[gate]);
+        if (!await fileExists(actualPath)) {
+            continue;
+        }
+        const relativePath = path.relative(worktreePath, actualPath).split(path.sep).join("/");
+        await emit({
+            role: "tool",
+            kind: "tool_result",
+            content: `Forge Decompose completion tool recorded ${gate} artifact ${relativePath}.`,
+            eventType: "completion_tool_artifact_recorded",
+            data: JSON.stringify({ phase: "decompose", decompose_gate: gate, artifact_relative_paths: [relativePath] })
+        });
+        await emit({
+            role: "hook",
+            kind: "checkpoint",
+            content: `phase_gate: ${gate} artifact accepted with status pass.`,
+            eventType: "phase_gate"
+        });
+        const next = gates[gates.indexOf(gate) + 1];
+        if (next) {
+            await emit({
+                role: "hook",
+                kind: "checkpoint",
+                content: `phase_progression: ${gate} -> ${next}`,
+                eventType: "phase_gate"
+            });
+        }
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildDraftPrompt(dispatch) {
+    const draft = dispatch.draft;
+    if (!draft) {
+        throw new Error("Draft prompt is missing.");
+    }
+    const decomposeDraft = isDecomposeDraftDispatch(dispatch);
+    const draftArtifacts = dispatch.artifacts
+        .filter((artifact) => artifact.scope === "operational" && ["command", "skill", "hook"].includes(artifact.kind))
+        .map((artifact) => `## ${artifact.kind}: ${artifact.slug}\n${artifact.body.trim()}`)
+        .join("\n\n");
+    const artifactSection = draftArtifacts
+        ? `\n\n# Injected Draft command/skills/hooks\n\n${draftArtifacts}`
+        : "";
+    const projectSection = [
+        draft.projectName ? `Project: ${draft.projectName}` : null,
+        draft.repoName ? `Repository: ${draft.repoName}` : null
+    ].filter(Boolean).join("\n");
+    const scopedProjectSection = projectSection ? `\n\n# Selected project context\n\n${projectSection}` : "";
+    return `${draft.systemPrompt}${scopedProjectSection}${artifactSection}
+
+Draft kind: ${draft.kind}
+
+${draft.userPrompt}
+
+${decomposeDraft
+        ? `Use the injected command/skills/hooks as lane instructions. You must call each Forge Decompose MCP completion tool in order. Do not claim Decompose is complete until forge.complete_decompose_proposal accepts the final proposal_json.
+
+Complete these gates in order: decompose_subject_intake -> decompose_context_review -> decompose_breakdown_strategy -> decompose_child_items -> decompose_dependency_graph -> decompose_critic -> decompose_proposal.
+
+The final proposal_json object must contain summary, optional blockedReason, and candidates.`
+        : `${completionPromptForDraftCycle("draft_intent")}
+
+Use the injected command/skills/hooks as lane instructions. You must call each Forge Draft MCP completion tool in order. Do not claim the Draft is complete until forge.complete_draft_proposal accepts the final draft_json.`}
+
+Do not modify source files.`;
+}
+function isDecomposeDraftKind(kind) {
+    return kind === "work_order_decomposition" || kind === "feature_decomposition";
+}
+function isDecomposeDraftDispatch(dispatch) {
+    return dispatch.execution.lane.trim().toLowerCase() === "decompose"
+        || dispatch.session.lane.trim().toLowerCase() === "decompose"
+        || isDecomposeDraftKind(dispatch.draft?.kind?.trim().toLowerCase());
+}
+function summarizeStderr(stderr) {
+    const trimmed = stderr.trim();
+    return trimmed ? `: ${clip(trimmed, 1000)}` : "";
+}
+async function waitForCompletionArtifact(worktreePath, workItemId, phase, signal) {
+    while (!signal?.aborted) {
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, phase);
+        if (artifact) {
+            return artifact;
+        }
+        await delay(1000, signal);
+    }
+    throw new Error(`${phase} proposal artifact wait was cancelled.`);
+}
+async function delay(ms, signal) {
+    if (!signal) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return;
+    }
+    const abortSignal = signal;
+    if (abortSignal.aborted) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const timeout = setTimeout(done, ms);
+        const abort = () => done();
+        function done() {
+            clearTimeout(timeout);
+            abortSignal.removeEventListener("abort", abort);
+            resolve();
+        }
+        abortSignal.addEventListener("abort", abort, { once: true });
+        if (abortSignal.aborted) {
+            done();
+        }
+    });
+}
+function deterministicDraftPayload(dispatch) {
+    const kind = dispatch.draft?.kind ?? "work_item";
+    if (kind === "work_order_decomposition") {
+        return {
+            summary: "Fake decompose proposed a Feature DAG for the Work Order.",
+            blockedReason: "",
+            candidates: [
+                {
+                    origin: "agent",
+                    key: "intake-submission",
+                    title: "Customer intake submission",
+                    summary: "Collect, validate, de-duplicate, and confirm incoming customer requests.",
+                    planningPacket: "# Customer intake submission\n\nPlan Stories for request form validation, attachment support, duplicate prevention, and submission confirmation.",
+                    sortOrder: 10,
+                    dependsOn: []
+                },
+                {
+                    origin: "agent",
+                    key: "review-queue",
+                    title: "Reviewer triage queue",
+                    summary: "Provide reviewer triage, assignment, notes, status transitions, and audit trail.",
+                    planningPacket: "# Reviewer triage queue\n\nPlan Stories for queue filtering, assignment, reviewer notes, status changes, and immutable audit trail.",
+                    sortOrder: 20,
+                    dependsOn: ["intake-submission"]
+                }
+            ]
+        };
+    }
+    if (kind === "feature_decomposition") {
+        return {
+            summary: "Fake decompose proposed a Story DAG for the Feature.",
+            blockedReason: "",
+            candidates: [
+                {
+                    origin: "agent",
+                    key: "foundation",
+                    title: "Build the feature foundation",
+                    description: "Create the persistence, API, and UI shell needed by the feature.",
+                    acceptanceCriteria: "Scenario: Foundation exists\nGiven the Feature is selected\nWhen the foundation is delivered\nThen downstream Stories can build on stable contracts",
+                    points: 3,
+                    sortOrder: 10,
+                    dependsOn: []
+                },
+                {
+                    origin: "agent",
+                    key: "workflow-behavior",
+                    title: "Implement the primary workflow behavior",
+                    description: "Implement the main user-visible behavior for the feature after the foundation is ready.",
+                    acceptanceCriteria: "Scenario: Workflow behavior works\nGiven the foundation Story is complete\nWhen the user performs the primary workflow\nThen the expected state change and feedback are visible",
+                    points: 5,
+                    sortOrder: 20,
+                    dependsOn: ["foundation"]
+                },
+                {
+                    origin: "agent",
+                    key: "audit-and-tests",
+                    title: "Add audit coverage and regression tests",
+                    description: "Add audit/evidence behavior and automated regression coverage for the feature.",
+                    acceptanceCriteria: "Scenario: Feature is verifiable\nGiven the workflow behavior is complete\nWhen validation runs\nThen audit evidence and tests cover the expected outcomes",
+                    points: 3,
+                    sortOrder: 30,
+                    dependsOn: ["workflow-behavior"]
+                }
+            ]
+        };
+    }
+    if (kind === "work_order") {
+        return {
+            title: "Deterministic runner Work Order draft",
+            summary: "Forge Runner generated this deterministic Work Order draft.",
+            objective: "Validate runner-backed Draft generation.",
+            planningPacket: "Runner-backed draft generation returned a Work Order JSON payload.",
+            decompositionContext: "Use this deterministic fixture only in bridge tests.",
+            assumptions: ["Forge Runner dispatch is available."],
+            warnings: []
+        };
+    }
+    if (kind === "story") {
+        return {
+            title: "Deterministic runner Story draft",
+            description: "Forge Runner generated this deterministic Story draft.",
+            acceptanceCriteria: "Given runner-backed Draft generation, when Forge requests a Story draft, then JSON is returned.",
+            points: 3
+        };
+    }
+    return {
+        title: "Deterministic runner Work Item draft",
+        description: "Forge Runner generated this deterministic Work Item draft.",
+        acceptanceCriteria: "Given runner-backed Draft generation, when Forge requests a draft, then JSON is returned.",
+        reproSteps: "Run Draft with a Forge Runner provider selected.",
+        systemInfo: "forge-bridge deterministic provider",
+        points: 1
+    };
+}
 export function formatProviderCliCommand(command) {
     return [command.command, ...command.args].map(singleLine).join(" ");
 }
@@ -1752,7 +2319,7 @@ export function buildProviderCliCommand(dispatch, run) {
     const normalizedProvider = provider.toLowerCase();
     const model = dispatch.execution.model.trim();
     if (normalizedProvider === "codex") {
-        const args = run ? ["-s", "workspace-write", "-a", "never", "exec"] : ["exec"];
+        const args = run ? ["-s", codexSandboxModeForPlatform(), "-a", "never", "exec"] : ["exec"];
         if (run?.completionTools) {
             args.push(...codexMcpConfigArgs(run.completionTools));
         }
@@ -1762,6 +2329,9 @@ export function buildProviderCliCommand(dispatch, run) {
             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 };
@@ -1782,6 +2352,9 @@ 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.
 
@@ -1789,6 +2362,7 @@ 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.
 
@@ -1895,18 +2469,27 @@ function phaseWorkInstruction(phase) {
 }
 function qaBrowserInstruction(dispatch) {
     const qaBrowser = dispatch.qaBrowser;
+    const qaScope = dispatch.qaScope;
     if (!qaBrowser) {
         return "Browser/app launch context: not provided by Forge.";
     }
+    const scopeAuthority = qaScope
+        ? qaScope.source === "heuristic"
+            ? "Forge's transient heuristic fallback"
+            : "persisted QA scope"
+        : "Forge heuristics";
+    const scopeEvidence = qaScope
+        ? `\n- QA scope required evidence: ${qaScope.required_evidence.length > 0 ? qaScope.required_evidence.join(", ") : "none"}\n- QA scope not applicable: ${qaScope.not_applicable.length > 0 ? qaScope.not_applicable.join(", ") : "none"}${qaScope.rationale ? `\n- QA scope rationale: ${qaScope.rationale}` : ""}`
+        : "";
     const launchTarget = qaBrowser.launchTarget;
     if (qaBrowser.required && !hasLaunchTarget(launchTarget ?? null)) {
-        return `Browser/app launch context:\n- UI/browser QA is required for this item.\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`}`;
+        return `Browser/app launch context:\n- UI/browser QA is required for this item by ${scopeAuthority}.\n- No app launch target was provided.\n- Return blocked with blocker_reason: missing_app_launch_target instead of pretending browser testing occurred.${scopeEvidence}\n- Artifact sidecars path when available: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
     }
     if (!launchTarget) {
-        return `Browser/app launch context:\n- UI/browser QA is not required by 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`}`;
+        return `Browser/app launch context:\n- UI/browser QA is not required by ${scopeAuthority} for this item.\n- If you determine browser testing is needed, return blocked with blocker_reason: missing_app_launch_target unless you can safely identify a launch target from the repo.${scopeEvidence}\n- Browser sidecars path: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
     }
     const routes = launchTarget.routes.length > 0 ? launchTarget.routes.join(", ") : "not specified";
-    return `Browser/app launch context:\n- Browser QA required: ${qaBrowser.required ? "yes" : "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`}`;
+    return `Browser/app launch context:\n- Browser QA required: ${qaBrowser.required ? `yes, by ${scopeAuthority}` : `no by ${scopeAuthority}, unless the diff/AC requires it`}\n- URL: ${launchTarget.url || "not specified"}\n- Ready URL: ${launchTarget.ready_url || "not specified"}\n- Launch command: ${launchTarget.command || "not specified"}\n- Working directory: ${launchTarget.working_directory || "repo root"}\n- Routes to cover: ${routes}\n- Notes: ${launchTarget.notes || "none"}${scopeEvidence}\n- Browser sidecars path: ${qaBrowser.artifactsPath || `.forge/work-items/${dispatch.workItem.id}/artifacts/qa`}`;
 }
 function storyQaInstruction(dispatch) {
     const storyQa = dispatch.storyQa;
@@ -2094,11 +2677,11 @@ class CursorStreamJsonState {
         if (type === "assistant") {
             const text = assistantMessageText(event);
             if (text) {
-                this.finalMessage = clip(text, 4000);
+                this.finalMessage = text;
                 return [{
                         role: "assistant",
                         kind: "message",
-                        content: this.finalMessage,
+                        content: clip(text, 4000),
                         eventType: "provider_message"
                     }];
             }
@@ -2132,7 +2715,7 @@ class CursorStreamJsonState {
         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);
         }
@@ -2313,11 +2896,11 @@ class CodexJsonState {
             if (itemType === "agent_message") {
                 const text = stringField(item, "text");
                 if (text) {
-                    this.finalMessage = clip(text, 4000);
+                    this.finalMessage = text;
                     return [{
                             role: "assistant",
                             kind: "message",
-                            content: this.finalMessage,
+                            content: clip(text, 4000),
                             eventType: "provider_message"
                         }];
                 }