vibe-coding-master 0.7.47 → 0.7.48

package/dist/backend/services/artifact-service.js

@@ -1,13 +1,13 @@
 import path from "node:path";
-import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
-import { getArtifactDefinition, isArtifactKind } from "../../shared/validation/artifact-registry.js";
+import { getManagedArtifactDefinition, isArtifactKind, isManagedArtifactKind } from "../../shared/validation/artifact-registry.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsUpdateReportTemplate, renderDocsSyncReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
 import { renderRoleCommandTemplate } from "../templates/role-command.js";
-import { validateMemoryProposal } from "./memory-proposal-validation.js";
 import { isMemoryProposalSubmissionPath } from "./memory-review-paths.js";
+import { validateManagedArtifactContent } from "./managed-artifact-validation.js";
 const ARTIFACT_PATH_KEYS = [
     ["architecture-brief", "architectureBriefPath"],
     ["architecture-evidence", "architectureEvidencePath"],
@@ -191,21 +191,33 @@ export function createArtifactService(fs, deps = {}) {
             if (!normalized.trim()) {
                 throw artifactRejected(input.kind, ["Artifact content is empty."]);
             }
+            if (!isManagedArtifactKind(input.kind)) {
+                throw new VcmError({
+                    code: "ARTIFACT_KIND_INVALID",
+                    message: `Unknown managed artifact kind: ${input.kind}`,
+                    statusCode: 400
+                });
+            }
+            const definition = getManagedArtifactDefinition(input.kind);
+            const owners = Array.isArray(definition.owner) ? definition.owner : [definition.owner];
+            if (!owners.includes(input.role)) {
+                throw new VcmError({
+                    code: "ARTIFACT_OWNER_MISMATCH",
+                    message: `${input.kind} is owned by ${owners.join("|")}, not ${input.role}.`,
+                    statusCode: 403
+                });
+            }
             if (isArtifactKind(input.kind)) {
-                const definition = getArtifactDefinition(input.kind);
-                const owners = Array.isArray(definition.owner) ? definition.owner : [definition.owner];
-                if (!owners.includes(input.role)) {
-                    throw new VcmError({
-                        code: "ARTIFACT_OWNER_MISMATCH",
-                        message: `${input.kind} is owned by ${owners.join("|")}, not ${input.role}.`,
-                        statusCode: 403
-                    });
+                if (input.artifactPath?.trim()) {
+                    throw artifactRejected(input.kind, ["--path is not allowed for fixed artifact kinds."]);
                 }
-                const artifactPath = path.posix.join(input.handoffDir, definition.fileName);
-                const check = checkMarkdownArtifact(input.kind, artifactPath, normalized, { mode: input.mode });
-                const errors = artifactCheckErrors(check, input.mode);
-                if (errors.length > 0) {
-                    throw artifactRejected(input.kind, errors);
+                const artifactPath = path.posix.join(input.handoffDir, definition.fileName ?? "");
+                const validation = validateManagedArtifactContent(input.kind, normalized, {
+                    path: artifactPath,
+                    mode: input.mode
+                });
+                if (validation.errors.length > 0) {
+                    throw artifactRejected(input.kind, validation.errors);
                 }
                 if (input.kind === "workflow-progress") {
                     if (input.mode !== "final") {
@@ -238,7 +250,7 @@ export function createArtifactService(fs, deps = {}) {
                     kind: input.kind,
                     mode: input.mode,
                     path: artifactPath,
-                    status: check.status
+                    status: validation.status
                 };
             }
             const dynamic = await validateDynamicArtifact(fs, input, normalized, deps.workflowControlService);
@@ -253,16 +265,6 @@ export function createArtifactService(fs, deps = {}) {
         }
     };
 }
-function artifactCheckErrors(check, mode) {
-    const errors = [
-        ...check.missingHeadings.map((heading) => `Missing required heading: ${heading}.`),
-        ...check.invalidFields
-    ];
-    if (mode === "final" && check.hasPlaceholder) {
-        errors.push("Final artifacts must not contain TBD, draft, or not-run placeholders.");
-    }
-    return errors;
-}
 function artifactRejected(kind, errors) {
     return new VcmError({
         code: "ARTIFACT_VALIDATION_FAILED",
@@ -272,16 +274,13 @@ function artifactRejected(kind, errors) {
     });
 }
 async function validateDynamicArtifact(fs, input, content, workflowControlService) {
-    if (input.mode !== "final") {
-        throw artifactRejected(input.kind, ["Dynamic artifacts must be submitted in final mode."]);
-    }
     const artifactPath = normalizeRelativeArtifactPath(input.artifactPath);
     if (input.kind === "route-message") {
         const route = DEFAULT_MESSAGE_ROUTES.find(([fromRole, toRole]) => artifactPath === path.posix.join(input.handoffDir, "messages", `${fromRole}-${toRole}.md`));
         if (!route || route[0] !== input.role) {
             throw artifactRejected(input.kind, ["Route-message path must name the submitting role as the sender."]);
         }
-        validateRouteMessage(content);
+        assertManagedArtifactContent(input.kind, content, artifactPath, input.mode);
         if (input.role === "project-manager") {
             if (!workflowControlService) {
                 throw new VcmError({
@@ -302,40 +301,46 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
         return { kind: input.kind, root: input.repoRoot, path: artifactPath };
     }
     if (input.kind === "coder-worker-report") {
-        if (input.role !== "coder" || !/^\.ai\/vcm\/coder-workers\/reports\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
+        if (!/^\.ai\/vcm\/coder-workers\/reports\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
             throw artifactRejected(input.kind, ["Coder Worker reports must use the assigned .ai/vcm/coder-workers/reports/<worker-id>.md path."]);
         }
-        validateCoderWorkerReport(content);
+        assertManagedArtifactContent(input.kind, content, artifactPath, input.mode);
         return { kind: input.kind, root: input.repoRoot, path: artifactPath };
     }
     if (input.kind === "gate-review-report") {
-        if (input.role !== "reviewer" || !/^\.ai\/vcm\/gate-reviews\/requests\/[A-Za-z0-9._-]+\.report\.md$/.test(artifactPath)) {
+        if (!/^\.ai\/vcm\/gate-reviews\/requests\/[A-Za-z0-9._-]+\.report\.md$/.test(artifactPath)) {
             throw artifactRejected(input.kind, ["Reviewer must submit the assigned request report path."]);
         }
-        await validateGateReviewReport(fs, input.repoRoot, artifactPath, content);
+        const requestId = path.posix.basename(artifactPath, ".report.md");
+        const requestPath = path.posix.join(".ai/vcm/gate-reviews/requests", `${requestId}.json`);
+        const absoluteRequestPath = resolveRepoPath(input.repoRoot, requestPath);
+        if (!(await fs.pathExists(absoluteRequestPath))) {
+            throw artifactRejected(input.kind, [`Gate request does not exist: ${requestPath}.`]);
+        }
+        const request = await fs.readJson(absoluteRequestPath);
+        if (request.reportPath !== artifactPath) {
+            throw artifactRejected(input.kind, [
+                `Report path must match the assigned request path ${request.reportPath ?? "<missing>"}.`
+            ]);
+        }
+        assertManagedArtifactContent(input.kind, content, artifactPath, input.mode, {
+            expectedGate: request.gate,
+            expectedRequestId: request.requestId ?? requestId
+        });
         return { kind: input.kind, root: input.repoRoot, path: artifactPath };
     }
     if (input.kind === "memory-proposal") {
-        if (!VCM_ROLE_NAMES.includes(input.role)) {
-            throw artifactRejected(input.kind, ["Only a VCM workflow role may submit a Memory Proposal."]);
-        }
         if (!isMemoryProposalSubmissionPath(artifactPath, input.role)) {
             throw artifactRejected(input.kind, ["Memory proposal path is not assigned to the submitting role."]);
         }
-        const memoryError = validateMemoryProposal(content);
-        if (memoryError) {
-            throw artifactRejected(input.kind, [`Memory proposal ${memoryError}.`]);
-        }
+        assertManagedArtifactContent(input.kind, content, artifactPath, input.mode);
         return { kind: input.kind, root: input.repoRoot, path: artifactPath };
     }
     if (input.kind === "harness-feedback") {
-        if (!VCM_ROLE_NAMES.includes(input.role)) {
-            throw artifactRejected(input.kind, ["Only a VCM workflow role may submit Harness Feedback."]);
-        }
         if (!/^\.ai\/vcm\/harness-feedback\/pending\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
             throw artifactRejected(input.kind, ["Harness Feedback path must be under .ai/vcm/harness-feedback/pending/. "]);
         }
-        validateHarnessFeedback(content);
+        assertManagedArtifactContent(input.kind, content, artifactPath, input.mode);
         return { kind: input.kind, root: input.baseRepoRoot, path: artifactPath };
     }
     throw new VcmError({
@@ -344,89 +349,16 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
         statusCode: 400
     });
 }
-function validateCoderWorkerReport(content) {
-    const errors = [];
-    if (!/^# Coder Worker Report:\s*\S.+$/m.test(content)) {
-        errors.push("Coder Worker report requires '# Coder Worker Report: <worker-id>'.");
-    }
-    if (!/^Worker State:\s*completed\s*$/m.test(content)) {
-        errors.push("Worker State must be completed.");
-    }
-    if (!/^Implementation Result:\s*(success|has_failed_items)\s*$/m.test(content)) {
-        errors.push("Implementation Result must be success|has_failed_items.");
-    }
-    for (const heading of [
-        "Assigned Scope", "Item Dispositions", "Files Changed", "Tests Added Or Updated",
-        "L0/L1 Checks", "Commit", "Skipped Assigned Checks", "Objective Failures"
-    ]) {
-        if (!new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m").test(content)) {
-            errors.push(`Missing required section: ${heading}.`);
-        }
-    }
-    if (errors.length > 0)
-        throw artifactRejected("coder-worker-report", errors);
-}
-function validateRouteMessage(content) {
-    const type = /^type:\s*(\S+)\s*$/m.exec(content)?.[1];
-    const allowed = new Set(["task", "question", "revise", "cancel", "result", "blocked", "finding"]);
-    if (!type || !allowed.has(type)) {
-        throw artifactRejected("route-message", ["Frontmatter type must be one of task|question|revise|cancel|result|blocked|finding."]);
-    }
-    if (!content.startsWith("---\n") || !/\n---\n/.test(content) || !content.split(/\n---\n/, 2)[1]?.trim()) {
-        throw artifactRejected("route-message", ["Route message requires frontmatter and a non-empty body."]);
-    }
-}
-async function validateGateReviewReport(fs, repoRoot, artifactPath, content) {
-    const requestId = path.posix.basename(artifactPath, ".report.md");
-    const requestPath = path.posix.join(".ai/vcm/gate-reviews/requests", `${requestId}.json`);
-    const absoluteRequestPath = resolveRepoPath(repoRoot, requestPath);
-    if (!(await fs.pathExists(absoluteRequestPath))) {
-        throw artifactRejected("gate-review-report", [`Gate request does not exist: ${requestPath}.`]);
-    }
-    const request = await fs.readJson(absoluteRequestPath);
-    const fields = Object.fromEntries(["Gate", "Request", "Decision", "Summary"].map((field) => [
-        field,
-        new RegExp(`^${field}:\\s*(.+?)\\s*$`, "mi").exec(content)?.[1]?.trim()
-    ]));
-    const errors = [];
-    if (fields.Gate !== request.gate)
-        errors.push(`Gate must be ${request.gate ?? "the requested gate"}.`);
-    if (fields.Request !== request.requestId)
-        errors.push(`Request must be ${request.requestId ?? requestId}.`);
-    if (fields.Decision !== "approve" && fields.Decision !== "request_changes")
-        errors.push("Decision must be approve|request_changes.");
-    if (!fields.Summary)
-        errors.push("Summary is required.");
-    const requiredSection = request.gate === "architecture-plan"
-        ? "Architecture Analysis"
-        : request.gate === "validation-adequacy"
-            ? "Validation Analysis"
-            : "Code Diff Analysis";
-    if (!new RegExp(`^## ${escapeRegExp(requiredSection)}\\s*$`, "m").test(content)) {
-        errors.push(`Missing required section: ${requiredSection}.`);
-    }
-    if (!/^## Findings\s*$/m.test(content))
-        errors.push("Missing required section: Findings.");
-    if (errors.length > 0)
-        throw artifactRejected("gate-review-report", errors);
-}
-function validateHarnessFeedback(content) {
-    const errors = [];
-    if (!/^#\s+\S.+$/m.test(content))
-        errors.push("Harness Feedback requires a title.");
-    for (const field of [
-        "Reporter role", "Task slug", "Summary", "Observed problem", "Expected behavior",
-        "Evidence", "Suspected harness area", "Impact", "Urgency"
-    ]) {
-        if (!new RegExp(`^- ${escapeRegExp(field)}:\\s*\\S`, "m").test(content)) {
-            errors.push(`Harness Feedback is missing ${field}.`);
-        }
-    }
-    if (!/^- Urgency:\s*(low|medium|high)\s*$/m.test(content)) {
-        errors.push("Urgency must be low|medium|high.");
+function assertManagedArtifactContent(kind, content, artifactPath, mode, expected = {}) {
+    const validation = validateManagedArtifactContent(kind, content, {
+        path: artifactPath,
+        mode,
+        expectedGate: expected.expectedGate,
+        expectedRequestId: expected.expectedRequestId
+    });
+    if (validation.errors.length > 0) {
+        throw artifactRejected(kind, validation.errors);
     }
-    if (errors.length > 0)
-        throw artifactRejected("harness-feedback", errors);
 }
 function normalizeRelativeArtifactPath(value) {
     const normalized = value?.replaceAll("\\", "/").replace(/^\.\//, "").trim();
@@ -445,9 +377,6 @@ async function writeAtomic(fs, absolutePath, content) {
     }
     await fs.writeText(absolutePath, content);
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function getLegacyRoleCommandPath(roleCommandsDir, role) {
     return path.posix.join(roleCommandsDir, `${role}-command.md`);
 }

package/dist/backend/services/claude-hook-service.js

@@ -235,6 +235,9 @@ export function createClaudeHookService(deps) {
         if (!session) {
             return completedHookResult(input, eventName);
         }
+        if (input.role === "architect") {
+            await deps.architectRestartService?.recordReplacementPromptSubmitted(context.project.repoRoot, context.taskSlug, session.id);
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             deps.jobGuard?.notePromptSubmitted({

package/dist/backend/services/gate-review-service.js

@@ -6,6 +6,7 @@ import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+import { parseGateReviewReportArtifact } from "./managed-artifact-validation.js";
 const REVIEWER_AGENT_PATH = ".claude/agents/reviewer.md";
 const GATE_REVIEW_DIR = ".ai/vcm/gate-reviews";
 const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
@@ -15,49 +16,6 @@ const REVIEWER_ROLE = "reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
 const activeRuns = new Map();
 const gateStateLocks = new Map();
-const ARCHITECTURE_ANALYSIS_FIELDS = [
-    "Evidence Read",
-    "Architecture Brief Fit",
-    "End-To-End Flow",
-    "Scope Fit",
-    "Code Reality",
-    "Ownership",
-    "Data Flow",
-    "Lifecycle",
-    "Invariants",
-    "Boundaries And Public Surface",
-    "Failure Model",
-    "Coder Readiness"
-];
-const VALIDATION_ANALYSIS_FIELDS = [
-    "Evidence Read",
-    "Changed Behavior And Risk",
-    "Coverage Mapping",
-    "Baseline Coverage",
-    "L2 Integration Coverage",
-    "L3 Trigger Assessment",
-    "L3 End-To-End Coverage",
-    "Boundary And Failure Coverage",
-    "Public Contract Coverage",
-    "Test Integrity",
-    "Test Infrastructure",
-    "Skips And Gaps",
-    "User Approval And Gap Disposition",
-    "Validation Readiness"
-];
-const CODE_DIFF_ANALYSIS_FIELDS = [
-    "Commit Range And Sources",
-    "Evidence Read",
-    "Changed Files And Symbols",
-    "Changed Behavior",
-    "Source Evidence Fit",
-    "Callers And Public Surface",
-    "State Lifecycle And Failure Paths",
-    "Coding Standards",
-    "Baseline Test Integrity",
-    "Generated Context And Durable Docs",
-    "Code Readiness"
-];
 const SOURCE_ARTIFACTS = {
     "architecture-plan": [
         ".ai/vcm/handoffs/architecture-brief.md",
@@ -1531,113 +1489,61 @@ async function parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, rep
         });
     }
     const content = await fs.readText(absolutePath);
-    const parsedGate = matchField(content, "Gate");
-    if (parsedGate && parsedGate !== gate) {
-        throw new VcmError({
-            code: "GATE_REVIEW_REPORT_GATE_MISMATCH",
-            message: `Gate review report gate is ${parsedGate}, expected ${gate}.`,
-            statusCode: 500
-        });
-    }
-    const parsedRequest = matchField(content, "Request");
-    if (requestId && parsedRequest !== requestId) {
-        throw new VcmError({
-            code: "GATE_REVIEW_REPORT_STALE",
-            message: `Gate review report request is ${parsedRequest ?? "missing"}, expected ${requestId}.`,
-            statusCode: 500
-        });
-    }
-    const decision = normalizeDecision(matchField(content, "Decision"));
-    if (!decision) {
+    const validation = parseGateReviewReportArtifact(content, {
+        expectedGate: gate,
+        expectedRequestId: requestId
+    });
+    if (!validation.parsed || validation.errors.length > 0) {
         throw new VcmError({
-            code: "GATE_REVIEW_DECISION_MISSING",
-            message: `Gate review report must contain Decision: approve or Decision: request_changes.`,
+            code: gateReportErrorCode(validation.errors),
+            message: `Gate review report is invalid: ${validation.errors.join(" ")}`,
             statusCode: 500
         });
     }
-    const findings = extractFindings(content);
-    if (gate === "architecture-plan") {
-        validateArchitectureAnalysis(content);
-    }
     if (gate === "validation-adequacy") {
-        validateValidationAnalysis(content);
-        if (decision === "approve") {
+        if (validation.parsed.decision === "approve") {
             await validateValidationApprovalInput(fs, taskRepoRoot);
         }
     }
-    if (gate === "code-diff") {
-        validateCodeDiffAnalysis(content);
-    }
-    if (decision === "request_changes") {
-        validateRequestChangeFindings(findings);
-        if (gate === "code-diff") {
-            validateCodeDiffFindings(findings);
-        }
-    }
     return {
         gate,
-        requestId: parsedRequest,
-        decision,
-        summary: extractSummary(content),
-        findings,
+        requestId: validation.parsed.requestId,
+        decision: validation.parsed.decision,
+        summary: validation.parsed.summary,
+        findings: validation.parsed.findings,
         reportPath,
         content,
         parsedAt: timestamp
     };
 }
-function validateArchitectureAnalysis(content) {
-    const section = extractMarkdownSection(content, "Architecture Analysis");
-    if (!section) {
-        throw new VcmError({
-            code: "GATE_REVIEW_ARCHITECTURE_ANALYSIS_MISSING",
-            message: "Architecture-plan review must contain a non-empty Architecture Analysis section.",
-            statusCode: 500
-        });
-    }
-    const missingFields = ARCHITECTURE_ANALYSIS_FIELDS.filter((field) => !matchField(section, field));
-    if (missingFields.length > 0) {
-        throw new VcmError({
-            code: "GATE_REVIEW_ARCHITECTURE_ANALYSIS_INCOMPLETE",
-            message: `Architecture Analysis is missing required evidence: ${missingFields.join(", ")}.`,
-            statusCode: 500
-        });
-    }
-}
-function validateValidationAnalysis(content) {
-    const section = extractMarkdownSection(content, "Validation Analysis");
-    if (!section) {
-        throw new VcmError({
-            code: "GATE_REVIEW_VALIDATION_ANALYSIS_MISSING",
-            message: "Validation-adequacy review must contain a non-empty Validation Analysis section.",
-            statusCode: 500
-        });
-    }
-    const missingFields = VALIDATION_ANALYSIS_FIELDS.filter((field) => !matchField(section, field));
-    if (missingFields.length > 0) {
-        throw new VcmError({
-            code: "GATE_REVIEW_VALIDATION_ANALYSIS_INCOMPLETE",
-            message: `Validation Analysis is missing required evidence: ${missingFields.join(", ")}.`,
-            statusCode: 500
-        });
-    }
-}
-function validateCodeDiffAnalysis(content) {
-    const section = extractMarkdownSection(content, "Code Diff Analysis");
-    if (!section) {
-        throw new VcmError({
-            code: "GATE_REVIEW_CODE_DIFF_ANALYSIS_MISSING",
-            message: "Code-diff review must contain a non-empty Code Diff Analysis section.",
-            statusCode: 500
-        });
-    }
-    const missingFields = CODE_DIFF_ANALYSIS_FIELDS.filter((field) => !matchField(section, field));
-    if (missingFields.length > 0) {
-        throw new VcmError({
-            code: "GATE_REVIEW_CODE_DIFF_ANALYSIS_INCOMPLETE",
-            message: `Code Diff Analysis is missing required evidence: ${missingFields.join(", ")}.`,
-            statusCode: 500
-        });
-    }
+function gateReportErrorCode(errors) {
+    const message = errors.join(" ");
+    if (/Architecture Analysis must appear exactly once/.test(message))
+        return "GATE_REVIEW_ARCHITECTURE_ANALYSIS_MISSING";
+    if (/Architecture Analysis field/.test(message))
+        return "GATE_REVIEW_ARCHITECTURE_ANALYSIS_INCOMPLETE";
+    if (/Validation Analysis must appear exactly once/.test(message))
+        return "GATE_REVIEW_VALIDATION_ANALYSIS_MISSING";
+    if (/Validation Analysis field/.test(message))
+        return "GATE_REVIEW_VALIDATION_ANALYSIS_INCOMPLETE";
+    if (/Code Diff Analysis must appear exactly once/.test(message))
+        return "GATE_REVIEW_CODE_DIFF_ANALYSIS_MISSING";
+    if (/Code Diff Analysis field/.test(message))
+        return "GATE_REVIEW_CODE_DIFF_ANALYSIS_INCOMPLETE";
+    if (/Finding Scope|field File|field Line Or Symbol/.test(message)) {
+        return "GATE_REVIEW_CODE_DIFF_FINDING_LOCATION_MISSING";
+    }
+    if (/field Evidence|field Expected|field Gap|field Risk/.test(message))
+        return "GATE_REVIEW_FINDING_INCOMPLETE";
+    if (/requires at least one structured finding/.test(message))
+        return "GATE_REVIEW_FINDINGS_MISSING";
+    if (/Decision must/.test(message))
+        return "GATE_REVIEW_DECISION_MISSING";
+    if (/Gate must/.test(message))
+        return "GATE_REVIEW_REPORT_GATE_MISMATCH";
+    if (/Request must/.test(message))
+        return "GATE_REVIEW_REPORT_STALE";
+    return "GATE_REVIEW_REPORT_INVALID";
 }
 async function validateValidationApprovalInput(fs, taskRepoRoot) {
     const relativePath = CORE_INPUT_ARTIFACTS["validation-adequacy"];
@@ -1679,38 +1585,6 @@ function formatArtifactCheckFailure(check) {
 function renderFoundValue(value) {
     return value && value.trim().length > 0 ? JSON.stringify(value.trim()) : "<missing>";
 }
-function validateRequestChangeFindings(findings) {
-    if (findings.length === 0) {
-        throw new VcmError({
-            code: "GATE_REVIEW_FINDINGS_MISSING",
-            message: "A request_changes decision must contain at least one structured finding.",
-            statusCode: 500
-        });
-    }
-    const incomplete = findings.find((finding) => (!finding.evidence.trim()
-        || !finding.expected.trim()
-        || !finding.gap.trim()
-        || !finding.risk.trim()));
-    if (incomplete) {
-        throw new VcmError({
-            code: "GATE_REVIEW_FINDING_INCOMPLETE",
-            message: `Finding ${incomplete.title} must contain Evidence, Expected, Gap, and Risk.`,
-            statusCode: 500
-        });
-    }
-}
-function validateCodeDiffFindings(findings) {
-    const incomplete = findings.find((finding) => (!finding.file?.trim()
-        || !finding.location?.trim()
-        || !finding.scope));
-    if (incomplete) {
-        throw new VcmError({
-            code: "GATE_REVIEW_CODE_DIFF_FINDING_LOCATION_MISSING",
-            message: `Code-diff finding ${incomplete.title} must contain File, Line Or Symbol, and Finding Scope.`,
-            statusCode: 500
-        });
-    }
-}
 function extractMarkdownSection(content, heading) {
     const match = new RegExp(`^##\\s+${escapeRegex(heading)}\\s*$`, "im").exec(content);
     if (!match || match.index === undefined) {
@@ -1780,39 +1654,6 @@ function matchField(content, field) {
     const match = content.match(new RegExp(`^\\s*(?:[-*]\\s*)?${escapeRegex(field)}\\s*:\\s*(.+?)\\s*$`, "mi"));
     return match?.[1]?.trim();
 }
-function extractSummary(content) {
-    const field = matchField(content, "Summary");
-    if (field) {
-        return field;
-    }
-    const section = content.match(/^##\s+Summary\s*\n([\s\S]*?)(?=\n##\s+|\s*$)/im);
-    return section?.[1]?.trim() || undefined;
-}
-function extractFindings(content) {
-    const findings = [];
-    const blocks = content.split(/\n(?=#{2,4}\s+|-+\s*severity\s*:|severity\s*:)/i);
-    for (const block of blocks) {
-        const heading = block.match(/^#{2,4}\s+(critical|high|medium|low)\s*:\s*(.+)$/im);
-        const severity = normalizeSeverity(matchField(block, "severity") ?? heading?.[1]);
-        const title = matchField(block, "title") ?? heading?.[2]?.trim() ?? block.match(/^#{2,4}\s+(.+)$/m)?.[1]?.trim();
-        if (!severity || !title) {
-            continue;
-        }
-        findings.push({
-            severity,
-            title,
-            file: matchField(block, "file"),
-            line: parsePositiveInteger(matchField(block, "line")),
-            location: matchField(block, "line or symbol"),
-            scope: normalizeCodeDiffFindingScope(matchField(block, "finding scope")),
-            evidence: matchField(block, "evidence") ?? "",
-            expected: matchField(block, "expected") ?? "",
-            gap: matchField(block, "gap") ?? "",
-            risk: matchField(block, "risk") ?? ""
-        });
-    }
-    return findings;
-}
 function getSourceArtifacts(gate, codeDiffSources) {
     if (gate !== "code-diff") {
         return SOURCE_ARTIFACTS[gate];
@@ -1928,13 +1769,6 @@ function isFinding(value) {
 function isString(value) {
     return typeof value === "string";
 }
-function parsePositiveInteger(value) {
-    if (!value) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(value, 10);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
 function assertExceptionReason(reason) {
     if (!reason?.trim()) {
         throw new VcmError({
@@ -1998,16 +1832,7 @@ function errorMessage(error) {
     return "Unknown Gate review error.";
 }
 function isPendingReportError(error) {
-    return error instanceof VcmError && [
-        "GATE_REVIEW_DECISION_MISSING",
-        "GATE_REVIEW_ARCHITECTURE_ANALYSIS_MISSING",
-        "GATE_REVIEW_ARCHITECTURE_ANALYSIS_INCOMPLETE",
-        "GATE_REVIEW_FINDINGS_MISSING",
-        "GATE_REVIEW_FINDING_INCOMPLETE",
-        "GATE_REVIEW_REPORT_GATE_MISMATCH",
-        "GATE_REVIEW_REPORT_MISSING",
-        "GATE_REVIEW_REPORT_STALE"
-    ].includes(error.code);
+    return error instanceof VcmError && error.code === "GATE_REVIEW_REPORT_MISSING";
 }
 function delay(ms) {
     if (ms <= 0) {