@loucompanion/forge-bridge 0.1.1-dev.718bdb0018b9 → 0.1.1-dev.895607f4402a

package/dist/session/phase-completion.js

@@ -7,6 +7,45 @@ import { ensureNoSymbolicLinkPathSegments, isPathUnderRoot, sha256File } from ".
 const toolServerName = "forge";
 const completionRedactionSecretsEnv = "FORGE_COMPLETION_REDACTION_SECRETS";
 const completionPhaseOrder = ["implementation", "self_review", "validation"];
+export const debugCompletionPhaseOrder = [
+    "debug_repro",
+    "debug_root_cause",
+    "debug_fix",
+    "debug_regression"
+];
+export const qaCompletionGateOrder = [
+    "qa_plan",
+    "qa_regression",
+    "qa_api",
+    "qa_manual_web",
+    "qa_bug_repro",
+    "qa_findings",
+    "qa_verdict"
+];
+const qaGateFileNames = {
+    qa_plan: "qa.plan.json",
+    qa_regression: "qa.regression.json",
+    qa_api: "qa.api.json",
+    qa_manual_web: "qa.manual-web.json",
+    qa_bug_repro: "qa.bug-repro.json",
+    qa_findings: "qa.findings.json",
+    qa_verdict: "qa.verdict.json"
+};
+const qaGateToolNames = {
+    qa_plan: "complete_qa_plan",
+    qa_regression: "complete_qa_regression",
+    qa_api: "complete_qa_api",
+    qa_manual_web: "complete_qa_manual_web",
+    qa_bug_repro: "complete_qa_bug_repro",
+    qa_findings: "complete_qa_findings",
+    qa_verdict: "complete_qa_verdict"
+};
+const debugGateToolNames = {
+    debug_repro: "complete_debug_repro",
+    debug_root_cause: "complete_debug_root_cause",
+    debug_fix: "complete_debug_fix",
+    debug_regression: "complete_debug_regression"
+};
 const qaBlockerReasons = new Set([
     "missing_app_launch_target",
     "inconclusive",
@@ -34,6 +73,22 @@ const phaseFiles = {
     qa: {
         jsonFileName: "qa.verdict.json",
         reportFileName: "qa.report.md"
+    },
+    debug_repro: {
+        jsonFileName: "debug.repro.json",
+        reportFileName: "debug.report.md"
+    },
+    debug_root_cause: {
+        jsonFileName: "debug.root-cause.json",
+        reportFileName: "debug.report.md"
+    },
+    debug_fix: {
+        jsonFileName: "debug.fix.json",
+        reportFileName: "debug.report.md"
+    },
+    debug_regression: {
+        jsonFileName: "debug.regression.json",
+        reportFileName: "debug.report.md"
     }
 };
 export function completionPhaseFromDispatch(dispatch) {
@@ -41,6 +96,10 @@ export function completionPhaseFromDispatch(dispatch) {
 }
 export function normalizeCompletionPhase(value) {
     const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    const debugPhase = normalizeDebugCompletionPhase(normalized);
+    if (debugPhase) {
+        return debugPhase;
+    }
     if (normalized === "self_review" || normalized === "selfreview" || normalized === "review") {
         return "self_review";
     }
@@ -61,7 +120,28 @@ export function usesDevelopCycleCompletion(dispatch) {
         && lane === "develop"
         && completionPhaseFromDispatch(dispatch) === "implementation";
 }
+export function usesQaCycleCompletion(dispatch) {
+    const kind = dispatch.cycleRun.kind.trim().toLowerCase();
+    const role = dispatch.execution.role.trim().toLowerCase();
+    const lane = dispatch.execution.lane.trim().toLowerCase();
+    return kind === "qa"
+        && role === "qa"
+        && lane === "qa"
+        && completionPhaseFromDispatch(dispatch) === "qa";
+}
+export function usesDebugCycleCompletion(dispatch) {
+    const kind = dispatch.cycleRun.kind.trim().toLowerCase();
+    const role = dispatch.execution.role.trim().toLowerCase();
+    const lane = dispatch.execution.lane.trim().toLowerCase();
+    return kind === "debug"
+        && role === "debug"
+        && lane === "debug"
+        && isDebugCompletionPhase(completionPhaseFromDispatch(dispatch));
+}
 export function completionToolNamesForPhase(phase) {
+    if (isDebugCompletionPhase(phase)) {
+        return completionToolNamesForDebugGate(phase);
+    }
     const base = phase === "implementation"
         ? "complete_implementation"
         : phase === "self_review"
@@ -71,12 +151,29 @@ export function completionToolNamesForPhase(phase) {
                 : "complete_qa";
     return [`forge.${base}`, base];
 }
+export function completionToolNamesForQaGate(gate) {
+    const base = qaGateToolNames[gate];
+    return [`forge.${base}`, base];
+}
+export function completionToolNamesForDebugGate(gate) {
+    const base = debugGateToolNames[gate];
+    return [`forge.${base}`, base];
+}
 export function expectedCompletionToolName(phase) {
     return completionToolNamesForPhase(phase)[0];
 }
+export function expectedQaCompletionToolName(gate) {
+    return completionToolNamesForQaGate(gate)[0];
+}
+export function expectedDebugCompletionToolName(gate) {
+    return completionToolNamesForDebugGate(gate)[0];
+}
 export function artifactRootFor(worktreePath, workItemId) {
     return path.join(worktreePath, ".forge", "work-items", safePathSegment(workItemId, "work item id"), "artifacts");
 }
+function artifactRootForOwner(worktreePath, ownerType, ownerId) {
+    return path.join(worktreePath, ".forge", artifactOwnerDirectory(ownerType), safePathSegment(ownerId, "owner id"), "artifacts");
+}
 export function completionArtifactJsonPath(worktreePath, workItemId, phase) {
     return path.join(artifactRootFor(worktreePath, workItemId), phaseFiles[phase].jsonFileName);
 }
@@ -87,12 +184,18 @@ export async function prepareCompletionToolRuntime(options) {
     const phase = options.phase ?? completionPhaseFromDispatch(options.dispatch);
     const worktreePath = path.resolve(options.worktree.worktreePath);
     const workItemId = options.dispatch.workItem.id;
+    const ownerType = normalizedOwnerType(options.dispatch.cycleRun.ownerType) ?? "work_item";
+    const ownerId = options.dispatch.cycleRun.ownerId ?? workItemId;
     const mcpArgs = buildCompletionToolServerArgs({
         worktreePath,
         workItemId,
+        ownerType,
+        ownerId,
         phase,
         producedBy: `${options.dispatch.execution.provider}-cli`,
-        developCycle: usesDevelopCycleCompletion(options.dispatch)
+        developCycle: usesDevelopCycleCompletion(options.dispatch),
+        qaCycle: usesQaCycleCompletion(options.dispatch),
+        debugCycle: usesDebugCycleCompletion(options.dispatch)
     });
     const runtime = {
         serverName: toolServerName,
@@ -118,9 +221,19 @@ export function buildCompletionToolServerArgs(config) {
         "--produced-by",
         config.producedBy ?? "forge-completion-tool"
     ];
+    if (config.ownerType || config.ownerId) {
+        args.push("--owner-type", normalizedOwnerType(config.ownerType) ?? "work_item");
+        args.push("--owner-id", config.ownerId ?? config.workItemId);
+    }
     if (config.developCycle) {
         args.push("--develop-cycle");
     }
+    if (config.qaCycle) {
+        args.push("--qa-cycle");
+    }
+    if (config.debugCycle) {
+        args.push("--debug-cycle");
+    }
     return args;
 }
 export function codexMcpConfigArgs(runtime) {
@@ -169,31 +282,72 @@ 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") {
+    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:
+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(...)\`.
+4. Follow the returned manual web instruction, then call \`forge.complete_qa_manual_web(...)\`.
+5. Follow the returned bug reproduction instruction, then call \`forge.complete_qa_bug_repro(...)\`.
+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\`.
+The legacy \`forge.complete_qa\` one-shot tool is not available in normal QA-cycle mode. Reporting QA completion in prose is not enough.`;
+}
+export function completionPromptForDebugCycle(currentGate = "debug_repro") {
+    return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
+Do not write Debug artifacts by hand. The tool server enforces Debug gate order and starts this run at \`${currentGate}\`.
+Complete the Debug cycle in order inside this same provider session:
+1. Reproduce or tightly characterize the bug, then call \`forge.complete_debug_repro(...)\`.
+2. Follow the returned root-cause instruction, isolate evidence, then call \`forge.complete_debug_root_cause(...)\`.
+3. Follow the returned fix instruction, apply the smallest safe fix with regression coverage when practical, then call \`forge.complete_debug_fix(...)\`.
+4. Follow the returned regression instruction, prove the original repro is negative and the fix is QA-ready, then call \`forge.complete_debug_regression(...)\`.
+Each tool writes a canonical Debug artifact under \`.forge/work-items/{workItemId}/artifacts/\`: \`debug.repro.json\`, \`debug.root-cause.json\`, \`debug.fix.json\`, and \`debug.regression.json\` plus \`debug.report.md\` when report text is provided or generated.
+Use a non-pass status with explicit blockers when the current Debug gate cannot pass. Reporting Debug completion in prose is not enough; the relevant MCP completion tool is the transition request.`;
+}
 export function completionToolNamesForServer(config) {
-    return config.developCycle
-        ? completionPhaseOrder.flatMap((phase) => completionToolNamesForPhase(phase))
-        : completionToolNamesForPhase(config.phase);
+    return config.debugCycle
+        ? debugCompletionPhaseOrder.flatMap((gate) => completionToolNamesForDebugGate(gate))
+        : config.qaCycle
+            ? qaCompletionGateOrder.flatMap((gate) => completionToolNamesForQaGate(gate))
+            : config.developCycle
+                ? completionPhaseOrder.flatMap((phase) => completionToolNamesForPhase(phase))
+                : completionToolNamesForPhase(config.phase);
 }
 export class CompletionToolServerSession {
     config;
     currentPhase;
+    currentQaGate = "qa_plan";
     completed = false;
     constructor(config) {
         this.config = config;
         this.currentPhase = config.phase;
     }
     get instructions() {
-        return this.config.developCycle
-            ? completionPromptForDevelopCycle(this.currentPhase)
-            : completionPromptForPhase(this.currentPhase);
+        return this.config.debugCycle
+            ? completionPromptForDebugCycle(asDebugCompletionPhase(this.currentPhase))
+            : this.config.qaCycle
+                ? completionPromptForQaCycle(this.currentQaGate)
+                : this.config.developCycle
+                    ? completionPromptForDevelopCycle(this.currentPhase)
+                    : completionPromptForPhase(this.currentPhase);
     }
     toolDefinitions() {
-        return completionToolNamesForServer(this.config).map((name) => toolDefinition(name, phaseFromToolName(name)));
+        return completionToolNamesForServer(this.config).map((name) => toolDefinition(name, phaseFromToolName(name), qaGateFromToolName(name)));
     }
     async callTool(toolName, input) {
         const requestedPhase = phaseFromToolName(toolName);
         if (this.completed) {
-            throw new Error("Forge develop cycle is already complete; no more phase completion calls are accepted.");
+            throw new Error("Forge completion cycle is already complete; no more completion calls are accepted.");
+        }
+        if (this.config.debugCycle) {
+            return await this.callDebugGateTool(toolName, requestedPhase, input);
+        }
+        if (this.config.qaCycle) {
+            return await this.callQaGateTool(toolName, requestedPhase, input);
         }
         if (requestedPhase !== this.currentPhase) {
             throw new Error(`Tool ${toolName} is out of order. Current Forge phase is ${this.currentPhase}.`);
@@ -229,10 +383,91 @@ export class CompletionToolServerSession {
             }
         };
     }
+    async callDebugGateTool(toolName, requestedPhase, input) {
+        const currentDebugGate = asDebugCompletionPhase(this.currentPhase);
+        if (!isDebugCompletionPhase(requestedPhase)) {
+            throw new Error(`Tool ${toolName} is not available in Debug-cycle mode. Current Forge Debug gate is ${currentDebugGate}.`);
+        }
+        if (requestedPhase !== currentDebugGate) {
+            throw new Error(`Tool ${toolName} is out of order. Current Forge Debug gate is ${currentDebugGate}.`);
+        }
+        const completedGate = currentDebugGate;
+        const reference = await writeCompletionArtifact({ ...this.config, phase: completedGate }, toolName, input);
+        const status = reference.status.trim().toLowerCase();
+        const pass = status === "pass";
+        const nextGate = pass ? this.advanceAfterDebugGate(completedGate) : completedGate;
+        const nextPhase = nextGate ?? "qa_ready";
+        const nextInstruction = completionToolNextInstructionForDebugGate(completedGate, status, nextGate);
+        const reason = pass
+            ? `${completedGate} artifact accepted${nextGate ? `; continue to ${nextGate}.` : "; Debug regression is QA-ready."}`
+            : `${completedGate} artifact recorded with status ${status}; rework is required before Debug progression.`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Forge recorded ${completedGate} artifact ${path.relative(reference.repoPath, reference.path)} (${reference.status}, ${reference.contentHash}). ${nextInstruction}`
+                }
+            ],
+            structuredContent: {
+                ...reference,
+                gate: {
+                    phase: completedGate,
+                    status,
+                    allowed: pass,
+                    reason
+                },
+                nextPhase,
+                nextInstruction
+            }
+        };
+    }
+    async callQaGateTool(toolName, requestedPhase, input) {
+        const requestedGate = qaGateFromToolName(toolName);
+        if (requestedPhase !== "qa" || !requestedGate) {
+            throw new Error(`Tool ${toolName} is not available in QA-cycle mode. Current Forge QA gate is ${this.currentQaGate}.`);
+        }
+        if (requestedGate !== this.currentQaGate) {
+            throw new Error(`Tool ${toolName} is out of order. Current Forge QA gate is ${this.currentQaGate}.`);
+        }
+        const completedGate = this.currentQaGate;
+        const reference = await writeCompletionArtifact({ ...this.config, phase: "qa" }, toolName, input);
+        const status = reference.status.trim().toLowerCase();
+        const nextGate = this.advanceAfterQaGate(completedGate);
+        const nextPhase = nextGate ? "qa" : "sign_off_ready";
+        const nextInstruction = completionToolNextInstructionForQaGate(completedGate, status, nextGate);
+        const allowed = status !== "blocked";
+        const reason = nextGate
+            ? `${completedGate} artifact accepted; continue to ${nextGate}.`
+            : `QA verdict artifact accepted with status ${status}.`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Forge recorded ${completedGate} artifact ${path.relative(reference.repoPath, reference.path)} (${reference.status}, ${reference.contentHash}). ${nextInstruction}`
+                }
+            ],
+            structuredContent: {
+                ...reference,
+                gate: {
+                    phase: "qa",
+                    qaGate: completedGate,
+                    status,
+                    allowed,
+                    reason
+                },
+                nextPhase,
+                nextInstruction
+            }
+        };
+    }
     advanceAfterPass(phase) {
         if (phase === "qa") {
+            this.completed = true;
             return "sign_off_ready";
         }
+        if (isDebugCompletionPhase(phase)) {
+            return nextDebugPhaseAfter(phase) ?? "qa_ready";
+        }
         const next = nextPhaseAfter(phase);
         if (!this.config.developCycle) {
             return next ?? "dev_test_ready";
@@ -244,12 +479,36 @@ export class CompletionToolServerSession {
         this.completed = true;
         return "dev_test_ready";
     }
+    advanceAfterQaGate(gate) {
+        const index = qaCompletionGateOrder.indexOf(gate);
+        const next = index >= 0 ? qaCompletionGateOrder[index + 1] ?? null : null;
+        if (next) {
+            this.currentQaGate = next;
+            return next;
+        }
+        this.completed = true;
+        return null;
+    }
+    advanceAfterDebugGate(gate) {
+        const index = debugCompletionPhaseOrder.indexOf(gate);
+        const next = index >= 0 ? debugCompletionPhaseOrder[index + 1] ?? null : null;
+        if (next) {
+            this.currentPhase = next;
+            return next;
+        }
+        this.completed = true;
+        return null;
+    }
 }
 export async function writeCompletionArtifact(config, toolName, input) {
     const phase = phaseFromToolName(toolName);
     if (phase !== config.phase) {
         throw new Error(`Tool ${toolName} is not allowed for phase ${config.phase}.`);
     }
+    const qaGate = qaGateFromToolName(toolName);
+    if (qaGate && qaGate !== "qa_verdict") {
+        return await writeQaGateCompletionArtifact(config, qaGate, input);
+    }
     const payload = asRecord(input, "completion payload");
     const status = normalizeCompletionStatus(requiredString(payload, "status"), phase);
     const validationPayload = { ...payload, status };
@@ -266,6 +525,8 @@ export async function writeCompletionArtifact(config, toolName, input) {
     const artifactWithoutHash = normalizeArtifactPayload(redactedPayload, {
         phase,
         workItemId: config.workItemId,
+        ownerType: config.ownerType,
+        ownerId: config.ownerId,
         producedBy,
         status
     });
@@ -284,6 +545,51 @@ export async function writeCompletionArtifact(config, toolName, input) {
     return {
         phase,
         workItemId: config.workItemId,
+        ...artifactReferenceOwnerFields(config),
+        repoPath: path.resolve(config.worktreePath),
+        path: artifactPath,
+        reportPath,
+        contentHash,
+        status,
+        producedBy
+    };
+}
+async function writeQaGateCompletionArtifact(config, gate, input) {
+    const payload = asRecord(input, "QA gate completion payload");
+    const status = normalizeQaGateStatus(requiredString(payload, "status"));
+    validateQaGatePayloadShape(gate, payload, status);
+    validateOptionalWorkItemId(payload, config.workItemId);
+    const redactedPayload = redactSecrets({ ...payload, status }, 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);
+    const fileName = qaGateFileNames[gate];
+    const artifactPath = path.join(artifactRoot, fileName);
+    const reportPath = path.join(artifactRoot, "qa.report.md");
+    const artifactWithoutHash = normalizeQaGateArtifactPayload(redactedPayload, {
+        gate,
+        workItemId: config.workItemId,
+        ownerType: config.ownerType,
+        ownerId: config.ownerId,
+        producedBy,
+        status
+    });
+    const contentHash = sha256(stableStringify(artifactWithoutHash));
+    const artifact = {
+        ...artifactWithoutHash,
+        content_hash: contentHash
+    };
+    await fs.mkdir(artifactRoot, { recursive: true });
+    await writeFileAtomic(artifactPath, jsonText(artifact));
+    return {
+        phase: "qa",
+        workItemId: config.workItemId,
+        ...artifactReferenceOwnerFields(config),
         repoPath: path.resolve(config.worktreePath),
         path: artifactPath,
         reportPath,
@@ -293,19 +599,28 @@ export async function writeCompletionArtifact(config, toolName, input) {
     };
 }
 async function writeQaCompletionArtifact(config, payload, status, producedBy) {
-    const artifactRoot = artifactRootFor(config.worktreePath, config.workItemId);
+    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);
     const planPath = path.join(artifactRoot, "qa.plan.json");
     const evidencePath = path.join(artifactRoot, "qa.evidence.json");
     const findingsPath = path.join(artifactRoot, "qa.findings.json");
     const verdictPath = path.join(artifactRoot, "qa.verdict.json");
     const reportPath = path.join(artifactRoot, "qa.report.md");
-    const relativeEvidencePath = qaArtifactRelativePath(config.workItemId, "qa.evidence.json");
-    const relativeFindingsPath = qaArtifactRelativePath(config.workItemId, "qa.findings.json");
-    const relativeReportPath = qaArtifactRelativePath(config.workItemId, "qa.report.md");
+    const relativeEvidencePath = ownerFields.owner_type && ownerFields.owner_id
+        ? qaArtifactRelativePathForOwner(ownerFields.owner_type, ownerFields.owner_id, "qa.evidence.json")
+        : qaArtifactRelativePath(config.workItemId, "qa.evidence.json");
+    const relativeFindingsPath = ownerFields.owner_type && ownerFields.owner_id
+        ? qaArtifactRelativePathForOwner(ownerFields.owner_type, ownerFields.owner_id, "qa.findings.json")
+        : qaArtifactRelativePath(config.workItemId, "qa.findings.json");
+    const relativeReportPath = ownerFields.owner_type && ownerFields.owner_id
+        ? qaArtifactRelativePathForOwner(ownerFields.owner_type, ownerFields.owner_id, "qa.report.md")
+        : qaArtifactRelativePath(config.workItemId, "qa.report.md");
     const evidenceSource = qaEvidenceSource(payload);
     const commands = qaArray(payload, "commands", evidenceSource);
     const browserChecks = qaArray(payload, "browser_checks", evidenceSource);
-    const sidecars = await validateQaSidecarReferences(config.worktreePath, config.workItemId, qaArray(payload, "sidecars", evidenceSource));
+    const sidecars = await validateQaSidecarReferences(config.worktreePath, config.workItemId, qaArray(payload, "sidecars", evidenceSource), ownerFields.owner_type, ownerFields.owner_id);
     const notes = optionalString(payload, "notes") ?? optionalString(evidenceSource, "notes") ?? "";
     const findings = qaObjectArray(payload, "findings");
     const candidateBugs = qaObjectArray(payload, "candidate_bugs");
@@ -317,12 +632,14 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
     const planJson = jsonText({
         schema_version: 1,
         phase: "qa",
+        ...ownerFields,
         checklist: checklist.length > 0 ? checklist : defaultQaChecklist(status),
         acceptance_criteria: testedAcceptanceCriteria
     });
     const evidenceJson = jsonText({
         schema_version: 1,
         phase: "qa",
+        ...ownerFields,
         commands,
         browser_checks: browserChecks,
         sidecars,
@@ -331,6 +648,7 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
     const findingsJson = jsonText({
         schema_version: 1,
         phase: "qa",
+        ...ownerFields,
         findings,
         candidate_bugs: candidateBugs
     });
@@ -350,6 +668,7 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
     const verdictWithoutHash = {
         schema_version: numberOrDefault(payload.schema_version, 1),
         phase: "qa",
+        ...ownerFields,
         status,
         summary: requiredString(payload, "summary"),
         tested_acceptance_criteria: testedAcceptanceCriteria,
@@ -381,6 +700,7 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
     return {
         phase: "qa",
         workItemId: config.workItemId,
+        ...artifactReferenceOwnerFields(config),
         repoPath: path.resolve(config.worktreePath),
         path: verdictPath,
         reportPath,
@@ -389,11 +709,13 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
         producedBy
     };
 }
-async function validateQaSidecarReferences(worktreePath, workItemId, sidecars) {
+async function validateQaSidecarReferences(worktreePath, workItemId, sidecars, ownerType, ownerId) {
     if (sidecars.length === 0) {
         return [];
     }
-    const artifactRoot = artifactRootFor(worktreePath, workItemId);
+    const artifactRoot = ownerType && ownerId
+        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
+        : artifactRootFor(worktreePath, workItemId);
     const qaSidecarRoot = path.resolve(artifactRoot, "qa");
     const validated = [];
     for (const [index, sidecar] of sidecars.entries()) {
@@ -412,7 +734,7 @@ async function validateQaSidecarReferences(worktreePath, workItemId, sidecars) {
         }
         const fullPath = path.resolve(worktreePath, sidecarPath);
         if (!isPathUnderRoot(qaSidecarRoot, fullPath)) {
-            throw new Error(`sidecars[${index}].path must be under .forge/work-items/${workItemId}/artifacts/qa/.`);
+            throw new Error(`sidecars[${index}].path must be under ${artifactOwnerRelativeRoot(ownerType, ownerId, workItemId)}/qa/.`);
         }
         const stat = await fs.lstat(fullPath).catch((error) => {
             if (isNodeError(error) && error.code === "ENOENT") {
@@ -484,8 +806,12 @@ export function parseCompletionMcpArgs(argv) {
     let worktreePath = null;
     let workItemId = null;
     let phase = "implementation";
+    let ownerType;
+    let ownerId;
     let producedBy;
     let developCycle = false;
+    let qaCycle = false;
+    let debugCycle = false;
     for (let index = 1; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === "--worktree") {
@@ -494,11 +820,20 @@ export function parseCompletionMcpArgs(argv) {
         else if (arg === "--work-item-id") {
             workItemId = argv[++index] ?? null;
         }
+        else if (arg === "--owner-type") {
+            ownerType = normalizedOwnerType(argv[++index]);
+            if (!ownerType) {
+                return { ok: false, error: "mcp --owner-type must be work_item or story." };
+            }
+        }
+        else if (arg === "--owner-id") {
+            ownerId = argv[++index] ?? undefined;
+        }
         else if (arg === "--phase") {
             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." };
+                return { ok: false, error: "mcp --phase must be one of: implementation, self-review, validation, qa, debug-repro, debug-root-cause, debug-fix, debug-regression." };
             }
             phase = parsedPhase;
         }
@@ -508,6 +843,12 @@ export function parseCompletionMcpArgs(argv) {
         else if (arg === "--develop-cycle") {
             developCycle = true;
         }
+        else if (arg === "--qa-cycle") {
+            qaCycle = true;
+        }
+        else if (arg === "--debug-cycle") {
+            debugCycle = true;
+        }
         else {
             return { ok: false, error: `Unknown mcp argument: ${arg}` };
         }
@@ -515,15 +856,31 @@ export function parseCompletionMcpArgs(argv) {
     if (!worktreePath?.trim() || !workItemId?.trim()) {
         return { ok: false, error: "mcp requires --worktree and --work-item-id." };
     }
+    if ([developCycle, qaCycle, debugCycle].filter(Boolean).length > 1) {
+        return { ok: false, error: "mcp accepts only one cycle mode." };
+    }
+    if (developCycle && !isDevelopCompletionPhase(phase)) {
+        return { ok: false, error: "mcp --develop-cycle requires --phase implementation, self-review, or validation." };
+    }
+    if (qaCycle && phase !== "qa") {
+        return { ok: false, error: "mcp --qa-cycle requires --phase qa." };
+    }
+    if (debugCycle && !isDebugCompletionPhase(phase)) {
+        return { ok: false, error: "mcp --debug-cycle requires --phase debug-repro, debug-root-cause, debug-fix, or debug-regression." };
+    }
     return {
         ok: true,
         config: {
             worktreePath: path.resolve(worktreePath),
             workItemId,
+            ownerType,
+            ownerId,
             phase,
             producedBy,
             redactionSecrets: parseCompletionRedactionSecrets(process.env[completionRedactionSecretsEnv]),
-            developCycle
+            developCycle,
+            qaCycle,
+            debugCycle
         }
     };
 }
@@ -618,17 +975,24 @@ async function handleJsonRpcRequest(session, method, params) {
     }
     throw new Error(`Unsupported MCP method: ${method}`);
 }
-function toolDefinition(name, phase) {
+function toolDefinition(name, phase, qaGate = null) {
     return {
         name,
-        description: toolDescription(phase),
-        inputSchema: toolInputSchema(phase)
+        description: toolDescription(phase, qaGate),
+        inputSchema: toolInputSchema(phase, qaGate)
     };
 }
 function nextPhaseAfter(phase) {
+    if (!isDevelopCompletionPhase(phase)) {
+        return null;
+    }
     const index = completionPhaseOrder.indexOf(phase);
     return index >= 0 ? completionPhaseOrder[index + 1] ?? null : null;
 }
+function nextDebugPhaseAfter(phase) {
+    const index = debugCompletionPhaseOrder.indexOf(phase);
+    return index >= 0 ? debugCompletionPhaseOrder[index + 1] ?? null : null;
+}
 function completionToolNextInstruction(completedPhase, status, nextPhase) {
     if (completedPhase === "qa") {
         if (status === "blocked") {
@@ -642,6 +1006,10 @@ function completionToolNextInstruction(completedPhase, status, nextPhase) {
     if (status !== "pass") {
         return `Stay in ${completedPhase}, address the recorded blockers, then call ${expectedCompletionToolName(completedPhase)} again.`;
     }
+    if (isDebugCompletionPhase(completedPhase)) {
+        const debugNext = isDebugCompletionPhase(nextPhase) ? nextPhase : null;
+        return completionToolNextInstructionForDebugGate(completedPhase, status, debugNext);
+    }
     if (nextPhase === "self_review") {
         return "Implementation accepted. Begin self-review: inspect the diff, apply safe fixes, and call forge.complete_self_review with review evidence.";
     }
@@ -650,7 +1018,67 @@ function completionToolNextInstruction(completedPhase, status, nextPhase) {
     }
     return "Validation accepted. Forge has the structured evidence needed to move this work item to QA.";
 }
-function toolDescription(phase) {
+function completionToolNextInstructionForQaGate(completedGate, status, nextGate) {
+    if (!nextGate) {
+        if (status === "blocked") {
+            return "QA blocked. Forge recorded the blocker reason and will surface the run for human attention.";
+        }
+        if (status === "needs_rework") {
+            return "QA findings recorded. Forge has the structured evidence needed to route this work back for implementation rework.";
+        }
+        return "QA accepted. Forge has the structured evidence needed to move this work item to Sign-Off.";
+    }
+    const skipped = status === "skipped";
+    const blocked = status === "blocked";
+    const prefix = blocked
+        ? `${completedGate} recorded a blocker. Continue through ${nextGate} and mark downstream gates skipped if the blocker prevents evidence collection.`
+        : skipped
+            ? `${completedGate} skipped. Continue to ${nextGate}.`
+            : `${completedGate} accepted. Continue to ${nextGate}.`;
+    return `${prefix} ${qaGateInstruction(nextGate)}`;
+}
+function completionToolNextInstructionForDebugGate(completedGate, status, nextGate) {
+    if (status !== "pass") {
+        return `Stay in ${completedGate}, address the recorded blockers, then call ${expectedDebugCompletionToolName(completedGate)} again.`;
+    }
+    if (nextGate === "debug_root_cause") {
+        return "Debug repro accepted. Begin root-cause analysis: connect the observed failure to code evidence and call forge.complete_debug_root_cause.";
+    }
+    if (nextGate === "debug_fix") {
+        return "Debug root cause accepted. Apply the smallest safe fix with regression coverage where practical, then call forge.complete_debug_fix.";
+    }
+    if (nextGate === "debug_regression") {
+        return "Debug fix accepted. Prove the original repro is negative, run targeted regression checks, and call forge.complete_debug_regression.";
+    }
+    return "Debug regression accepted. Forge has the structured evidence needed to move this bug fix to QA.";
+}
+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.";
+        case "qa_api":
+            return "Run or explicitly skip applicable API/backend contract checks, then call forge.complete_qa_api.";
+        case "qa_manual_web":
+            return "Run or explicitly skip applicable browser/manual web checks, then call forge.complete_qa_manual_web.";
+        case "qa_bug_repro":
+            return "Reproduce or explicitly skip relevant defects/candidate bugs, then call forge.complete_qa_bug_repro.";
+        case "qa_findings":
+            return "Normalize observations into findings and candidate bugs, then call forge.complete_qa_findings.";
+        case "qa_verdict":
+            return "Assemble the final QA verdict from all prior gate evidence, then call forge.complete_qa_verdict.";
+        case "qa_plan":
+            return "Prepare the QA checklist, then call forge.complete_qa_plan.";
+    }
+}
+function toolDescription(phase, qaGate = null) {
+    if (qaGate) {
+        return qaGate === "qa_verdict"
+            ? "Complete the final Forge QA verdict by writing the canonical QA bundle with pass, needs_rework, or blocked evidence."
+            : `Complete the ${qaGate.replace(/_/g, " ")} QA gate by writing ${qaGateFileNames[qaGate]} before continuing to the next QA gate.`;
+    }
+    if (isDebugCompletionPhase(phase)) {
+        return `Complete the ${phase.replace(/_/g, " ")} Debug gate by writing ${phaseFiles[phase].jsonFileName} with structured bug-fix evidence before continuing.`;
+    }
     if (phase === "implementation") {
         return "Complete Forge implementation by writing implementation.completeness.json with scoped changed-file, verification, acceptance-criteria, gap, and next-phase evidence.";
     }
@@ -662,7 +1090,7 @@ function toolDescription(phase) {
     }
     return "Complete Forge validation by writing validation.verdict.json with command, build/test/lint/design, drift, acceptance-criteria, and ready-for-dev-test evidence.";
 }
-function toolInputSchema(phase) {
+function toolInputSchema(phase, qaGate = null) {
     const baseProperties = {
         status: {
             type: "string",
@@ -681,6 +1109,12 @@ function toolInputSchema(phase) {
             })
         }
     };
+    if (qaGate && qaGate !== "qa_verdict") {
+        return qaGateToolInputSchema(qaGate);
+    }
+    if (isDebugCompletionPhase(phase)) {
+        return debugToolInputSchema(phase, baseProperties);
+    }
     if (phase === "implementation") {
         return objectToolSchema({
             ...baseProperties,
@@ -893,6 +1327,144 @@ function toolInputSchema(phase) {
         ready_for_dev_test: { type: "boolean", description: "Required for pass and must be true." }
     }, ["status", "summary"], "For status pass, commands must include at least one passing deterministic command, acceptance criteria entries must use status: satisfied plus evidence, and ready_for_dev_test must be true.");
 }
+function debugToolInputSchema(phase, baseProperties) {
+    if (phase === "debug_repro") {
+        return objectToolSchema({
+            ...baseProperties,
+            repro_steps: {
+                type: "array",
+                description: "Required for pass. Minimal reproduction or characterization steps.",
+                items: { type: "string" }
+            },
+            observed: { type: "string", description: "Observed failure behavior." },
+            expected: { type: "string", description: "Expected behavior." },
+            evidence: {
+                type: "array",
+                description: "Required for pass. Concrete logs, commands, screenshots, file refs, or characterization notes.",
+                items: { type: "object", additionalProperties: true }
+            }
+        }, ["status", "summary"], "For status pass, include repro_steps, observed, expected, and evidence.");
+    }
+    if (phase === "debug_root_cause") {
+        return objectToolSchema({
+            ...baseProperties,
+            root_cause: { type: "string", description: "Likely root cause tied to code or config evidence." },
+            evidence: {
+                type: "array",
+                description: "Required for pass. Concrete code/log/test evidence supporting the root cause.",
+                items: { type: "object", additionalProperties: true }
+            },
+            eliminated_alternatives: {
+                type: "array",
+                description: "Required for pass. Plausible alternatives checked or ruled out.",
+                items: { type: "object", additionalProperties: true }
+            },
+            risk_area: { type: "string", description: "Subsystem or behavior most at risk from the fix." }
+        }, ["status", "summary"], "For status pass, include root_cause, evidence, eliminated_alternatives, and risk_area.");
+    }
+    if (phase === "debug_fix") {
+        return objectToolSchema({
+            ...baseProperties,
+            changed_files: {
+                type: "array",
+                description: "Required for pass. Files changed by the bug fix.",
+                items: evidenceObjectSchema(["path", "summary"], { path: { type: "string" }, summary: { type: "string" } })
+            },
+            tests_added_or_updated: {
+                type: "array",
+                description: "Required for pass. Regression tests or checks added/updated, or justify omission in remaining_risks.",
+                items: evidenceObjectSchema(["path", "summary"], { path: { type: "string" }, summary: { type: "string" } })
+            },
+            remaining_risks: {
+                type: "array",
+                description: "Required for pass, even when empty. Include why no regression coverage changed when tests_added_or_updated is empty.",
+                items: evidenceObjectSchema(["summary"], { summary: { type: "string" }, mitigation: { type: "string" } })
+            },
+            resolved_findings: {
+                type: "array",
+                description: "Required for QA rework. Entries should include qa_id, status, summary, evidence, changed_files, tests_added_or_updated, and regression_evidence.",
+                items: { type: "object", additionalProperties: true }
+            }
+        }, ["status", "summary"], "For status pass, include changed_files, tests_added_or_updated, and remaining_risks.");
+    }
+    return objectToolSchema({
+        ...baseProperties,
+        commands: {
+            type: "array",
+            description: "Required for pass. Targeted regression/repro-negative commands with exit_code: 0 and status: pass.",
+            items: commandEvidenceSchema()
+        },
+        required_regressions: {
+            type: "array",
+            description: "Required for pass. Repro-negative and regression coverage checklist.",
+            items: { type: "string" }
+        },
+        build_status: { type: "string", description: "Required for pass. pass or not_applicable." },
+        test_status: { type: "string", description: "Required for pass. pass or not_applicable." },
+        repro_negative: { type: "boolean", description: "Required for pass and must be true after the original repro no longer fails." },
+        qa_ready: { type: "boolean", description: "Required for pass and must be true." }
+    }, ["status", "summary"], "For status pass, commands must include at least one passing deterministic debug regression check, repro_negative must be true, and qa_ready must be true.");
+}
+function qaGateToolInputSchema(gate) {
+    const baseProperties = {
+        status: {
+            type: "string",
+            enum: ["pass", "skipped", "blocked"],
+            description: "Use pass when this QA gate produced evidence, skipped when not applicable, or blocked when a prerequisite prevents this gate."
+        },
+        summary: { type: "string", description: "Concise QA gate summary." },
+        reason: { type: "string", description: "Required for skipped or blocked gates." },
+        blocker_reason: {
+            type: "string",
+            enum: [...qaBlockerReasons],
+            description: "Required when status is blocked."
+        }
+    };
+    if (gate === "qa_plan") {
+        return objectToolSchema({
+            ...baseProperties,
+            checklist: {
+                type: "array",
+                description: "Required for pass. QA checklist entries planned for this work item.",
+                items: { type: "string" }
+            },
+            acceptance_criteria: {
+                type: "array",
+                description: "Acceptance criteria selected for QA.",
+                items: { type: "string" }
+            }
+        }, ["status", "summary"], "Record the QA plan gate. Pass requires a non-empty checklist.");
+    }
+    if (gate === "qa_findings") {
+        return objectToolSchema({
+            ...baseProperties,
+            findings: {
+                type: "array",
+                description: "Normalized in-scope and out-of-scope QA findings.",
+                items: { type: "object", additionalProperties: true }
+            },
+            candidate_bugs: {
+                type: "array",
+                description: "Out-of-scope or follow-up candidates.",
+                items: { type: "object", additionalProperties: true }
+            }
+        }, ["status", "summary"], "Record normalized QA findings. Pass or skipped requires findings and candidate_bugs arrays, even when empty.");
+    }
+    return objectToolSchema({
+        ...baseProperties,
+        commands: {
+            type: "array",
+            description: "Command evidence for this gate when applicable.",
+            items: commandEvidenceSchema()
+        },
+        browser_checks: {
+            type: "array",
+            description: "Browser/manual evidence for this gate when applicable.",
+            items: { type: "object", additionalProperties: true }
+        },
+        notes: { type: "string", description: "Evidence notes for this gate." }
+    }, ["status", "summary"], "Record this QA evidence gate. Use skipped with a reason when the gate is not applicable.");
+}
 function objectToolSchema(properties, required, description) {
     return {
         type: "object",
@@ -962,6 +1534,13 @@ function normalizeCompletionStatus(value, phase) {
     }
     return canonical;
 }
+function normalizeQaGateStatus(value) {
+    const normalized = value.trim().toLowerCase().replace(/-/g, "_");
+    if (normalized !== "pass" && normalized !== "skipped" && normalized !== "blocked") {
+        throw new Error("QA gate status must be pass, skipped, or blocked.");
+    }
+    return normalized;
+}
 function validatePayloadShape(phase, payload) {
     const status = normalizeCompletionStatus(requiredString(payload, "status"), phase);
     if (!status) {
@@ -977,6 +1556,10 @@ function validatePayloadShape(phase, payload) {
         requireNonPassEvidence(payload);
         return;
     }
+    if (isDebugCompletionPhase(phase)) {
+        validateDebugPayloadShape(phase, payload);
+        return;
+    }
     if (phase === "implementation") {
         requireArray(payload, "plan");
         requireArray(payload, "changed_files");
@@ -1014,6 +1597,86 @@ function validatePayloadShape(phase, payload) {
     requirePassingCommands(payload);
     requireSatisfiedAcceptanceCriteria(payload);
 }
+function validateDebugPayloadShape(phase, payload) {
+    if (phase === "debug_repro") {
+        requireArray(payload, "repro_steps");
+        requireField(payload, "observed");
+        requireField(payload, "expected");
+        requireArray(payload, "evidence");
+        requireNonEmptyArray(payload, "repro_steps");
+        requireNonEmptyArray(payload, "evidence");
+        return;
+    }
+    if (phase === "debug_root_cause") {
+        requireField(payload, "root_cause");
+        requireArray(payload, "evidence");
+        requireArray(payload, "eliminated_alternatives");
+        requireField(payload, "risk_area");
+        requireNonEmptyArray(payload, "evidence");
+        return;
+    }
+    if (phase === "debug_fix") {
+        requireArray(payload, "changed_files");
+        requireArray(payload, "tests_added_or_updated");
+        requireArray(payload, "remaining_risks");
+        requireNonEmptyArray(payload, "changed_files");
+        if (arrayLength(payload, "tests_added_or_updated") === 0 && arrayLength(payload, "remaining_risks") === 0) {
+            throw new Error("tests_added_or_updated is empty; remaining_risks must explain why no regression coverage changed.");
+        }
+        return;
+    }
+    requireArray(payload, "commands");
+    requireArray(payload, "required_regressions");
+    requireField(payload, "build_status");
+    requireField(payload, "test_status");
+    requireBoolean(payload, "repro_negative");
+    requireBoolean(payload, "qa_ready");
+    if (payload.repro_negative !== true) {
+        throw new Error("debug_regression pass requires repro_negative: true.");
+    }
+    if (payload.qa_ready !== true) {
+        throw new Error("debug_regression pass requires qa_ready: true.");
+    }
+    requireAllowedStatus(payload, "build_status", ["pass", "not_applicable"]);
+    requireAllowedStatus(payload, "test_status", ["pass", "not_applicable"]);
+    requireNonEmptyArray(payload, "required_regressions");
+    requirePassingCommands(payload);
+}
+function validateQaGatePayloadShape(gate, payload, status) {
+    requireField(payload, "summary");
+    if (status === "skipped") {
+        requireField(payload, "reason");
+    }
+    if (status === "blocked") {
+        const reason = normalizedString(optionalString(payload, "blocker_reason"));
+        if (!qaBlockerReasons.has(reason)) {
+            throw new Error("QA gate blocked requires blocker_reason to be one of missing_app_launch_target, inconclusive, environment_failure, missing_validation_evidence, missing_worktree, or runner_failure.");
+        }
+    }
+    if (gate === "qa_plan" && status === "pass") {
+        const checklist = qaStringArray(payload, "checklist");
+        if (checklist.length === 0) {
+            throw new Error("complete_qa_plan pass requires checklist with at least one entry.");
+        }
+    }
+    if (gate === "qa_findings" && status !== "blocked") {
+        qaObjectArray(payload, "findings");
+        qaObjectArray(payload, "candidate_bugs");
+    }
+    if ((gate === "qa_regression" || gate === "qa_api") && status === "pass") {
+        const commands = qaArray(payload, "commands");
+        if (commands.length === 0) {
+            throw new Error(`${qaGateToolNames[gate]} pass requires commands with at least one entry.`);
+        }
+    }
+    if (gate === "qa_manual_web" && status === "pass") {
+        const browserChecks = qaArray(payload, "browser_checks");
+        const notes = optionalString(payload, "notes");
+        if (browserChecks.length === 0 && !notes) {
+            throw new Error(`${qaGateToolNames[gate]} pass requires browser_checks or notes.`);
+        }
+    }
+}
 function validateQaPayloadShape(payload, status) {
     const evidenceSource = qaEvidenceSource(payload);
     const commands = qaArray(payload, "commands", evidenceSource);
@@ -1153,10 +1816,36 @@ function normalizeArtifactPayload(payload, defaults) {
     normalized.schema_version = numberOrDefault(normalized.schema_version, 1);
     normalized.phase = defaults.phase;
     normalized.work_item_id = defaults.workItemId;
+    const ownerFields = artifactOwnerFields(defaults);
+    Object.assign(normalized, ownerFields);
     normalized.status = defaults.status;
     normalized.produced_by = defaults.producedBy;
     return normalized;
 }
+function normalizeQaGateArtifactPayload(payload, defaults) {
+    const normalized = stripUndefined({ ...payload });
+    delete normalized.report_markdown;
+    delete normalized.content_hash;
+    delete normalized.contentHash;
+    normalized.schema_version = numberOrDefault(normalized.schema_version, 1);
+    normalized.phase = "qa";
+    normalized.gate = defaults.gate;
+    normalized.work_item_id = defaults.workItemId;
+    const ownerFields = artifactOwnerFields(defaults);
+    Object.assign(normalized, ownerFields);
+    normalized.status = defaults.status;
+    normalized.produced_by = defaults.producedBy;
+    if (defaults.gate === "qa_plan") {
+        const checklist = qaStringArray(normalized, "checklist");
+        normalized.checklist = checklist.length > 0 ? checklist : defaultQaChecklist(defaults.status);
+        normalized.acceptance_criteria = qaStringArray(normalized, "acceptance_criteria");
+    }
+    if (defaults.gate === "qa_findings") {
+        normalized.findings = qaObjectArray(normalized, "findings");
+        normalized.candidate_bugs = qaObjectArray(normalized, "candidate_bugs");
+    }
+    return normalized;
+}
 function reportMarkdown(payload, phase, status, producedBy, contentHash) {
     const explicit = optionalString(payload, "report_markdown");
     if (explicit) {
@@ -1176,6 +1865,10 @@ ${summary}
 }
 function parseStrictCompletionPhase(value) {
     const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    const debugPhase = normalizeDebugCompletionPhase(normalized);
+    if (debugPhase) {
+        return debugPhase;
+    }
     if (normalized === "implementation" || normalized === "implement" || normalized === "develop") {
         return "implementation";
     }
@@ -1190,6 +1883,43 @@ function parseStrictCompletionPhase(value) {
     }
     return null;
 }
+function normalizeDebugCompletionPhase(value) {
+    const normalized = (value ?? "").trim().toLowerCase().replace(/-/g, "_");
+    switch (normalized) {
+        case "debug_repro":
+        case "debugrepro":
+        case "repro":
+        case "reproduce":
+            return "debug_repro";
+        case "debug_root_cause":
+        case "debugrootcause":
+        case "root_cause":
+        case "rootcause":
+            return "debug_root_cause";
+        case "debug_fix":
+        case "debugfix":
+        case "fix":
+            return "debug_fix";
+        case "debug_regression":
+        case "debugregression":
+        case "regression":
+            return "debug_regression";
+        default:
+            return null;
+    }
+}
+function isDevelopCompletionPhase(phase) {
+    return phase === "implementation" || phase === "self_review" || phase === "validation";
+}
+function isDebugCompletionPhase(phase) {
+    return debugCompletionPhaseOrder.includes(phase);
+}
+function asDebugCompletionPhase(phase) {
+    if (isDebugCompletionPhase(phase)) {
+        return phase;
+    }
+    throw new Error(`Expected Debug completion phase, got ${phase}.`);
+}
 function parseCompletionRedactionSecrets(raw) {
     if (!raw?.trim()) {
         return [];
@@ -1219,8 +1949,35 @@ function phaseFromToolName(toolName) {
     if (normalized === "forge.complete_qa" || normalized === "complete_qa") {
         return "qa";
     }
+    const debugGate = debugGateFromToolName(toolName);
+    if (debugGate) {
+        return debugGate;
+    }
+    if (qaGateFromToolName(toolName)) {
+        return "qa";
+    }
     throw new Error(`Unknown Forge completion tool: ${toolName}`);
 }
+function debugGateFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    for (const gate of debugCompletionPhaseOrder) {
+        const base = debugGateToolNames[gate];
+        if (normalized === `forge.${base}` || normalized === base) {
+            return gate;
+        }
+    }
+    return null;
+}
+function qaGateFromToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    for (const gate of qaCompletionGateOrder) {
+        const base = qaGateToolNames[gate];
+        if (normalized === `forge.${base}` || normalized === base) {
+            return gate;
+        }
+    }
+    return null;
+}
 function requireField(payload, key) {
     if (payload[key] === undefined || payload[key] === null || (typeof payload[key] === "string" && payload[key].trim().length === 0)) {
         throw new Error(`${key} is required.`);
@@ -1288,6 +2045,22 @@ function requireArray(payload, key) {
         throw new Error(`${key} must be an array.`);
     }
 }
+function requireNonEmptyArray(payload, key) {
+    requireArray(payload, key);
+    if (arrayLength(payload, key) === 0) {
+        throw new Error(`${key} must include at least one value.`);
+    }
+}
+function arrayLength(payload, key) {
+    const value = payload[key];
+    return Array.isArray(value) ? value.length : 0;
+}
+function requireAllowedStatus(payload, key, allowed) {
+    const value = normalizedString(optionalString(payload, key));
+    if (!allowed.includes(value)) {
+        throw new Error(`${key} must be one of ${allowed.join(", ")}.`);
+    }
+}
 function requireObject(payload, key) {
     const value = payload[key];
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -1406,6 +2179,36 @@ function hasSubstantiveJsonValue(value) {
 function normalizedString(value) {
     return typeof value === "string" ? value.trim().toLowerCase().replace(/-/g, "_") : "";
 }
+function normalizedOwnerType(value) {
+    const normalized = normalizedString(value);
+    return normalized === "work_item" || normalized === "story" ? normalized : undefined;
+}
+function artifactOwnerFields(config) {
+    const ownerType = normalizedOwnerType(config.ownerType);
+    const ownerId = config.ownerId?.trim();
+    if (!ownerType && !ownerId) {
+        return {};
+    }
+    return {
+        owner_type: ownerType ?? "work_item",
+        owner_id: ownerId || config.workItemId
+    };
+}
+function artifactReferenceOwnerFields(config) {
+    const owner = artifactOwnerFields(config);
+    return owner.owner_type && owner.owner_id
+        ? { ownerType: owner.owner_type, ownerId: owner.owner_id }
+        : {};
+}
+function artifactOwnerDirectory(ownerType) {
+    return normalizedOwnerType(ownerType) === "story" ? "stories" : "work-items";
+}
+function artifactOwnerRelativeRoot(ownerType, ownerId, workItemId) {
+    const owner = artifactOwnerFields({ workItemId, ownerType, ownerId });
+    return owner.owner_type && owner.owner_id
+        ? [".forge", artifactOwnerDirectory(owner.owner_type), owner.owner_id, "artifacts"].join("/")
+        : [".forge", "work-items", workItemId, "artifacts"].join("/");
+}
 function defaultQaChecklist(status) {
     return [
         "Review the validated work item against acceptance criteria.",
@@ -1416,6 +2219,9 @@ function defaultQaChecklist(status) {
 function qaArtifactRelativePath(workItemId, fileName) {
     return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
 }
+function qaArtifactRelativePathForOwner(ownerType, ownerId, fileName) {
+    return [".forge", artifactOwnerDirectory(ownerType), ownerId, "artifacts", fileName].join("/");
+}
 function jsonText(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
@@ -1431,7 +2237,7 @@ function parseJsonObject(content, label) {
         return asRecord(JSON.parse(content), label);
     }
     catch (error) {
-        throw new Error(`${label} is not valid JSON: ${errorMessage(error)}`);
+        throw new Error(`${label} is not valid JSON: ${errorMessage(error)}`, { cause: error });
     }
 }
 function parseOptionalJsonObject(content, label) {