@loucompanion/forge-bridge 0.1.3-dev.f2b8822ce953 → 0.1.3-dev.fbe15023cdfe

package/dist/session/phase-completion.helpers.js

@@ -85,6 +85,9 @@ export function parseStrictCompletionPhase(value) {
     if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
         return "decompose";
     }
+    if (normalized === "ci_repair" || normalized === "pr_checks" || normalized === "repair_pr_checks") {
+        return "ci_repair";
+    }
     return null;
 }
 export function normalizeDebugCompletionPhase(value) {
@@ -156,6 +159,9 @@ export function phaseFromToolName(toolName) {
     if (normalized === "forge.complete_architect_plan" || normalized === "complete_architect_plan") {
         return "architect";
     }
+    if (normalized === "forge.complete_ci_repair" || normalized === "complete_ci_repair") {
+        return "ci_repair";
+    }
     if (draftGateFromToolName(toolName)) {
         return "draft";
     }
@@ -600,9 +606,22 @@ export async function readOptionalFile(filePath) {
 }
 export async function writeFileAtomic(filePath, content) {
     await fs.mkdir(path.dirname(filePath), { recursive: true });
-    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
     await fs.writeFile(tempPath, content, "utf8");
-    await fs.rename(tempPath, filePath);
+    try {
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        if (process.platform !== "win32" || !isNodeError(error) || (error.code !== "EPERM" && error.code !== "EEXIST")) {
+            await fs.rm(tempPath, { force: true });
+            throw error;
+        }
+        // Windows rename does not reliably replace an existing destination. QA-cycle gates
+        // intentionally refresh canonical bundle files, so remove only the exact destination
+        // after the replacement temp file is durable, then complete the rename.
+        await fs.rm(filePath, { force: true });
+        await fs.rename(tempPath, filePath);
+    }
 }
 export function stableStringify(value) {
     return JSON.stringify(sortJson(value));
@@ -626,7 +645,12 @@ export function forgeBridgeCliBinPath() {
     return fileURLToPath(new URL("../cli/bin.js", import.meta.url));
 }
 export function tomlString(value) {
-    return JSON.stringify(value);
+    if (value.includes("'''")) {
+        throw new Error("Codex MCP configuration values cannot contain three consecutive apostrophes.");
+    }
+    // Codex config overrides pass through npm's PowerShell shim on Windows.
+    // Literal TOML strings survive that boundary; basic-string double quotes do not.
+    return `'''${value}'''`;
 }
 export function tomlStringArray(values) {
     return `[${values.map(tomlString).join(", ")}]`;

package/dist/session/phase-completion.js

@@ -195,6 +195,10 @@ export const phaseFiles = {
     decompose: {
         jsonFileName: "decompose.proposal.json",
         reportFileName: "decompose.report.md"
+    },
+    ci_repair: {
+        jsonFileName: "ci-repair.handoff.json",
+        reportFileName: "ci-repair.report.md"
     }
 };
 export function completionPhaseFromDispatch(dispatch) {
@@ -224,6 +228,9 @@ export function normalizeCompletionPhase(value) {
     if (normalized === "decompose" || normalized === "decomposition" || normalized === "work_order_decomposition" || normalized === "feature_decomposition") {
         return "decompose";
     }
+    if (normalized === "ci_repair" || normalized === "pr_checks" || normalized === "repair_pr_checks") {
+        return "ci_repair";
+    }
     return "implementation";
 }
 export function usesDevelopCycleCompletion(dispatch) {
@@ -275,9 +282,11 @@ export function completionToolNamesForPhase(phase) {
             ? "complete_self_review"
             : phase === "validation"
                 ? "complete_validation"
-                : phase === "architect"
-                    ? "complete_architect_plan"
-                    : "complete_qa";
+                : phase === "ci_repair"
+                    ? "complete_ci_repair"
+                    : phase === "architect"
+                        ? "complete_architect_plan"
+                        : "complete_qa";
     return [`forge.${base}`, base];
 }
 export function completionToolNamesForQaGate(gate) {

package/dist/session/phase-completion.prompts.d.ts

@@ -1,13 +1,13 @@
 import { type CompletionPhase, type DebugCompletionPhase, type DecomposeCompletionGate, type DevelopCompletionPhase, type DraftCompletionGate, type QaCompletionGate } from "./phase-completion.js";
-export declare function completionPromptForPhase(phase: CompletionPhase): string;
+export declare function completionPromptForPhase(phase: CompletionPhase, artifactRoot?: string): string;
 export declare function completionPromptForDevelopCycle(phase: CompletionPhase): string;
-export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate): string;
+export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate, artifactRoot?: string): string;
 export declare function completionPromptForDraftCycle(currentGate?: DraftCompletionGate): string;
 export declare function completionPromptForDecomposeCycle(currentGate?: DecomposeCompletionGate): string;
 export declare function completionPromptForDebugCycle(currentGate?: DebugCompletionPhase): string;
 export declare function nextPhaseAfter(phase: CompletionPhase): DevelopCompletionPhase | null;
 export declare function nextDebugPhaseAfter(phase: DebugCompletionPhase): DebugCompletionPhase | null;
-export declare function completionToolNextInstruction(completedPhase: CompletionPhase, status: string, nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready"): string;
+export declare function completionToolNextInstruction(completedPhase: CompletionPhase, status: string, nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready" | "provider_checks_ready"): string;
 export declare function completionToolNextInstructionForDraftGate(completedGate: DraftCompletionGate, status: string, nextGate: DraftCompletionGate | null): string;
 export declare function completionToolNextInstructionForQaGate(completedGate: QaCompletionGate, status: string, nextGate: QaCompletionGate | null): string;
 export declare function completionToolNextInstructionForDecomposeGate(completedGate: DecomposeCompletionGate, status: string, nextGate: DecomposeCompletionGate | null): string;

package/dist/session/phase-completion.prompts.js

@@ -1,13 +1,13 @@
 import { completionPhaseOrder, completionToolNamesForPhase, debugCompletionPhaseOrder, expectedCompletionToolName, expectedDebugCompletionToolName, expectedDecomposeCompletionToolName, phaseFiles, toolServerName } from "./phase-completion.js";
 import { isDebugCompletionPhase, isDevelopCompletionPhase } from "./phase-completion.validation.js";
-export function completionPromptForPhase(phase) {
+export function completionPromptForPhase(phase, artifactRoot = ".forge/work-items/{workItemId}/artifacts") {
     const toolName = expectedCompletionToolName(phase);
     const alias = completionToolNamesForPhase(phase).find((name) => name !== toolName);
     const artifactName = phaseFiles[phase].jsonFileName;
     if (phase === "qa") {
         return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write QA artifacts by hand. When QA is complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""} with the required structured QA payload.
-That tool writes the durable QA bundle under \`.forge/work-items/{workItemId}/artifacts/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`${artifactName}\`, and \`qa.report.md\`.
+That tool writes the durable QA bundle under \`${artifactRoot}/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`${artifactName}\`, and \`qa.report.md\`.
 Use \`status: "pass"\` only when the validated changes satisfy acceptance criteria with concrete evidence. Use \`status: "needs_rework"\` with actionable in-scope findings, or \`status: "blocked"\` with a concrete blocker_reason.
 Include \`policy_warnings\` for non-blocking Forge policy or scope mismatches that should remain visible after QA.
 Forge will mirror only the tool-written QA artifacts; reporting QA completion in prose is not enough.`;
@@ -22,6 +22,14 @@ The payload must put \`phases\`, \`tasks\`, \`dependencies\`, and \`phase_gates\
 Dependency entries use canonical \`before\` and \`after\` task ids, for example \`{ "before": "task-1", "after": "task-2" }\`. Forge accepts \`from\`/\`to\` only as aliases and normalizes them before writing artifacts.
 Use \`status: "pass"\` for a valid pending-approval plan, \`needs_revision\` when story/design input must change, or \`blocked\` with a concrete blocker.
 Forge will mirror only the tool-written Architect artifacts; reporting the plan in prose is not enough.`;
+    }
+    if (phase === "ci_repair") {
+        return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
+Read the generated \`.forge/work-items/{workItemId}/ci-repair.readiness.json\` before running validation.
+Do not write the CI-repair handoff by hand. After the repair and locally equivalent validation are complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""}.
+That tool validates failed-check inspection, root cause, scoped changes, narrow proof, every failed-job guard/test/drift step, provider-only classifications, broader validation, remaining risk, provider state, and push readiness.
+It writes \`.forge/work-items/{workItemId}/artifacts/${artifactName}\`. Forge Bridge will not commit, push, or report CI repair success until this gate passes.
+For a step classified \`provider_only\`, include the exact reason and provider check that will supply the missing proof. Do not weaken or delete the provider check.`;
     }
     return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write phase artifacts by hand. When the phase is complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""} with the required evidence payload.
@@ -38,10 +46,10 @@ Complete the dev cycle in order inside this same provider session:
 Each tool writes the canonical artifact under \`.forge/work-items/{workItemId}/artifacts/\` and returns the next-phase instruction Forge expects you to follow.
 If the current phase cannot pass, call the current phase tool with a non-pass status and explicit blockers instead of reporting completion in prose only.`;
 }
-export function completionPromptForQaCycle(currentGate = "qa_plan") {
+export function completionPromptForQaCycle(currentGate = "qa_plan", artifactRoot = ".forge/work-items/{workItemId}/artifacts") {
     return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
 Do not write QA artifacts by hand. The tool server enforces QA gate order and starts this run at \`${currentGate}\`.
-Complete the QA cycle in order inside this same provider session:
+Complete the QA cycle in order inside this same provider session. Start long, independent regression verification as early as practical, continue API/source/manual review while it runs, and wait for its receipt only when those independent checks are complete:
 1. Call \`forge.complete_qa_plan(...)\` after the QA test plan/checklist is ready.
 2. Follow the returned regression instruction, then call \`forge.complete_qa_regression(...)\`.
 3. Follow the returned API/backend instruction, then call \`forge.complete_qa_api(...)\`.
@@ -50,7 +58,8 @@ Complete the QA cycle in order inside this same provider session:
 6. Follow the returned findings instruction, then call \`forge.complete_qa_findings(...)\`.
 7. Follow the returned verdict instruction, then call \`forge.complete_qa_verdict(...)\`.
 Use \`status: "skipped"\` with a reason for gates that are not applicable. If a gate is blocked, keep moving through later gates as skipped due to the blocker and finish with a blocked verdict.
-The final verdict tool writes the canonical QA bundle under \`.forge/work-items/{workItemId}/artifacts/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`qa.verdict.json\`, and \`qa.report.md\`.
+On a managed host, start solution-wide \`dotnet test Forge.sln\` evidence through \`forge.start_managed_command\` with at least a 45-minute timeout. Do not poll it. Continue independent QA work, then call \`forge.wait_managed_command\` once; Forge keeps the session healthy and streams durable progress while that call waits. Include the returned \`managed_command_id\` in command evidence. The regression gate rejects generic-shell timeouts and non-terminal receipts for that command.
+The final verdict tool writes the canonical QA bundle under \`${artifactRoot}/\`: \`qa.plan.json\`, \`qa.evidence.json\`, \`qa.findings.json\`, \`qa.verdict.json\`, and \`qa.report.md\`.
 Include \`policy_warnings\` in the final verdict for non-blocking Forge policy or scope mismatches that should remain visible after QA.
 The legacy \`forge.complete_qa\` one-shot tool is not available in normal QA-cycle mode. Reporting QA completion in prose is not enough.`;
 }
@@ -115,6 +124,11 @@ export function completionToolNextInstruction(completedPhase, status, nextPhase)
         }
         return "QA accepted. Forge has the structured evidence needed to move this work item to Sign-Off.";
     }
+    if (completedPhase === "ci_repair") {
+        return status === "pass"
+            ? "CI repair handoff accepted. Forge Bridge may now commit, push, and return the PR to provider checks."
+            : "Stay in CI repair, address the exact missing evidence returned by this gate, then call forge.complete_ci_repair again.";
+    }
     if (status !== "pass") {
         return `Stay in ${completedPhase}, address the recorded blockers, then call ${expectedCompletionToolName(completedPhase)} again.`;
     }
@@ -203,7 +217,7 @@ export function completionToolNextInstructionForDebugGate(completedGate, status,
 function qaGateInstruction(gate) {
     switch (gate) {
         case "qa_regression":
-            return "Run or explicitly skip applicable regression/build/lint/typecheck/e2e checks, then call forge.complete_qa_regression.";
+            return "Run or explicitly skip applicable regression/build/lint/typecheck/e2e checks, then call forge.complete_qa_regression. On a managed host, start solution-wide dotnet test Forge.sln early with forge.start_managed_command using at least a 45-minute timeout. Do not poll it: continue independent QA checks, then call forge.wait_managed_command once and include its terminal managed_command_id in command evidence. Forge keeps the session healthy and streams durable progress while that wait call is active. A reproduced failure outside the current diff and acceptance criteria may remain non-blocking only when the current item has independent passing evidence: preserve it as an out_of_scope_failure with candidate_bug_id, scope_evidence, acceptance_criteria_independent: true, and a failing focused repro command/exit code. Never classify an unexplained, in-scope, or infrastructure failure this way.";
         case "qa_api":
             return "Run or explicitly skip applicable API/backend contract checks, then call forge.complete_qa_api.";
         case "qa_manual_web":

package/dist/session/phase-completion.runtime.d.ts

@@ -1,4 +1,5 @@
 import { type CompletionToolCallResult, type CompletionToolRuntime, type CompletionToolRuntimeOptions, type CompletionToolServerConfig } from "./phase-completion.js";
+import { type ManagedAttemptToolResult } from "./managed-attempt-tools.js";
 export declare function prepareCompletionToolRuntime(options: CompletionToolRuntimeOptions): Promise<CompletionToolRuntime>;
 export declare function buildCompletionToolServerArgs(config: CompletionToolServerConfig): readonly string[];
 export declare function codexMcpConfigArgs(runtime: CompletionToolRuntime): readonly string[];
@@ -10,11 +11,12 @@ export declare class CompletionToolServerSession {
     private currentQaGate;
     private currentDraftGate;
     private currentDecomposeGate;
+    private readonly managedCommandReceipts;
     private completed;
     constructor(config: CompletionToolServerConfig);
     get instructions(): string;
     toolDefinitions(): readonly unknown[];
-    callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult>;
+    callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult | ManagedAttemptToolResult>;
     private callDecomposeGateTool;
     private callDraftGateTool;
     private callDebugGateTool;
@@ -25,6 +27,15 @@ export declare class CompletionToolServerSession {
     private advanceAfterQaGate;
     private advanceAfterDebugGate;
 }
+export declare function completionToolRuntimeEnvironment(runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+/**
+ * A solution-wide Forge test is long enough that a generic provider shell can
+ * expire while VSTest is still healthy. On managed host attempts, only the
+ * attempt-owned command runner can prove the exact process outcome and clean
+ * up its process tree. Keep this check at the completion gate so prompt drift
+ * cannot turn an arbitrary shell timeout into a QA blocker.
+ */
+export declare function assertManagedQaRegressionEvidence(input: unknown, receipts: readonly Readonly<Record<string, unknown>>[]): void;
 export declare function runCompletionMcpServer(config: CompletionToolServerConfig): Promise<void>;
 export declare function parseCompletionMcpArgs(argv: readonly string[]): {
     readonly ok: true;

package/dist/session/phase-completion.runtime.js

@@ -1,10 +1,11 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { completionPhaseFromDispatch, completionPhaseOrder, completionRedactionSecretsEnv, completionToolNamesForDebugGate, completionToolNamesForDecomposeGate, completionToolNamesForDraftGate, completionToolNamesForPhase, completionToolNamesForQaGate, debugCompletionPhaseOrder, decomposeCompletionGateOrder, draftCompletionGateOrder, qaCompletionGateOrder, toolServerName, usesArchitectCycleCompletion, usesDebugCycleCompletion, usesDevelopCycleCompletion, usesQaCycleCompletion } from "./phase-completion.js";
-import { asDebugCompletionPhase, asJsonRpcMessage, asMutableRecord, asRecord, decomposeGateFromToolName, draftGateFromToolName, errorMessage, forgeBridgeCliBinPath, isDebugCompletionPhase, isDecomposeDispatch, isDevelopCompletionPhase, normalizedOwnerType, parseCompletionRedactionSecrets, parseOptionalJsonObject, parseStrictCompletionPhase, phaseFromToolName, qaGateFromToolName, requiredString, rpcError, tomlString, tomlStringArray, writeFileAtomic, writeJsonRpc } from "./phase-completion.validation.js";
+import { asDebugCompletionPhase, asJsonRpcMessage, asMutableRecord, asRecord, artifactOwnerRelativeRoot, decomposeGateFromToolName, draftGateFromToolName, errorMessage, forgeBridgeCliBinPath, isDebugCompletionPhase, isDecomposeDispatch, isDevelopCompletionPhase, normalizedOwnerType, parseCompletionRedactionSecrets, parseOptionalJsonObject, parseStrictCompletionPhase, phaseFromToolName, qaGateFromToolName, requiredString, rpcError, tomlString, tomlStringArray, writeFileAtomic, writeJsonRpc } from "./phase-completion.validation.js";
 import { completionPromptForDebugCycle, completionPromptForDecomposeCycle, completionPromptForDevelopCycle, completionPromptForDraftCycle, completionPromptForPhase, completionPromptForQaCycle, completionToolNextInstruction, completionToolNextInstructionForDebugGate, completionToolNextInstructionForDecomposeGate, completionToolNextInstructionForDraftGate, completionToolNextInstructionForQaGate, nextDebugPhaseAfter, nextPhaseAfter } from "./phase-completion.prompts.js";
 import { toolDescription, toolInputSchema } from "./phase-completion.schemas.js";
 import { writeCompletionArtifact, writeDecomposeGateCompletionArtifact, writeDraftGateCompletionArtifact } from "./phase-completion.artifacts.js";
+import { callManagedAttemptTool, isManagedAttemptTool, managedAttemptToolDefinition, managedAttemptToolNames, } from "./managed-attempt-tools.js";
 export async function prepareCompletionToolRuntime(options) {
     const phase = options.phase ?? completionPhaseFromDispatch(options.dispatch);
     const worktreePath = path.resolve(options.worktree.worktreePath);
@@ -32,7 +33,7 @@ export async function prepareCompletionToolRuntime(options) {
         serverName: toolServerName,
         command: process.execPath,
         args: [forgeBridgeCliBinPath(), ...mcpArgs],
-        env: {},
+        env: completionToolRuntimeEnvironment(options.runtimeEnvironment),
         cleanup: async () => undefined
     };
     if (options.dispatch.execution.provider.trim().toLowerCase() !== "cursor") {
@@ -82,7 +83,11 @@ export function codexMcpConfigArgs(runtime) {
         "-c",
         `${prefix}.command=${tomlString(runtime.command)}`,
         "-c",
-        `${prefix}.args=${tomlStringArray(runtime.args)}`
+        `${prefix}.args=${tomlStringArray(runtime.args)}`,
+        "-c",
+        `${prefix}.default_tools_approval_mode=${tomlString("approve")}`,
+        "-c",
+        `${prefix}.tool_timeout_sec=7200`
     ];
     for (const [key, value] of Object.entries(runtime.env)) {
         args.push("-c", `${prefix}.env.${key}=${tomlString(value)}`);
@@ -117,6 +122,7 @@ export class CompletionToolServerSession {
     currentQaGate = "qa_plan";
     currentDraftGate = "draft_intent";
     currentDecomposeGate = "decompose_subject_intake";
+    managedCommandReceipts = [];
     completed = false;
     constructor(config) {
         this.config = config;
@@ -130,15 +136,28 @@ export class CompletionToolServerSession {
                 : this.config.debugCycle
                     ? completionPromptForDebugCycle(asDebugCompletionPhase(this.currentPhase))
                     : this.config.qaCycle
-                        ? completionPromptForQaCycle(this.currentQaGate)
+                        ? completionPromptForQaCycle(this.currentQaGate, artifactOwnerRelativeRoot(this.config.ownerType, this.config.ownerId, this.config.workItemId))
                         : this.config.developCycle
                             ? completionPromptForDevelopCycle(this.currentPhase)
-                            : completionPromptForPhase(this.currentPhase);
+                            : completionPromptForPhase(this.currentPhase, artifactOwnerRelativeRoot(this.config.ownerType, this.config.ownerId, this.config.workItemId));
     }
     toolDefinitions() {
-        return completionToolNamesForServer(this.config).map((name) => toolDefinition(name, phaseFromToolName(name), qaGateFromToolName(name), decomposeGateFromToolName(name)));
+        const completionTools = completionToolNamesForServer(this.config).map((name) => toolDefinition(name, phaseFromToolName(name), qaGateFromToolName(name), decomposeGateFromToolName(name)));
+        return managedAttemptToolsAvailable()
+            ? [...completionTools, ...managedAttemptToolNames.map(managedAttemptToolDefinition)]
+            : completionTools;
     }
     async callTool(toolName, input) {
+        if (isManagedAttemptTool(toolName)) {
+            if (!managedAttemptToolsAvailable()) {
+                throw new Error("Forge managed-attempt tools require an active managed host runtime.");
+            }
+            const result = await callManagedAttemptTool(toolName, input, this.config.worktreePath);
+            if (Array.isArray(result.structuredContent.command)) {
+                this.managedCommandReceipts.push(result.structuredContent);
+            }
+            return result;
+        }
         const requestedPhase = phaseFromToolName(toolName);
         if (this.completed) {
             throw new Error("Forge completion cycle is already complete; no more completion calls are accepted.");
@@ -292,6 +311,9 @@ export class CompletionToolServerSession {
             throw new Error(`Tool ${toolName} is out of order. Current Forge QA gate is ${this.currentQaGate}.`);
         }
         const completedGate = this.currentQaGate;
+        if (completedGate === "qa_regression" && managedAttemptToolsAvailable()) {
+            assertManagedQaRegressionEvidence(input, this.managedCommandReceipts);
+        }
         const reference = await writeCompletionArtifact({ ...this.config, phase: "qa" }, toolName, input);
         const status = reference.status.trim().toLowerCase();
         const nextGate = this.advanceAfterQaGate(completedGate);
@@ -327,6 +349,10 @@ export class CompletionToolServerSession {
             this.completed = true;
             return "sign_off_ready";
         }
+        if (phase === "ci_repair") {
+            this.completed = true;
+            return "provider_checks_ready";
+        }
         if (isDebugCompletionPhase(phase)) {
             return nextDebugPhaseAfter(phase) ?? "qa_ready";
         }
@@ -382,6 +408,102 @@ export class CompletionToolServerSession {
         return null;
     }
 }
+const completionToolRuntimeEnvironmentNames = [
+    "FORGE_RUNTIME_MODE",
+    "FORGE_RESOURCE_LEASE_ID",
+    "FORGE_DISPATCH_ATTEMPT_ID",
+    "FORGE_LOG_DIR",
+    "FORGE_TEST_OUTPUT_DIR",
+    "FORGE_TMPDIR",
+    "TMPDIR",
+    "TMP",
+    "TEMP",
+];
+export function completionToolRuntimeEnvironment(runtimeEnvironment) {
+    if (!runtimeEnvironment)
+        return {};
+    const env = {};
+    for (const name of completionToolRuntimeEnvironmentNames) {
+        const value = runtimeEnvironment[name]?.trim();
+        if (value)
+            env[name] = value;
+    }
+    return env;
+}
+const minimumManagedSolutionTestTimeoutMs = 45 * 60 * 1000;
+/**
+ * A solution-wide Forge test is long enough that a generic provider shell can
+ * expire while VSTest is still healthy. On managed host attempts, only the
+ * attempt-owned command runner can prove the exact process outcome and clean
+ * up its process tree. Keep this check at the completion gate so prompt drift
+ * cannot turn an arbitrary shell timeout into a QA blocker.
+ */
+export function assertManagedQaRegressionEvidence(input, receipts) {
+    const payload = asRecord(input, "QA regression completion payload");
+    const nestedEvidence = asMutableRecord(payload.evidence);
+    const commands = payload.commands ?? nestedEvidence.commands;
+    if (!Array.isArray(commands))
+        return;
+    for (const [index, entry] of commands.entries()) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const command = entry.command;
+        if (typeof command !== "string" || !isForgeSolutionTestCommand(command))
+            continue;
+        const managedCommandId = entry.managed_command_id;
+        if (typeof managedCommandId !== "string" || !managedCommandId.trim()) {
+            throw new Error(`qa_regression_managed_command_id_required: commands[${index}] runs the solution-wide Forge test. `
+                + "Run it with forge.start_managed_command, continue independent work, call forge.wait_managed_command once for the terminal receipt, and include the returned managed_command_id in this command evidence.");
+        }
+        const matchingReceipts = receipts.filter((receipt) => {
+            const tokens = receipt.command;
+            return receipt.command_id === managedCommandId
+                && Array.isArray(tokens)
+                && tokens.every((token) => typeof token === "string")
+                && isForgeSolutionTestCommand(tokens.join(" "));
+        });
+        if (matchingReceipts.length === 0) {
+            throw new Error(`qa_regression_managed_command_required: commands[${index}] runs the solution-wide Forge test. `
+                + "Run it with forge.start_managed_command, continue independent work, call forge.wait_managed_command once for the terminal receipt, and include its matching managed_command_id; generic-shell timeout evidence is not accepted on a managed host.");
+        }
+        const terminalReceipts = matchingReceipts.filter((receipt) => typeof receipt.status === "string" && [
+            "pass",
+            "fail",
+            "timed_out",
+            "timeout_termination_failed",
+            "runner_error",
+        ].includes(receipt.status));
+        if (terminalReceipts.length === 0) {
+            throw new Error(`qa_regression_managed_command_in_progress: commands[${index}] has not produced a terminal managed receipt. `
+                + "Call forge.wait_managed_command once for its terminal receipt, then resubmit this gate.");
+        }
+        const adequateReceipt = terminalReceipts.some((receipt) => {
+            if (receipt.timed_out !== true)
+                return true;
+            return typeof receipt.timeout_ms === "number"
+                && receipt.timeout_ms >= minimumManagedSolutionTestTimeoutMs
+                && receipt.process_tree_terminated === true;
+        });
+        if (!adequateReceipt) {
+            throw new Error(`qa_regression_managed_timeout_too_short: commands[${index}] timed out before the minimum `
+                + `${minimumManagedSolutionTestTimeoutMs}ms solution-test budget. Rerun it with forge.start_managed_command `
+                + "using at least a 45-minute timeout and resubmit this gate.");
+        }
+    }
+}
+function isForgeSolutionTestCommand(command) {
+    const normalized = command.trim().toLowerCase().replaceAll("\\", "/");
+    return normalized.includes("dotnet")
+        && /(?:^|\s)test(?:\s|$)/u.test(normalized)
+        && /(?:^|[\s/"'])forge\.sln(?:[\s"']|$)/u.test(normalized);
+}
+function managedAttemptToolsAvailable() {
+    return process.env.FORGE_RUNTIME_MODE === "host"
+        && Boolean(process.env.FORGE_RESOURCE_LEASE_ID?.trim())
+        && Boolean(process.env.FORGE_DISPATCH_ATTEMPT_ID?.trim())
+        && Boolean(process.env.FORGE_LOG_DIR?.trim())
+        && Boolean(process.env.FORGE_TEST_OUTPUT_DIR?.trim());
+}
 export async function runCompletionMcpServer(config) {
     const session = new CompletionToolServerSession(config);
     process.stdin.setEncoding("utf8");
@@ -437,7 +559,7 @@ export function parseCompletionMcpArgs(argv) {
             const rawPhase = argv[++index];
             const parsedPhase = parseStrictCompletionPhase(rawPhase);
             if (!parsedPhase) {
-                return { ok: false, error: "mcp --phase must be one of: implementation, self-review, validation, qa, architect, draft, debug-repro, debug-root-cause, debug-fix, debug-regression." };
+                return { ok: false, error: "mcp --phase must be one of: implementation, self-review, validation, qa, architect, draft, decompose, ci-repair, debug-repro, debug-root-cause, debug-fix, debug-regression." };
             }
             phase = parsedPhase;
         }

package/dist/session/phase-completion.schemas.js

@@ -16,6 +16,9 @@ export function toolDescription(phase, qaGate = null, decomposeGate = null) {
     if (phase === "implementation") {
         return "Complete Forge implementation by writing implementation.completeness.json with scoped changed-file, verification, acceptance-criteria, gap, and next-phase evidence.";
     }
+    if (phase === "ci_repair") {
+        return "Complete Forge CI repair by writing ci-repair.handoff.json with failed-check, root-cause, scoped-change, workflow-equivalence, validation, provider-state, and push-readiness evidence.";
+    }
     if (phase === "self_review") {
         return "Complete Forge self-review by writing self-review.report.json with diff review, findings, security, edge-case, design, deterministic-comparison, fixes, and remaining-risk evidence.";
     }
@@ -55,6 +58,94 @@ export function toolInputSchema(phase, qaGate = null, decomposeGate = null) {
     if (isDebugCompletionPhase(phase)) {
         return debugToolInputSchema(phase, baseProperties);
     }
+    if (phase === "ci_repair") {
+        return objectToolSchema({
+            ...baseProperties,
+            failed_checks: {
+                type: "array",
+                description: "Required and non-empty for pass. Provider check/job/step evidence inspected before repair.",
+                items: evidenceObjectSchema(["name", "provider_state"], {
+                    name: { type: "string" },
+                    provider_state: { type: "string" },
+                    workflow: { type: "string" },
+                    job: { type: "string" },
+                    step: { type: "string" },
+                    details_url: { type: "string" },
+                    evidence: { type: "string" }
+                })
+            },
+            root_cause: {
+                type: "object",
+                description: "Required for pass. Include classification, summary, and concrete evidence.",
+                additionalProperties: true,
+                properties: {
+                    classification: { type: "string" },
+                    summary: { type: "string" },
+                    evidence: { type: "array", items: { type: "string" } }
+                }
+            },
+            changed_files: {
+                type: "array",
+                description: "Files changed by the repair. May be empty only when no_code_action explains the provider-only action or blocker.",
+                items: evidenceObjectSchema(["path", "summary"], {
+                    path: { type: "string" },
+                    summary: { type: "string" }
+                })
+            },
+            no_code_action: {
+                type: "object",
+                description: "Required when changed_files is empty. Describe the evidence-backed provider action or blocker.",
+                additionalProperties: true,
+                properties: {
+                    action: { type: "string" },
+                    reason: { type: "string" },
+                    evidence: { type: "string" }
+                }
+            },
+            narrow_validation: {
+                type: "array",
+                description: "Required and non-empty for pass. The focused failing command or evidence-backed substitute.",
+                items: commandEvidenceSchema()
+            },
+            workflow_validation: {
+                type: "array",
+                description: "Required and non-empty for pass. Each failed-job guard/test/drift step with local equivalence supported, substitute, or provider_only.",
+                items: evidenceObjectSchema(["step", "equivalence", "status"], {
+                    step: { type: "string" },
+                    equivalence: { type: "string", enum: ["supported", "substitute", "provider_only"] },
+                    command: { type: "string" },
+                    exit_code: { type: "number" },
+                    status: { type: "string" },
+                    summary: { type: "string" },
+                    reason: { type: "string" },
+                    substitute: { type: "string" }
+                })
+            },
+            broader_validation: {
+                type: "array",
+                description: "Required and non-empty for pass. Normal validation covering every touched compiled/tested surface.",
+                items: commandEvidenceSchema()
+            },
+            remaining_risks: {
+                type: "array",
+                description: "Required for pass, even when empty.",
+                items: evidenceObjectSchema(["summary"], {
+                    summary: { type: "string" },
+                    mitigation: { type: "string" },
+                    owner: { type: "string" }
+                })
+            },
+            provider_state: {
+                type: "string",
+                enum: ["ready_for_rerun", "rerun_requested", "checks_pending", "still_failing", "blocked_by_provider"],
+                description: "Provider state after local validation and before Forge-owned publication."
+            },
+            ready_for_push: {
+                type: "boolean",
+                description: "Required for pass and must be true. Forge Bridge performs the commit/push only after this gate passes."
+            }
+        }, ["status", "summary"], "For status pass, include failed_checks, root_cause, changed_files or no_code_action, narrow_validation, workflow_validation, broader_validation, remaining_risks, provider_state, and ready_for_push: true.");
+    }
     if (phase === "implementation") {
         return objectToolSchema({
             ...baseProperties,
@@ -198,7 +289,7 @@ export function toolInputSchema(phase, qaGate = null, decomposeGate = null) {
             },
             sidecars: {
                 type: "array",
-                description: "Optional QA sidecar files already written under .forge/work-items/<id>/artifacts/qa/ with path/content_hash/bytes metadata.",
+                description: "Optional QA sidecar files already written under the dispatch-provided QA artifacts path with path/content_hash/bytes metadata.",
                 items: evidenceObjectSchema(["path", "content_hash", "bytes"], {
                     path: { type: "string" },
                     content_hash: { type: "string" },
@@ -411,7 +502,9 @@ function decomposeGateToolInputSchema(gate, baseProperties) {
             estimatedQaScope: qaScopeSchema("Work Order-to-Feature planning QA estimate. This is not dispatch-authoritative QA scope."),
             estimated_qa_scope: qaScopeSchema("Work Order-to-Feature planning QA estimate. Snake_case alias for estimatedQaScope."),
             qaScope: qaScopeSchema("Feature-to-Story QA scope that becomes Story-level QA scope after proposal approval."),
-            qa_scope: qaScopeSchema("Feature-to-Story QA scope. Snake_case alias for qaScope.")
+            qa_scope: qaScopeSchema("Feature-to-Story QA scope. Snake_case alias for qaScope."),
+            designerRefCandidates: designerRefCandidatesSchema("Designer packet refs that justify this candidate. Omit to inherit all parent refs unchanged."),
+            designer_ref_candidates: designerRefCandidatesSchema("Snake_case alias for designerRefCandidates.")
         }
     };
     const proposalSchema = {
@@ -440,7 +533,27 @@ function decomposeGateToolInputSchema(gate, baseProperties) {
             ...proposalSchema,
             description: "Alias for proposal_json when a client cannot send proposal_json."
         }
-    }, ["status", "summary"], "For the final Decompose proposal, include proposal_json with a candidates array. Work Order-to-Feature candidates may include estimatedQaScope/estimated_qa_scope; Feature-to-Story candidates may include qaScope/qa_scope.");
+    }, ["status", "summary"], "For the final Decompose proposal, include proposal_json with a candidates array. Work Order-to-Feature candidates may include estimatedQaScope/estimated_qa_scope; Feature-to-Story candidates may include qaScope/qa_scope. Both levels may include designerRefCandidates/designer_ref_candidates.");
+}
+function designerRefCandidatesSchema(description) {
+    return {
+        type: "array",
+        description,
+        items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                designerRefId: { type: "string" },
+                designer_ref_id: { type: "string" },
+                refKey: { type: "string" },
+                ref_key: { type: "string" },
+                path: { type: "string" },
+                anchor: { type: "string" },
+                reason: { type: "string" },
+                required: { type: "boolean" }
+            }
+        }
+    };
 }
 function debugToolInputSchema(phase, baseProperties) {
     if (phase === "debug_repro") {
@@ -630,9 +743,23 @@ function qaScopeSchema(description) {
 function commandEvidenceSchema() {
     return evidenceObjectSchema(["command", "exit_code", "status", "summary"], {
         command: { type: "string" },
-        exit_code: { type: "number" },
+        managed_command_id: { type: "string", description: "Receipt ID returned by forge.start_managed_command and completed through one forge.wait_managed_command call for managed-host evidence." },
+        exit_code: { type: ["number", "null"], description: "Process exit code, or null when the managed runner timed out or could not launch the process." },
         status: { type: "string" },
-        summary: { type: "string" }
+        summary: { type: "string" },
+        classification: {
+            type: "string",
+            enum: ["out_of_scope_failure", "baseline_failure"],
+            description: "Only for a verified non-blocking failure in a passing QA regression gate. Never use for an in-scope or unexplained failure."
+        },
+        candidate_bug_id: { type: "string", description: "Required for a classified non-blocking failure; links the preserved failure to candidate_bugs." },
+        scope_evidence: { type: "string", description: "Required proof that the failing surface is outside the current acceptance criteria and changed-file scope." },
+        acceptance_criteria_independent: { type: "boolean", description: "Required and true only when the current item can be judged independently of this failure." },
+        repro_command: { type: "string", description: "Required for out_of_scope_failure; focused command that reproduced the unrelated failure." },
+        repro_exit_code: { type: "number", description: "Required non-zero focused repro exit code for out_of_scope_failure." },
+        baseline_ref: { type: "string", description: "Required for baseline_failure; immutable ref where the same failure was observed." },
+        baseline_exit_code: { type: "number", description: "Required non-zero baseline command exit code for baseline_failure." },
+        failure_signature_match: { type: "boolean", description: "Required and true for baseline_failure after matching failing test/error signatures." }
     });
 }
 function resolvedFindingSchema() {

package/dist/session/phase-completion.validation.d.ts

@@ -2,9 +2,12 @@ import { type CompletionPhase, type DebugCompletionPhase, type QaCompletionGate
 export declare function normalizeCompletionStatus(value: string, phase?: CompletionPhase): string;
 export declare function normalizeQaGateStatus(value: string): string;
 export declare function validatePayloadShape(phase: CompletionPhase, payload: Record<string, unknown>): void;
+export declare function validateCiRepairPayloadShape(payload: Record<string, unknown>): void;
 export declare function validateDebugPayloadShape(phase: DebugCompletionPhase, payload: Record<string, unknown>): void;
 export declare function validateQaGatePayloadShape(gate: QaCompletionGate, payload: Record<string, unknown>, status: string): void;
-export declare function validateQaGatePassingCommands(commands: readonly unknown[]): void;
+export declare function validateQaGatePassingCommands(commands: readonly unknown[], options?: {
+    readonly allowClassifiedNonBlockingFailures?: boolean;
+}): void;
 export declare function validateArchitectPayloadShape(payload: Record<string, unknown>, status: string): void;
 export declare function validateArchitectTaskDevelopScope(task: Record<string, unknown>, taskId: string): void;
 export declare function validateArchitectVerificationScope(task: Record<string, unknown>, taskId: string): void;