@loucompanion/forge-bridge 0.1.1-dev.9acab970e5d1 → 0.1.1-dev.ac656b52f9c6

package/dist/session/phase-completion.js

@@ -54,6 +54,8 @@ const qaBlockerReasons = new Set([
     "missing_worktree",
     "runner_failure"
 ]);
+const resolvedFindingStatusValues = ["resolved", "disputed", "not_reproduced"];
+const resolvedFindingStatuses = new Set(resolvedFindingStatusValues);
 const qaFindingSeverities = new Set(["critical", "major", "minor"]);
 const qaFindingScopes = new Set(["in_scope", "out_of_scope", "unclear"]);
 const qaCandidateBugActions = new Set(["create_bug", "create_follow_up", "accept_risk", "attach_to_current_item"]);
@@ -89,6 +91,10 @@ const phaseFiles = {
     debug_regression: {
         jsonFileName: "debug.regression.json",
         reportFileName: "debug.report.md"
+    },
+    architect: {
+        jsonFileName: "architect.verdict.json",
+        reportFileName: "architect.report.md"
     }
 };
 export function completionPhaseFromDispatch(dispatch) {
@@ -109,6 +115,9 @@ export function normalizeCompletionPhase(value) {
     if (normalized === "qa" || normalized === "quality_assurance" || normalized === "qualityassurance") {
         return "qa";
     }
+    if (normalized === "architect" || normalized === "architect_plan" || normalized === "planning" || normalized === "plan") {
+        return "architect";
+    }
     return "implementation";
 }
 export function usesDevelopCycleCompletion(dispatch) {
@@ -138,6 +147,12 @@ export function usesDebugCycleCompletion(dispatch) {
         && lane === "debug"
         && isDebugCompletionPhase(completionPhaseFromDispatch(dispatch));
 }
+export function usesArchitectCycleCompletion(dispatch) {
+    const kind = dispatch.cycleRun.kind.trim().toLowerCase();
+    const role = dispatch.execution.role.trim().toLowerCase();
+    const lane = dispatch.execution.lane.trim().toLowerCase();
+    return kind === "architect" || role === "architect" || lane === "architect";
+}
 export function completionToolNamesForPhase(phase) {
     if (isDebugCompletionPhase(phase)) {
         return completionToolNamesForDebugGate(phase);
@@ -148,7 +163,9 @@ export function completionToolNamesForPhase(phase) {
             ? "complete_self_review"
             : phase === "validation"
                 ? "complete_validation"
-                : "complete_qa";
+                : phase === "architect"
+                    ? "complete_architect_plan"
+                    : "complete_qa";
     return [`forge.${base}`, base];
 }
 export function completionToolNamesForQaGate(gate) {
@@ -171,14 +188,20 @@ export function expectedDebugCompletionToolName(gate) {
 export function artifactRootFor(worktreePath, workItemId) {
     return path.join(worktreePath, ".forge", "work-items", safePathSegment(workItemId, "work item id"), "artifacts");
 }
-function artifactRootForOwner(worktreePath, ownerType, ownerId) {
+export 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);
+export function completionArtifactJsonPath(worktreePath, workItemId, phase, ownerType, ownerId) {
+    const artifactRoot = ownerType && ownerId
+        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
+        : artifactRootFor(worktreePath, workItemId);
+    return path.join(artifactRoot, phaseFiles[phase].jsonFileName);
 }
-export function completionArtifactReportPath(worktreePath, workItemId, phase) {
-    return path.join(artifactRootFor(worktreePath, workItemId), phaseFiles[phase].reportFileName);
+export function completionArtifactReportPath(worktreePath, workItemId, phase, ownerType, ownerId) {
+    const artifactRoot = ownerType && ownerId
+        ? artifactRootForOwner(worktreePath, ownerType, ownerId)
+        : artifactRootFor(worktreePath, workItemId);
+    return path.join(artifactRoot, phaseFiles[phase].reportFileName);
 }
 export async function prepareCompletionToolRuntime(options) {
     const phase = options.phase ?? completionPhaseFromDispatch(options.dispatch);
@@ -195,7 +218,8 @@ export async function prepareCompletionToolRuntime(options) {
         producedBy: `${options.dispatch.execution.provider}-cli`,
         developCycle: usesDevelopCycleCompletion(options.dispatch),
         qaCycle: usesQaCycleCompletion(options.dispatch),
-        debugCycle: usesDebugCycleCompletion(options.dispatch)
+        debugCycle: usesDebugCycleCompletion(options.dispatch),
+        architectCycle: usesArchitectCycleCompletion(options.dispatch)
     });
     const runtime = {
         serverName: toolServerName,
@@ -234,6 +258,9 @@ export function buildCompletionToolServerArgs(config) {
     if (config.debugCycle) {
         args.push("--debug-cycle");
     }
+    if (config.architectCycle) {
+        args.push("--architect-cycle");
+    }
     return args;
 }
 export function codexMcpConfigArgs(runtime) {
@@ -266,6 +293,16 @@ Do not write QA artifacts by hand. When QA is complete, call \`${toolName}(...)\
 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\`.
 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.
 Forge will mirror only the tool-written QA artifacts; reporting QA completion in prose is not enough.`;
+    }
+    if (phase === "architect") {
+        return `Forge completion tools are available through the MCP server named \`${toolServerName}\`.
+Do not write Architect artifacts by hand. When the plan is complete, call \`${toolName}(...)\`${alias ? ` (or \`${alias}\` if your client shows unqualified MCP tool names)` : ""} with the full structured Architect planning payload.
+That tool writes \`.forge/work-items/{workItemId}/artifacts/implementation.plan.json\`, \`qa.plan.json\`, \`${artifactName}\`, and \`architect.report.md\`.
+The payload must put \`phases\`, \`tasks\`, \`dependencies\`, and \`phase_gates\` as top-level fields inside \`implementation_plan\`, for example:
+\`{ "status": "pass", "summary": "...", "implementation_plan": { "schema_version": 1, "plan_id": "plan-...", "phases": [{ "id": "phase-1", "tasks": ["task-1"], "gate": "gate-1" }], "tasks": [{ "id": "task-1", "tests": [{ "command": "npm test" }] }], "dependencies": [], "phase_gates": [{ "id": "gate-1", "phase": "phase-1" }] }, "qa_plan": { "schema_version": 1, "final_qa": [{ "id": "qa-1", "coverage": "..." }] }, "report_markdown": "# Architect Report" }\`.
+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.`;
     }
     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.
@@ -315,7 +352,9 @@ export function completionToolNamesForServer(config) {
             ? qaCompletionGateOrder.flatMap((gate) => completionToolNamesForQaGate(gate))
             : config.developCycle
                 ? completionPhaseOrder.flatMap((phase) => completionToolNamesForPhase(phase))
-                : completionToolNamesForPhase(config.phase);
+                : config.architectCycle
+                    ? completionToolNamesForPhase("architect")
+                    : completionToolNamesForPhase(config.phase);
 }
 export class CompletionToolServerSession {
     config;
@@ -511,7 +550,10 @@ export async function writeCompletionArtifact(config, toolName, input) {
     }
     const payload = asRecord(input, "completion payload");
     const status = normalizeCompletionStatus(requiredString(payload, "status"), phase);
-    const validationPayload = { ...payload, status };
+    let validationPayload = { ...payload, status };
+    if (config.qaCycle && qaGate === "qa_verdict") {
+        validationPayload = await synthesizeQaCycleVerdictPayload(config, validationPayload, status);
+    }
     validatePayloadShape(phase, validationPayload);
     validateOptionalWorkItemId(validationPayload, config.workItemId);
     const redactedPayload = redactSecrets(validationPayload, config.redactionSecrets ?? []);
@@ -522,6 +564,9 @@ export async function writeCompletionArtifact(config, toolName, input) {
     if (phase === "qa") {
         return await writeQaCompletionArtifact(config, redactedPayload, status, producedBy);
     }
+    if (phase === "architect") {
+        return await writeArchitectCompletionArtifact(config, redactedPayload, status, producedBy);
+    }
     const artifactWithoutHash = normalizeArtifactPayload(redactedPayload, {
         phase,
         workItemId: config.workItemId,
@@ -554,6 +599,48 @@ export async function writeCompletionArtifact(config, toolName, input) {
         producedBy
     };
 }
+async function writeArchitectCompletionArtifact(config, payload, status, producedBy) {
+    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 implementationPlanPath = path.join(artifactRoot, "implementation.plan.json");
+    const qaPlanPath = path.join(artifactRoot, "qa.plan.json");
+    const verdictPath = path.join(artifactRoot, "architect.verdict.json");
+    const reportPath = path.join(artifactRoot, "architect.report.md");
+    const implementationPlan = requiredRecord(payload, "implementation_plan");
+    const qaPlan = requiredRecord(payload, "qa_plan");
+    const report = optionalString(payload, "report") ?? optionalString(payload, "report_markdown") ?? reportMarkdown(payload, "architect", status, producedBy, "pending");
+    const artifactWithoutHash = normalizeArtifactPayload(payload, {
+        phase: "architect",
+        workItemId: config.workItemId,
+        ownerType: config.ownerType,
+        ownerId: config.ownerId,
+        producedBy,
+        status
+    });
+    const contentHash = sha256(stableStringify(artifactWithoutHash));
+    const verdict = {
+        ...artifactWithoutHash,
+        content_hash: contentHash
+    };
+    await fs.mkdir(artifactRoot, { recursive: true });
+    await writeFileAtomic(implementationPlanPath, jsonText(implementationPlan));
+    await writeFileAtomic(qaPlanPath, jsonText(qaPlan));
+    await writeFileAtomic(verdictPath, jsonText(verdict));
+    await writeFileAtomic(reportPath, `${report.trim()}\n`);
+    return {
+        phase: "architect",
+        workItemId: config.workItemId,
+        ...artifactReferenceOwnerFields(config),
+        repoPath: path.resolve(config.worktreePath),
+        path: verdictPath,
+        reportPath,
+        contentHash,
+        status,
+        producedBy
+    };
+}
 async function writeQaGateCompletionArtifact(config, gate, input) {
     const payload = asRecord(input, "QA gate completion payload");
     const status = normalizeQaGateStatus(requiredString(payload, "status"));
@@ -709,6 +796,103 @@ async function writeQaCompletionArtifact(config, payload, status, producedBy) {
         producedBy
     };
 }
+async function synthesizeQaCycleVerdictPayload(config, payload, status) {
+    const qaPlan = await readQaGateArtifact(config, "qa_plan");
+    const qaRegression = await readQaGateArtifact(config, "qa_regression");
+    const qaApi = await readQaGateArtifact(config, "qa_api");
+    const qaManualWeb = await readQaGateArtifact(config, "qa_manual_web");
+    const qaBugRepro = await readQaGateArtifact(config, "qa_bug_repro");
+    const qaFindings = await readQaGateArtifact(config, "qa_findings");
+    const evidenceGates = [qaRegression, qaApi, qaManualWeb, qaBugRepro];
+    const payloadEvidence = qaEvidenceSource(payload);
+    const merged = { ...payload };
+    const checklist = qaStringArray(payload, "checklist");
+    if (checklist.length === 0) {
+        const plannedChecklist = qaStringArray(qaPlan, "checklist");
+        merged.checklist = plannedChecklist.length > 0 ? plannedChecklist : defaultQaChecklist(status);
+    }
+    const testedAcceptanceCriteria = qaStringArray(payload, "tested_acceptance_criteria");
+    if (testedAcceptanceCriteria.length === 0) {
+        const plannedAcceptanceCriteria = qaStringArray(qaPlan, "acceptance_criteria");
+        const payloadAcceptanceCriteria = qaStringArray(payload, "acceptance_criteria");
+        const acceptanceCriteria = plannedAcceptanceCriteria.length > 0 ? plannedAcceptanceCriteria : payloadAcceptanceCriteria;
+        if (acceptanceCriteria.length > 0) {
+            merged.tested_acceptance_criteria = acceptanceCriteria;
+        }
+    }
+    merged.commands = dedupeUnknownArray([
+        ...qaArray(payload, "commands", payloadEvidence),
+        ...evidenceGates.flatMap((gate) => qaArray(gate, "commands"))
+    ]);
+    merged.browser_checks = dedupeUnknownArray([
+        ...qaArray(payload, "browser_checks", payloadEvidence),
+        ...evidenceGates.flatMap((gate) => qaArray(gate, "browser_checks"))
+    ]);
+    merged.sidecars = dedupeUnknownArray([
+        ...qaArray(payload, "sidecars", payloadEvidence),
+        ...evidenceGates.flatMap((gate) => qaArray(gate, "sidecars"))
+    ]);
+    const notes = dedupeStrings([
+        optionalString(payload, "notes"),
+        optionalString(payloadEvidence, "notes"),
+        ...evidenceGates.map((gate) => optionalString(gate, "notes"))
+    ]);
+    if (notes.length > 0) {
+        merged.notes = notes.join("\n");
+    }
+    merged.findings = mergeQaObjectArraysById(qaObjectArray(payload, "findings"), qaObjectArray(qaFindings, "findings"));
+    merged.candidate_bugs = mergeQaObjectArraysById(qaObjectArray(payload, "candidate_bugs"), qaObjectArray(qaFindings, "candidate_bugs"));
+    return merged;
+}
+async function readQaGateArtifact(config, gate) {
+    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 artifactPath = path.join(artifactRoot, qaGateFileNames[gate]);
+    const content = await readOptionalFile(artifactPath);
+    return content === null ? {} : parseOptionalJsonObject(content, qaGateFileNames[gate]);
+}
+function dedupeUnknownArray(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        const key = stableStringify(value);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(value);
+    }
+    return deduped;
+}
+function mergeQaObjectArraysById(primary, fallback) {
+    const seen = new Set();
+    const merged = [];
+    for (const value of [...primary, ...fallback]) {
+        const id = optionalString(value, "id");
+        const key = id ? `id:${id}` : stableStringify(value);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        merged.push(value);
+    }
+    return merged;
+}
+function dedupeStrings(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (!trimmed || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        deduped.push(trimmed);
+    }
+    return deduped;
+}
 async function validateQaSidecarReferences(worktreePath, workItemId, sidecars, ownerType, ownerId) {
     if (sidecars.length === 0) {
         return [];
@@ -762,19 +946,28 @@ async function validateQaSidecarReferences(worktreePath, workItemId, sidecars, o
     }
     return validated;
 }
-export async function readCompletionArtifact(worktreePath, workItemId, phase) {
-    const artifactPath = completionArtifactJsonPath(worktreePath, workItemId, phase);
-    const reportPath = completionArtifactReportPath(worktreePath, workItemId, phase);
+export async function readCompletionArtifact(worktreePath, workItemId, phase, ownerType, ownerId) {
+    const artifactPath = completionArtifactJsonPath(worktreePath, workItemId, phase, ownerType, ownerId);
+    const reportPath = completionArtifactReportPath(worktreePath, workItemId, phase, ownerType, ownerId);
     const verdictJson = await readOptionalFile(artifactPath);
     if (verdictJson === null) {
         return null;
     }
     const parsed = parseJsonObject(verdictJson, artifactPath);
     const report = await readOptionalFile(reportPath) ?? fallbackReport(parsed, phase, artifactPath);
+    const artifactRoot = path.dirname(artifactPath);
+    const implementationPlanJson = phase === "architect"
+        ? await readOptionalFile(path.join(artifactRoot, "implementation.plan.json"))
+        : null;
+    const qaPlanJson = phase === "architect"
+        ? await readOptionalFile(path.join(artifactRoot, "qa.plan.json"))
+        : null;
     return {
         repoPath: path.resolve(worktreePath),
         path: artifactPath,
         verdictJson,
+        implementationPlanJson,
+        qaPlanJson,
         report,
         producedBy: optionalString(parsed, "produced_by") ?? optionalString(parsed, "producedBy") ?? "forge-completion-tool",
         status: optionalString(parsed, "status") ?? "unknown",
@@ -812,6 +1005,7 @@ export function parseCompletionMcpArgs(argv) {
     let developCycle = false;
     let qaCycle = false;
     let debugCycle = false;
+    let architectCycle = false;
     for (let index = 1; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg === "--worktree") {
@@ -833,7 +1027,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, 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, debug-repro, debug-root-cause, debug-fix, debug-regression." };
             }
             phase = parsedPhase;
         }
@@ -849,6 +1043,9 @@ export function parseCompletionMcpArgs(argv) {
         else if (arg === "--debug-cycle") {
             debugCycle = true;
         }
+        else if (arg === "--architect-cycle") {
+            architectCycle = true;
+        }
         else {
             return { ok: false, error: `Unknown mcp argument: ${arg}` };
         }
@@ -856,7 +1053,7 @@ 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) {
+    if ([developCycle, qaCycle, debugCycle, architectCycle].filter(Boolean).length > 1) {
         return { ok: false, error: "mcp accepts only one cycle mode." };
     }
     if (developCycle && !isDevelopCompletionPhase(phase)) {
@@ -868,6 +1065,9 @@ export function parseCompletionMcpArgs(argv) {
     if (debugCycle && !isDebugCompletionPhase(phase)) {
         return { ok: false, error: "mcp --debug-cycle requires --phase debug-repro, debug-root-cause, debug-fix, or debug-regression." };
     }
+    if (architectCycle && phase !== "architect") {
+        return { ok: false, error: "mcp --architect-cycle requires --phase architect." };
+    }
     return {
         ok: true,
         config: {
@@ -880,7 +1080,8 @@ export function parseCompletionMcpArgs(argv) {
             redactionSecrets: parseCompletionRedactionSecrets(process.env[completionRedactionSecretsEnv]),
             developCycle,
             qaCycle,
-            debugCycle
+            debugCycle,
+            architectCycle
         }
     };
 }
@@ -1088,6 +1289,9 @@ function toolDescription(phase, qaGate = null) {
     if (phase === "qa") {
         return "Complete Forge QA by writing qa.plan.json, qa.evidence.json, qa.findings.json, qa.verdict.json, and qa.report.md with structured pass, needs-rework, or blocked evidence.";
     }
+    if (phase === "architect") {
+        return "Complete Forge Architect planning by writing implementation.plan.json, qa.plan.json, architect.verdict.json, and architect.report.md with a pending-approval plan or explicit revision/blocker reasons.";
+    }
     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, qaGate = null) {
@@ -1137,7 +1341,7 @@ function toolInputSchema(phase, qaGate = null) {
             },
             tests_added_or_updated: {
                 type: "array",
-                description: "Required for pass. Use an object explaining why no tests were needed for docs/config-only work if empty would be ambiguous.",
+                description: "Required for pass. Use an object explaining why no tests were needed for documentation/config-only work if empty would be ambiguous.",
                 items: evidenceObjectSchema(["path", "summary"], {
                     path: { type: "string" },
                     summary: { type: "string" }
@@ -1168,6 +1372,11 @@ function toolInputSchema(phase, qaGate = null) {
             },
             next_phase_context: {
                 description: "Required for pass. Context the self-review phase should carry forward."
+            },
+            resolved_findings: {
+                type: "array",
+                description: "Required for QA rework. Each entry must use status resolved, disputed, or not_reproduced.",
+                items: resolvedFindingSchema()
             }
         }, ["status", "summary"], "For status pass, include plan, changed_files, tests_added_or_updated, docs_added_or_updated, acceptance_criteria, known_gaps, and next_phase_context. Acceptance criteria entries must use status: satisfied plus evidence.");
     }
@@ -1303,6 +1512,83 @@ function toolInputSchema(phase, qaGate = null) {
             }
         }, ["status", "summary"], "For pass, include tested_acceptance_criteria plus concrete command/browser/note evidence. For needs_rework, include at least one actionable in_scope finding. For blocked, include blocker_reason.");
     }
+    if (phase === "architect") {
+        return objectToolSchema({
+            status: {
+                type: "string",
+                enum: ["pass", "needs_revision", "blocked"],
+                description: "Use pass only for a complete pending-approval Architect plan. Use needs_revision for fixable story/design/repo gaps, or blocked for missing required context or decisions."
+            },
+            summary: { type: "string", description: "Concise Architect plan verdict summary." },
+            implementation_plan: {
+                type: "object",
+                description: "Required for pass. Top-level fields inside this object must include schema_version, plan_id, phases, tasks, dependencies, and phase_gates.",
+                additionalProperties: true,
+                properties: {
+                    schema_version: { type: "number", enum: [1] },
+                    plan_id: { type: "string" },
+                    phases: {
+                        type: "array",
+                        description: "Required top-level implementation_plan.phases array.",
+                        items: { type: "object", additionalProperties: true }
+                    },
+                    tasks: {
+                        type: "array",
+                        description: "Required task list. Each task must include id and a non-empty tests array.",
+                        items: { type: "object", additionalProperties: true }
+                    },
+                    dependencies: {
+                        type: "array",
+                        description: "Required dependency edge array. Use [] when no task dependencies exist. Each edge should use before and after task ids; from/to are accepted only as aliases and normalized before writing artifacts.",
+                        items: {
+                            type: "object",
+                            additionalProperties: true,
+                            properties: {
+                                id: { type: "string" },
+                                before: { type: "string", description: "Task id that must complete first." },
+                                after: { type: "string", description: "Task id that depends on before." },
+                                from: { type: "string", description: "Alias for before." },
+                                to: { type: "string", description: "Alias for after." },
+                                type: { type: "string" },
+                                rationale: { type: "string" }
+                            }
+                        }
+                    },
+                    phase_gates: {
+                        type: "array",
+                        description: "Required non-empty phase gate array.",
+                        items: { type: "object", additionalProperties: true }
+                    }
+                }
+            },
+            qa_plan: {
+                type: "object",
+                description: "Required for pass. Must include schema_version: 1 and non-empty final_qa coverage.",
+                additionalProperties: true,
+                properties: {
+                    schema_version: { type: "number", enum: [1] },
+                    final_qa: {
+                        type: "array",
+                        description: "Required non-empty final QA coverage array.",
+                        items: { type: "object", additionalProperties: true }
+                    }
+                }
+            },
+            report_markdown: { type: "string", description: "Human-readable Architect report. Use report as an alias only when the client cannot send report_markdown." },
+            report: { type: "string", description: "Alias for report_markdown." },
+            blockers: baseProperties.blockers,
+            revision_questions: {
+                type: "array",
+                description: "Required for needs_revision when blockers are not used.",
+                items: { type: "string" }
+            },
+            revision_reasons: {
+                type: "array",
+                description: "Concrete reasons that prevent pass status.",
+                items: { type: "string" }
+            }
+        }, ["status", "summary"], "For status pass, include implementation_plan and qa_plan at the top level of the MCP tool arguments. implementation_plan.phases must be a top-level array inside implementation_plan, not nested under another object.");
+    }
     return objectToolSchema({
         ...baseProperties,
         commands: {
@@ -1382,8 +1668,8 @@ function debugToolInputSchema(phase, baseProperties) {
             },
             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 }
+                description: "Required for QA rework. Each entry must use status resolved, disputed, or not_reproduced.",
+                items: resolvedFindingSchema()
             }
         }, ["status", "summary"], "For status pass, include changed_files, tests_added_or_updated, and remaining_risks.");
     }
@@ -1490,6 +1776,29 @@ function commandEvidenceSchema() {
         summary: { type: "string" }
     });
 }
+function resolvedFindingSchema() {
+    return evidenceObjectSchema([
+        "qa_id",
+        "status",
+        "summary",
+        "evidence",
+        "changed_files",
+        "tests_added_or_updated",
+        "regression_evidence"
+    ], {
+        qa_id: { type: "string" },
+        status: {
+            type: "string",
+            enum: [...resolvedFindingStatusValues],
+            description: "Use resolved when fixed, disputed when the QA finding is incorrect/out-of-scope, or not_reproduced when retesting cannot reproduce it."
+        },
+        summary: { type: "string" },
+        evidence: { description: "Concrete evidence for the resolution." },
+        changed_files: { type: "array", description: "Required and non-empty when status is resolved." },
+        tests_added_or_updated: { type: "array", description: "Required and non-empty when status is resolved." },
+        regression_evidence: { description: "Concrete regression evidence for this QA finding." }
+    });
+}
 function acceptanceCriteriaSchema() {
     return {
         type: "array",
@@ -1524,6 +1833,13 @@ function normalizeCompletionStatus(value, phase) {
         }
         return canonical;
     }
+    if (phase === "architect") {
+        const canonical = normalized === "needsrevision" ? "needs_revision" : normalized;
+        if (canonical !== "pass" && canonical !== "needs_revision" && canonical !== "blocked") {
+            throw new Error("Architect status must be pass, needs_revision, or blocked.");
+        }
+        return canonical;
+    }
     const canonical = normalized === "blocked" || normalized === "needsrework"
         ? "needs_rework"
         : normalized === "failed"
@@ -1551,6 +1867,10 @@ function validatePayloadShape(phase, payload) {
         validateQaPayloadShape(payload, status);
         return;
     }
+    if (phase === "architect") {
+        validateArchitectPayloadShape(payload, status);
+        return;
+    }
     const pass = status === "pass";
     if (!pass) {
         requireNonPassEvidence(payload);
@@ -1570,6 +1890,7 @@ function validatePayloadShape(phase, payload) {
         requireField(payload, "next_phase_context");
         requireImplementationEvidence(payload);
         requireSatisfiedAcceptanceCriteria(payload);
+        validateResolvedFindings(payload);
         return;
     }
     if (phase === "self_review") {
@@ -1623,6 +1944,7 @@ function validateDebugPayloadShape(phase, payload) {
         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.");
         }
+        validateResolvedFindings(payload);
         return;
     }
     requireArray(payload, "commands");
@@ -1677,6 +1999,160 @@ function validateQaGatePayloadShape(gate, payload, status) {
         }
     }
 }
+function validateArchitectPayloadShape(payload, status) {
+    if (status !== "pass") {
+        requireArchitectNonPassEvidence(payload);
+        return;
+    }
+    const implementationPlan = requiredRecord(payload, "implementation_plan");
+    const qaPlan = requiredRecord(payload, "qa_plan");
+    requireNumericOne(implementationPlan, "schema_version", "implementation_plan.schema_version");
+    requireNonEmptyStringRecord(implementationPlan, "plan_id", "implementation_plan.");
+    requireArchitectArray(implementationPlan, "phases", payload);
+    requireArchitectArray(implementationPlan, "tasks", payload);
+    requireArchitectArray(implementationPlan, "dependencies", payload, { allowEmpty: true });
+    requireArchitectArray(implementationPlan, "phase_gates", payload);
+    if (arrayLength(implementationPlan, "tasks") === 0) {
+        throw new Error("implementation_plan.tasks: expected non-empty array; correction: include at least one task with id and tests.");
+    }
+    const taskIds = new Set();
+    for (const task of implementationPlan.tasks) {
+        if (!task || typeof task !== "object" || Array.isArray(task)) {
+            throw new Error("implementation_plan.tasks[]: expected object entries; correction: each task must be an object with id and tests.");
+        }
+        const taskRecord = task;
+        requireNonEmptyStringRecord(taskRecord, "id", "implementation_plan.tasks[].");
+        const taskId = optionalString(taskRecord, "id") ?? "";
+        if (taskIds.has(taskId)) {
+            throw new Error(`implementation_plan.tasks: duplicate task id '${taskId}'.`);
+        }
+        taskIds.add(taskId);
+        requireArchitectArray(taskRecord, "tests", payload, { path: `implementation_plan.tasks[${optionalString(taskRecord, "id") ?? "?"}].tests` });
+        if (arrayLength(taskRecord, "tests") === 0) {
+            throw new Error(`implementation_plan.tasks[${optionalString(taskRecord, "id") ?? "?"}].tests: expected non-empty array; correction: include task-specific verification.`);
+        }
+    }
+    validateAndNormalizeArchitectDependencies(implementationPlan, taskIds);
+    requireNumericOne(qaPlan, "schema_version", "qa_plan.schema_version");
+    requireArchitectArray(qaPlan, "final_qa", payload, { path: "qa_plan.final_qa" });
+    if (arrayLength(qaPlan, "final_qa") === 0) {
+        throw new Error("qa_plan.final_qa: expected non-empty array; correction: include final QA coverage for the completed plan.");
+    }
+}
+function validateAndNormalizeArchitectDependencies(implementationPlan, taskIds) {
+    const dependencies = implementationPlan.dependencies;
+    const edges = new Map();
+    for (const taskId of taskIds) {
+        edges.set(taskId, []);
+    }
+    const normalizedDependencies = [];
+    for (const [index, dependency] of dependencies.entries()) {
+        if (!dependency || typeof dependency !== "object" || Array.isArray(dependency)) {
+            throw new Error("implementation_plan.dependencies[]: expected object entries; correction: each dependency must be an object with before and after task ids.");
+        }
+        const record = dependency;
+        const before = architectDependencyEndpoint(record, index, "before", "from");
+        const after = architectDependencyEndpoint(record, index, "after", "to");
+        if (!taskIds.has(before) || !taskIds.has(after)) {
+            throw new Error("implementation_plan.dependencies: dependency references an unknown task id.");
+        }
+        const normalized = stripUndefined({
+            ...record,
+            before,
+            after,
+            from: undefined,
+            to: undefined
+        });
+        normalizedDependencies.push(normalized);
+        edges.get(before)?.push(after);
+    }
+    implementationPlan.dependencies = normalizedDependencies;
+    if (hasArchitectDependencyCycle(edges)) {
+        throw new Error("implementation_plan.dependencies: expected acyclic graph; correction: remove or revise cyclic task dependencies.");
+    }
+}
+function architectDependencyEndpoint(dependency, index, canonicalKey, aliasKey) {
+    const canonical = optionalString(dependency, canonicalKey);
+    const alias = optionalString(dependency, aliasKey);
+    if (canonical && alias && canonical !== alias) {
+        throw new Error(`implementation_plan.dependencies[${index}].${canonicalKey}: conflicts with ${aliasKey}; correction: use one task id for ${canonicalKey}.`);
+    }
+    const value = canonical ?? alias;
+    if (!value) {
+        throw new Error(`implementation_plan.dependencies[${index}].${canonicalKey}: expected string; correction: use before and after task ids for each dependency.`);
+    }
+    return value;
+}
+function hasArchitectDependencyCycle(edges) {
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (node) => {
+        if (visited.has(node)) {
+            return false;
+        }
+        if (visiting.has(node)) {
+            return true;
+        }
+        visiting.add(node);
+        for (const next of edges.get(node) ?? []) {
+            if (visit(next)) {
+                return true;
+            }
+        }
+        visiting.delete(node);
+        visited.add(node);
+        return false;
+    };
+    for (const node of edges.keys()) {
+        if (visit(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+function requireArchitectNonPassEvidence(payload) {
+    const evidenceKeys = ["blockers", "revision_questions", "revision_reasons", "known_gaps", "findings", "remaining_risks", "failures"];
+    const hasEvidence = evidenceKeys.some((key) => {
+        const value = payload[key];
+        if (typeof value === "string") {
+            return value.trim().length > 0;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        return Boolean(value && typeof value === "object");
+    });
+    if (!hasEvidence) {
+        throw new Error("status: non-pass Architect completion requires blockers, revision_questions, revision_reasons, findings, failures, or known_gaps; correction: explain why the plan cannot pass.");
+    }
+}
+function requireArchitectArray(source, key, rootPayload, options = {}) {
+    const pathLabel = options.path ?? `implementation_plan.${key}`;
+    if (!Array.isArray(source[key])) {
+        const nestedHint = architectNestedArrayHint(rootPayload, key);
+        throw new Error(`${pathLabel}: expected array${key === "phases" ? " as a top-level field inside implementation_plan" : ""}; correction: ${nestedHint ?? `set ${pathLabel} to an array${options.allowEmpty ? " (use [] when none exist)" : " with at least one entry"}.`}`);
+    }
+    if (!options.allowEmpty && arrayLength(source, key) === 0) {
+        throw new Error(`${pathLabel}: expected non-empty array; correction: include at least one entry.`);
+    }
+}
+function architectNestedArrayHint(rootPayload, key) {
+    if (Array.isArray(rootPayload[key])) {
+        return `move top-level ${key} into implementation_plan.${key}.`;
+    }
+    const implementationPlan = rootPayload.implementation_plan;
+    if (!implementationPlan || typeof implementationPlan !== "object" || Array.isArray(implementationPlan)) {
+        return null;
+    }
+    const plan = implementationPlan;
+    for (const container of ["plan", "dag", "implementation_dag", "implementationPlan", "implementation_plan"]) {
+        const nested = plan[container];
+        if (nested && typeof nested === "object" && !Array.isArray(nested) && Array.isArray(nested[key])) {
+            return `move implementation_plan.${container}.${key} to implementation_plan.${key}.`;
+        }
+    }
+    return null;
+}
 function validateQaPayloadShape(payload, status) {
     const evidenceSource = qaEvidenceSource(payload);
     const commands = qaArray(payload, "commands", evidenceSource);
@@ -1881,6 +2357,9 @@ function parseStrictCompletionPhase(value) {
     if (normalized === "qa" || normalized === "quality_assurance" || normalized === "qualityassurance") {
         return "qa";
     }
+    if (normalized === "architect" || normalized === "architect_plan" || normalized === "planning" || normalized === "plan") {
+        return "architect";
+    }
     return null;
 }
 function normalizeDebugCompletionPhase(value) {
@@ -1949,6 +2428,9 @@ function phaseFromToolName(toolName) {
     if (normalized === "forge.complete_qa" || normalized === "complete_qa") {
         return "qa";
     }
+    if (normalized === "forge.complete_architect_plan" || normalized === "complete_architect_plan") {
+        return "architect";
+    }
     const debugGate = debugGateFromToolName(toolName);
     if (debugGate) {
         return debugGate;
@@ -2067,11 +2549,20 @@ function requireObject(payload, key) {
         throw new Error(`${key} must be an object.`);
     }
 }
+function requiredRecord(payload, key) {
+    requireObject(payload, key);
+    return payload[key];
+}
 function requireBoolean(payload, key) {
     if (typeof payload[key] !== "boolean") {
         throw new Error(`${key} must be a boolean.`);
     }
 }
+function requireNumericOne(payload, key, pathLabel) {
+    if (payload[key] !== 1) {
+        throw new Error(`${pathLabel}: expected numeric 1; correction: set ${pathLabel} to 1.`);
+    }
+}
 function requireSatisfiedAcceptanceCriteria(payload) {
     const criteria = payload.acceptance_criteria;
     if (!Array.isArray(criteria)) {
@@ -2089,6 +2580,37 @@ function requireSatisfiedAcceptanceCriteria(payload) {
         }
     }
 }
+function validateResolvedFindings(payload) {
+    const resolvedFindings = payload.resolved_findings;
+    if (resolvedFindings === undefined || resolvedFindings === null) {
+        return;
+    }
+    if (!Array.isArray(resolvedFindings)) {
+        throw new Error("resolved_findings must be an array.");
+    }
+    for (const [index, finding] of resolvedFindings.entries()) {
+        const prefix = `resolved_findings[${index}].`;
+        if (!finding || typeof finding !== "object" || Array.isArray(finding)) {
+            throw new Error(`resolved_findings[${index}] must be an object.`);
+        }
+        const record = finding;
+        requireNonEmptyStringRecord(record, "qa_id", prefix);
+        requireKnownStringRecord(record, "status", resolvedFindingStatuses, prefix);
+        requireNonEmptyStringRecord(record, "summary", prefix);
+        requireSubstantiveValueRecord(record, "evidence", prefix);
+        requireArrayRecord(record, "changed_files", prefix);
+        requireArrayRecord(record, "tests_added_or_updated", prefix);
+        requireSubstantiveValueRecord(record, "regression_evidence", prefix);
+        if (normalizedString(record.status) === "resolved") {
+            if (record.changed_files.length === 0) {
+                throw new Error(`${prefix}changed_files must include at least one changed file for resolved QA findings.`);
+            }
+            if (record.tests_added_or_updated.length === 0) {
+                throw new Error(`${prefix}tests_added_or_updated must include at least one regression test for resolved QA findings.`);
+            }
+        }
+    }
+}
 function qaEvidenceSource(payload) {
     const evidence = payload.evidence;
     return evidence && typeof evidence === "object" && !Array.isArray(evidence)
@@ -2138,6 +2660,11 @@ function requireNonEmptyStringRecord(source, key, prefix = "") {
         throw new Error(`${prefix}${key} is required.`);
     }
 }
+function requireArrayRecord(source, key, prefix = "") {
+    if (!Array.isArray(source[key])) {
+        throw new Error(`${prefix}${key} must be an array.`);
+    }
+}
 function requireKnownStringRecord(source, key, allowed, prefix = "") {
     const value = normalizedString(optionalString(source, key));
     if (!allowed.has(value)) {
@@ -2155,6 +2682,11 @@ function requireNonEmptyStringArrayRecord(source, key, prefix = "") {
         }
     }
 }
+function requireSubstantiveValueRecord(source, key, prefix = "") {
+    if (!hasSubstantiveJsonValue(source[key])) {
+        throw new Error(`${prefix}${key} must include at least one concrete evidence reference or summary.`);
+    }
+}
 function requireSubstantiveEvidenceRecord(source, prefix = "") {
     const evidence = source.evidence;
     if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) {
@@ -2237,7 +2769,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) {