@loucompanion/forge-bridge 0.1.1-dev.cada6731ecc7 → 0.1.1-dev.d71662695396

package/dist/session/provider-cli/provider-cli.service.d.ts

@@ -25,6 +25,12 @@ export interface ProviderProcessHandlers {
     onStdoutLine?(line: string): Promise<void> | void;
     onStderrLine?(line: string): Promise<void> | void;
 }
+interface ProviderChildEnvironmentOptions {
+    readonly parentEnv?: NodeJS.ProcessEnv;
+    readonly platform?: NodeJS.Platform;
+    readonly homeDir?: string;
+}
+export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Record<string, string>>, options?: ProviderChildEnvironmentOptions): NodeJS.ProcessEnv;
 export declare class RoutingProviderCliService implements ProviderCliService {
     private readonly realProvider;
     private readonly deterministicProvider;
@@ -67,3 +73,4 @@ export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket,
     readonly skipGitRepoCheck?: boolean;
 }): ProviderCliCommand;
 export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform): "workspace-write" | "danger-full-access";
+export {};

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,20 +189,61 @@ 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 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 Draft: ${formatProviderCliCommand(command)}`,
+            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({
+            const providerCancellation = new AbortController();
+            const abortProvider = () => providerCancellation.abort();
+            if (context.signal?.aborted) {
+                abortProvider();
+            }
+            else {
+                context.signal?.addEventListener("abort", abortProvider, { once: true });
+            }
+            const runPromise = this.processRunner.run({
                 command: command.command,
                 args: command.args,
                 cwd: tempDir,
@@ -125,27 +254,79 @@ export class ProcessBackedProviderCliService {
                         await context.emit(event);
                     }
                 }
-            }, context.signal);
-            if (result.exitCode !== 0) {
+            }, providerCancellation.signal);
+            let result;
+            let earlyProposalArtifact = null;
+            if (completionTools && !isDecomposePrompt) {
+                const terminal = await Promise.race([
+                    runPromise.then(value => ({ kind: "process", value })),
+                    waitForDraftProposalArtifact(tempDir, dispatch.workItem.id, context.signal).then(value => ({ kind: "artifact", value }))
+                ]);
+                if (terminal.kind === "artifact") {
+                    earlyProposalArtifact = terminal.value;
+                    providerCancellation.abort();
+                    result = await runPromise.catch(() => ({ exitCode: 0, stdout: "", stderr: "" }));
+                }
+                else {
+                    result = terminal.value;
+                }
+            }
+            else {
+                result = await runPromise;
+            }
+            context.signal?.removeEventListener("abort", abortProvider);
+            if (result.exitCode !== 0 && !earlyProposalArtifact) {
                 throw new Error(`Provider CLI exited with code ${result.exitCode}${summarizeStderr(result.stderr)}.`);
             }
-            const content = outputState.finalMessage ?? result.stdout.trim();
-            if (!content) {
-                throw new Error("Provider CLI completed without returning a draft.");
+            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 = 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 = extractJsonObject(content);
+            const json = JSON.stringify(draftJson);
             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."
+                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 });
         }
     }
@@ -1812,18 +1993,95 @@ 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.");
     }
-    return `${draft.systemPrompt}
+    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.`;
+${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();
@@ -1842,6 +2100,19 @@ function summarizeStderr(stderr) {
     const trimmed = stderr.trim();
     return trimmed ? `: ${clip(trimmed, 1000)}` : "";
 }
+async function waitForDraftProposalArtifact(worktreePath, workItemId, signal) {
+    while (!signal?.aborted) {
+        const artifact = await readCompletionArtifact(worktreePath, workItemId, "draft");
+        if (artifact) {
+            return artifact;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    throw new Error("Draft proposal artifact wait was cancelled.");
+}
+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") {
@@ -1926,6 +2197,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.
 
@@ -2231,11 +2503,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"
                     }];
             }
@@ -2269,7 +2541,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);
         }
@@ -2450,11 +2722,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"
                         }];
                 }

package/dist/session/session.types.d.ts

@@ -23,6 +23,8 @@ export interface DispatchDraftPrompt {
     readonly kind: string;
     readonly systemPrompt: string;
     readonly userPrompt: string;
+    readonly projectName?: string | null;
+    readonly repoName?: string | null;
 }
 export interface DispatchQaBrowserContext {
     readonly required: boolean;
@@ -224,6 +226,8 @@ export interface RunnerDispatchArtifact {
     readonly planJson?: string | null;
     readonly evidenceJson?: string | null;
     readonly findingsJson?: string | null;
+    readonly implementationPlanJson?: string | null;
+    readonly qaPlanJson?: string | null;
     readonly report: string;
     readonly producedBy: string;
     readonly status: string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const forgeBridgeVersion = "0.1.1-dev.cada6731ecc7";
+export declare const forgeBridgeVersion = "0.1.1-dev.d71662695396";

package/dist/version.js

@@ -1 +1 @@
-export const forgeBridgeVersion = "0.1.1-dev.cada6731ecc7";
+export const forgeBridgeVersion = "0.1.1-dev.d71662695396";

package/dist/worktree/artifact-injector.js

@@ -31,6 +31,24 @@ const ARCHITECT_OPERATIONAL_HOOKS = new Set([
     "architect-complete",
     "architect-revise"
 ]);
+const DRAFT_OPERATIONAL_SKILLS = new Set([
+    "draft-intent",
+    "draft-repo-context",
+    "draft-graph-context",
+    "draft-product-scope",
+    "draft-work-order-plan",
+    "draft-critic",
+    "draft-proposal"
+]);
+const DRAFT_OPERATIONAL_HOOKS = new Set([
+    "draft-intent",
+    "draft-repo-context",
+    "draft-graph-context",
+    "draft-product-scope",
+    "draft-work-order-plan",
+    "draft-critic",
+    "draft-proposal"
+]);
 export async function injectWorktreeArtifacts(worktreePath, artifacts) {
     for (const artifact of artifacts) {
         await writeArtifact(worktreePath, artifact);
@@ -45,6 +63,9 @@ export function filterArtifactsForLane(artifacts, lane, phase) {
     if (normalizedLane === "architect") {
         return artifacts.filter((artifact) => shouldInjectArchitectArtifact(artifact, commandSlug));
     }
+    if (normalizedLane === "draft") {
+        return artifacts.filter((artifact) => shouldInjectDraftArtifact(artifact, commandSlug));
+    }
     return artifacts;
 }
 export async function writeArtifact(worktreePath, artifact) {
@@ -79,6 +100,8 @@ export function resolveCommandSlug(lane, phase) {
         return "rework-prompt";
     }
     switch (normalizedLane) {
+        case "draft":
+            return "draft-prompt";
         case "architect":
             return "architect-prompt";
         case "qa":
@@ -119,6 +142,22 @@ function shouldInjectArchitectArtifact(artifact, commandSlug) {
             return false;
     }
 }
+function shouldInjectDraftArtifact(artifact, commandSlug) {
+    if (artifact.scope.trim().toLowerCase() !== "operational") {
+        return false;
+    }
+    const slug = artifact.slug.trim().toLowerCase();
+    switch (normalizedArtifactKind(artifact.kind)) {
+        case "command":
+            return slug === commandSlug;
+        case "skill":
+            return DRAFT_OPERATIONAL_SKILLS.has(slug);
+        case "hook":
+            return DRAFT_OPERATIONAL_HOOKS.has(slug);
+        default:
+            return false;
+    }
+}
 export function buildSpecBody(laneCommand, workItem, phase = "implementation") {
     const prompt = laneCommand.body.replaceAll("{workItemId}", workItem.id);
     return `---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loucompanion/forge-bridge",
-  "version": "0.1.1-dev.cada6731ecc7",
+  "version": "0.1.1-dev.d71662695396",
   "description": "Forge runner bridge CLI for connecting local developer machines to Forge dispatch.",
   "license": "UNLICENSED",
   "type": "module",