@loucompanion/forge-bridge 0.1.3-dev.d1ca67076aa9 → 0.1.3-dev.eeefdb0d19c1

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

@@ -237,12 +237,19 @@ export async function writeQaGateCompletionArtifact(config, gate, input) {
     const status = normalizeQaGateStatus(requiredString(payload, "status"));
     validateQaGatePayloadShape(gate, payload, status);
     validateOptionalWorkItemId(payload, config.workItemId);
-    const redactedPayload = redactSecrets({ ...payload, status }, config.redactionSecrets ?? []);
+    const ownerFields = artifactOwnerFields(config);
+    const validatedSidecars = gate === "qa_manual_web"
+        ? await validateQaSidecarReferences(config.worktreePath, config.workItemId, qaArray(payload, "sidecars", qaEvidenceSource(payload)), ownerFields.owner_type, ownerFields.owner_id)
+        : null;
+    const redactedPayload = redactSecrets({
+        ...payload,
+        status,
+        ...(validatedSidecars ? { sidecars: validatedSidecars } : {})
+    }, config.redactionSecrets ?? []);
     const producedBy = optionalString(redactedPayload, "produced_by")
         ?? optionalString(redactedPayload, "producedBy")
         ?? config.producedBy
         ?? "forge-completion-tool";
-    const ownerFields = artifactOwnerFields(config);
     const artifactRoot = ownerFields.owner_type && ownerFields.owner_id
         ? artifactRootForOwner(config.worktreePath, ownerFields.owner_type, ownerFields.owner_id)
         : artifactRootFor(config.worktreePath, config.workItemId);
@@ -424,7 +431,7 @@ async function synthesizeQaCycleVerdictPayload(config, payload, status) {
     ]);
     merged.browser_checks = dedupeUnknownArray([
         ...qaArray(payload, "browser_checks", payloadEvidence),
-        ...evidenceGates.flatMap((gate) => qaArray(gate, "browser_checks"))
+        ...evidenceGates.flatMap((gate) => qaArray(gate, "browser_checks").map(normalizeInheritedQaBrowserCheck))
     ]);
     merged.sidecars = dedupeUnknownArray([
         ...qaArray(payload, "sidecars", payloadEvidence),
@@ -516,6 +523,27 @@ function dedupeStrings(values) {
     }
     return deduped;
 }
+function normalizeInheritedQaBrowserCheck(browserCheck) {
+    if (!browserCheck || typeof browserCheck !== "object" || Array.isArray(browserCheck)) {
+        return browserCheck;
+    }
+    const record = browserCheck;
+    if (optionalString(record, "summary")) {
+        return record;
+    }
+    const target = optionalString(record, "url") ?? optionalString(record, "route") ?? "the configured browser target";
+    const status = optionalString(record, "status") ?? "recorded";
+    return {
+        ...record,
+        summary: `Inherited browser check ${status} for ${target}.`
+    };
+}
+function normalizeSha256ContentHash(contentHash) {
+    const normalized = contentHash.trim().toLowerCase();
+    return normalized.startsWith("sha256:")
+        ? normalized.slice("sha256:".length)
+        : normalized;
+}
 async function validateQaSidecarReferences(worktreePath, workItemId, sidecars, ownerType, ownerId) {
     if (sidecars.length === 0) {
         return [];
@@ -557,7 +585,7 @@ async function validateQaSidecarReferences(worktreePath, workItemId, sidecars, o
             throw new Error(`sidecars[${index}].bytes does not match the referenced file.`);
         }
         const actualHash = await sha256File(fullPath);
-        if (actualHash !== contentHash.trim().toLowerCase()) {
+        if (actualHash !== normalizeSha256ContentHash(contentHash)) {
             throw new Error(`sidecars[${index}].content_hash does not match the referenced file.`);
         }
         validated.push({

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

@@ -9,7 +9,8 @@ export type DebugCompletionPhase = "debug_repro" | "debug_root_cause" | "debug_f
 export type ArchitectCompletionPhase = "architect";
 export type DraftCompletionPhase = "draft";
 export type DecomposeCompletionPhase = "decompose";
-export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase | DecomposeCompletionPhase;
+export type CiRepairCompletionPhase = "ci_repair";
+export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase | DraftCompletionPhase | DecomposeCompletionPhase | CiRepairCompletionPhase;
 export type QaCompletionGate = "qa_plan" | "qa_regression" | "qa_api" | "qa_manual_web" | "qa_bug_repro" | "qa_findings" | "qa_verdict";
 export type DraftCompletionGate = "draft_intent" | "draft_repo_context" | "draft_graph_context" | "draft_product_scope" | "draft_work_order_plan" | "draft_critic" | "draft_proposal";
 export type DecomposeCompletionGate = "decompose_subject_intake" | "decompose_context_review" | "decompose_breakdown_strategy" | "decompose_child_items" | "decompose_dependency_graph" | "decompose_critic" | "decompose_proposal";
@@ -25,6 +26,7 @@ export interface CompletionToolRuntimeOptions {
     readonly dispatch: RunOnceDispatchPacket;
     readonly worktree: WorktreeHandle;
     readonly phase?: CompletionPhase;
+    readonly runtimeEnvironment?: Readonly<Record<string, string>>;
 }
 export interface CompletionToolServerConfig {
     readonly worktreePath: string;
@@ -56,7 +58,7 @@ export interface CompletionToolCallResult {
             readonly allowed: boolean;
             readonly reason: string;
         };
-        readonly nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready";
+        readonly nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready" | "provider_checks_ready";
         readonly nextInstruction: string;
     };
 }

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,7 +46,7 @@ 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:
@@ -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, poll \`forge.get_managed_command\` until it returns a terminal receipt, and include the returned \`managed_command_id\` in its 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 with forge.start_managed_command using at least a 45-minute timeout, poll forge.get_managed_command to a terminal receipt, and include its managed_command_id in the command evidence. 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,9 @@ 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")}`
     ];
     for (const [key, value] of Object.entries(runtime.env)) {
         args.push("-c", `${prefix}.env.${key}=${tomlString(value)}`);
@@ -117,6 +120,7 @@ export class CompletionToolServerSession {
     currentQaGate = "qa_plan";
     currentDraftGate = "draft_intent";
     currentDecomposeGate = "decompose_subject_intake";
+    managedCommandReceipts = [];
     completed = false;
     constructor(config) {
         this.config = config;
@@ -130,15 +134,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 +309,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 +347,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 +406,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, poll forge.get_managed_command to a 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, poll forge.get_managed_command to a 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. `
+                + "Poll forge.get_managed_command until the status is terminal, 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 +557,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;
         }