@loucompanion/forge-bridge 0.1.1-dev.eee62899e922 → 0.1.3-dev.04a84914da09

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

@@ -9,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);
@@ -25,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;
         }
     }
@@ -45,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;
@@ -101,51 +189,165 @@ export class ProcessBackedProviderCliService {
             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 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);
+            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();
                 }
-            }, context.signal);
-            if (result.exitCode !== 0) {
-                throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
+                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]
+                };
             }
-            const content = outputState.finalMessage ?? result.stdout.trim();
-            if (!content) {
-                throw new Error("Provider CLI completed without returning a draft.");
+            finally {
+                context.signal?.removeEventListener("abort", abortProvider);
             }
-            const json = extractJsonObject(content);
-            await context.emit({
-                role: "assistant",
-                kind: "message",
-                content: json,
-                eventType: "draft_complete"
-            });
-            await emitProviderUsageEvent(context.emit, dispatch, outputState);
-            return {
-                summary: "Draft generated through Forge Runner."
-            };
         }
         finally {
+            await cleanupCompletionTools(completionTools, context.emit);
             await fs.rm(tempDir, { recursive: true, force: true });
         }
     }
@@ -224,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))) {
@@ -264,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,
@@ -330,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,
@@ -1812,38 +2031,255 @@ 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.");
     }
-    return `${draft.systemPrompt}
+    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}
 
-Return ONLY the requested JSON object. Do not wrap it in markdown and do not modify files.`;
+${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 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 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",
@@ -1883,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));
         }
@@ -1916,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.
 
@@ -1923,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.
 
@@ -2228,11 +2668,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"
                     }];
             }
@@ -2266,7 +2706,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);
         }
@@ -2447,11 +2887,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"
                         }];
                 }