vibe-coding-master 0.7.46 → 0.7.48

package/dist/backend/services/harness-feedback-service.js

@@ -4,6 +4,7 @@ import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/va
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { parseHarnessFeedbackArtifact } from "./managed-artifact-validation.js";
 const FEEDBACK_ROOT = ".ai/vcm/harness-feedback";
 const PENDING_DIR = `${FEEDBACK_ROOT}/pending`;
 const TASK_RETROSPECTIVE_DIR = `${FEEDBACK_ROOT}/task-retrospectives`;
@@ -266,19 +267,22 @@ export function createHarnessFeedbackService(deps) {
     }
     function parseFeedbackItem(relativePath, content) {
         const id = sanitizeFeedbackId(path.posix.basename(relativePath, ".md"));
-        const metadata = parseSimpleMetadata(content);
-        const title = firstHeading(content)
-            ?? metadata.summary
-            ?? metadata["observed problem"]
-            ?? id;
+        const validation = parseHarnessFeedbackArtifact(content);
+        if (!validation.parsed || validation.errors.length > 0) {
+            throw new VcmError({
+                code: "HARNESS_FEEDBACK_INVALID",
+                message: `Invalid Harness Feedback ${relativePath}: ${validation.errors.join(" ")}`,
+                statusCode: 422
+            });
+        }
         return {
             id,
-            title: compactLine(title),
+            title: compactLine(validation.parsed.title),
             path: relativePath,
             source: "role-feedback",
-            reporterRole: metadata["reporter role"] ?? metadata.reporter,
-            taskSlug: metadata["task slug"] ?? metadata.task,
-            summary: metadata.summary
+            reporterRole: validation.parsed.reporterRole,
+            taskSlug: validation.parsed.taskSlug,
+            summary: validation.parsed.summary
         };
     }
     function buildTaskRetrospectivePrompt(repoRoot, analysisPath, pendingFeedbackPaths, memoryReview) {
@@ -493,21 +497,6 @@ function getRetrospectiveReportErrors(content) {
     }
     return errors;
 }
-function parseSimpleMetadata(content) {
-    const result = {};
-    for (const line of content.split(/\r?\n/).slice(0, 80)) {
-        const match = /^[-*]?\s*([A-Za-z][A-Za-z -]{1,40})\s*:\s*(.+)$/.exec(line.trim());
-        if (!match) {
-            continue;
-        }
-        result[match[1].trim().toLowerCase()] = match[2].trim();
-    }
-    return result;
-}
-function firstHeading(content) {
-    const heading = content.split(/\r?\n/).find((line) => /^#{1,3}\s+\S/.test(line));
-    return heading?.replace(/^#{1,3}\s+/, "").trim();
-}
 function compactLine(value) {
     return value.replace(/\s+/g, " ").trim().slice(0, 160);
 }

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

@@ -5,7 +5,9 @@ import { renderArchitectHarnessRules } from "../templates/harness/architect-agen
 import { CODE_ROLE_DISALLOWED_TOOLS, REVIEWER_DISALLOWED_TOOLS } from "../role-tool-policy.js";
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderCoderWorkerHarnessRules } from "../templates/harness/coder-worker-agent.js";
+import { renderArchitectEvidenceWorkerHarnessRules } from "../templates/harness/architect-evidence-worker-agent.js";
 import { renderArchitectScaffoldWorkerHarnessRules } from "../templates/harness/architect-scaffold-worker-agent.js";
+import { renderArchitectValidationWorkerHarnessRules } from "../templates/harness/architect-validation-worker-agent.js";
 import { renderReviewerAgentRules, renderRequestGateReviewTool, renderTranslatorAgentRules, renderVcmGateReviewSkillRules } from "../templates/harness/gate-review.js";
 import { renderHarnessEngineerHarnessRules } from "../templates/harness/harness-engineer-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
@@ -255,6 +257,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("vcm-coder-worker", "Bounded VCM implementation worker for assigned modules, files, and VCM:CODE markers from Coder.", { model: "inherit" }),
         renderRules: renderCoderWorkerHarnessRules
     },
+    {
+        kind: "agent-architect-evidence-worker",
+        path: ".claude/agents/vcm-architect-evidence-worker.md",
+        title: "VCM Architect Evidence Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-architect-evidence-worker", "Foreground Architect worker for bounded project evidence collection.", { tools: "Read, Grep, Glob, Write", model: "opus", effort: "xhigh" }),
+        renderRules: renderArchitectEvidenceWorkerHarnessRules
+    },
     {
         kind: "agent-architect-scaffold-worker",
         path: ".claude/agents/vcm-architect-scaffold-worker.md",
@@ -262,6 +271,13 @@ const HARNESS_FILES = [
         frontmatter: renderAgentFrontmatter("vcm-architect-scaffold-worker", "Foreground Architect worker for exact scaffold execution and scaffold validation.", { model: "opus", effort: "xhigh" }),
         renderRules: renderArchitectScaffoldWorkerHarnessRules
     },
+    {
+        kind: "agent-architect-validation-worker",
+        path: ".claude/agents/vcm-architect-validation-worker.md",
+        title: "VCM Architect Validation Worker Agent",
+        frontmatter: renderAgentFrontmatter("vcm-architect-validation-worker", "Foreground Architect worker for exact assigned command execution and evidence capture.", { tools: "Read, Grep, Glob, Bash, Write", model: "opus", effort: "xhigh" }),
+        renderRules: renderArchitectValidationWorkerHarnessRules
+    },
     {
         kind: "tool-request-gate-review",
         path: ".ai/tools/request-gate-review",

package/dist/backend/services/managed-artifact-validation.js

@@ -0,0 +1,403 @@
+import { CODE_DIFF_FINDING_SCOPES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
+import { getManagedArtifactDefinition, isArtifactKind } from "../../shared/validation/artifact-registry.js";
+import { parseMemoryProposal } from "./memory-proposal-validation.js";
+export const ROUTE_MESSAGE_TYPES = [
+    "task",
+    "question",
+    "revise",
+    "cancel",
+    "result",
+    "blocked",
+    "finding"
+];
+export const GATE_ANALYSIS_HEADINGS = {
+    "architecture-plan": "Architecture Analysis",
+    "validation-adequacy": "Validation Analysis",
+    "code-diff": "Code Diff Analysis"
+};
+export const GATE_ANALYSIS_FIELDS = {
+    "architecture-plan": [
+        "Evidence Read",
+        "Architecture Brief Fit",
+        "End-To-End Flow",
+        "Scope Fit",
+        "Code Reality",
+        "Invalidated Assumptions",
+        "Existing-Class Completeness",
+        "Ownership",
+        "Data Flow",
+        "Lifecycle",
+        "Invariants",
+        "Boundaries And Public Surface",
+        "Failure Model",
+        "Coder Readiness"
+    ],
+    "validation-adequacy": [
+        "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"
+    ],
+    "code-diff": [
+        "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 PLACEHOLDER_VALUE = /^(?:TBD|Not run yet\.?|<[^>]+>)$/i;
+export function validateManagedArtifactContent(kind, content, context) {
+    const definition = getManagedArtifactDefinition(kind);
+    if (!definition.allowedModes.includes(context.mode)) {
+        return {
+            errors: [`${kind} supports only ${definition.allowedModes.join("|")} mode.`],
+            status: "incomplete"
+        };
+    }
+    if (isArtifactKind(kind)) {
+        const check = checkMarkdownArtifact(kind, context.path, content, { mode: context.mode });
+        return {
+            errors: artifactCheckErrors(check, context.mode),
+            status: check.status,
+            check
+        };
+    }
+    const result = kind === "route-message"
+        ? parseRouteMessageArtifact(content)
+        : kind === "coder-worker-report"
+            ? parseCoderWorkerReportArtifact(content)
+            : kind === "gate-review-report"
+                ? parseGateReviewReportArtifact(content, {
+                    expectedGate: context.expectedGate,
+                    expectedRequestId: context.expectedRequestId
+                })
+                : kind === "memory-proposal"
+                    ? parseMemoryProposalArtifact(content)
+                    : parseHarnessFeedbackArtifact(content);
+    return {
+        errors: result.errors,
+        status: result.errors.length === 0 ? "accepted" : "incomplete",
+        parsed: result.parsed
+    };
+}
+export function parseRouteMessageArtifact(content) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
+    if (!frontmatter) {
+        return { errors: ["Route message requires YAML-style frontmatter bounded by ---."] };
+    }
+    const fields = parseColonFields(frontmatter[1]);
+    const errors = [];
+    const type = fields.type;
+    if (!type || !ROUTE_MESSAGE_TYPES.includes(type)) {
+        errors.push(`Frontmatter type must be exactly one of ${ROUTE_MESSAGE_TYPES.join("|")}.`);
+    }
+    const body = content.slice(frontmatter[0].length).trim();
+    if (!body) {
+        errors.push("Route message body must not be empty.");
+    }
+    if (errors.length > 0) {
+        return { errors };
+    }
+    const refs = fields.artifact_refs ?? fields.artifactRefs ?? fields.related_artifact;
+    return {
+        errors: [],
+        parsed: {
+            type: type,
+            body,
+            artifactRefs: refs ? refs.split(",").map((entry) => entry.trim()).filter(Boolean) : []
+        }
+    };
+}
+export function parseCoderWorkerReportArtifact(content) {
+    const definition = getManagedArtifactDefinition("coder-worker-report");
+    const errors = validateRequiredHeadings(content, definition.requiredHeadings);
+    const titleMatches = [...content.matchAll(/^# Coder Worker Report:\s*(\S.+?)\s*$/gm)];
+    if (titleMatches.length !== 1) {
+        errors.push("Coder Worker report requires exactly one '# Coder Worker Report: <worker-id>' title.");
+    }
+    const workerState = readUniqueField(content, "Worker State", errors);
+    if (workerState !== "completed") {
+        errors.push(`Worker State must be exactly completed; found ${renderFoundValue(workerState)}.`);
+    }
+    const implementationResult = readUniqueField(content, "Implementation Result", errors);
+    if (implementationResult !== "success" && implementationResult !== "has_failed_items") {
+        errors.push(`Implementation Result must be exactly success|has_failed_items; found ${renderFoundValue(implementationResult)}.`);
+    }
+    if (errors.length > 0) {
+        return { errors };
+    }
+    return {
+        errors: [],
+        parsed: {
+            workerId: titleMatches[0][1].trim(),
+            workerState: "completed",
+            implementationResult: implementationResult
+        }
+    };
+}
+export function parseGateReviewReportArtifact(content, context = {}) {
+    const errors = [];
+    const gateValue = readUniqueField(content, "Gate", errors);
+    const requestId = readUniqueField(content, "Request", errors);
+    const decisionValue = readUniqueField(content, "Decision", errors);
+    const summary = readUniqueField(content, "Summary", errors);
+    const gate = GATE_REVIEW_GATES.includes(gateValue)
+        ? gateValue
+        : undefined;
+    if (!gate) {
+        errors.push(`Gate must be exactly one of ${GATE_REVIEW_GATES.join("|")}; found ${renderFoundValue(gateValue)}.`);
+    }
+    if (context.expectedGate && gateValue !== context.expectedGate) {
+        errors.push(`Gate must be ${context.expectedGate}; found ${renderFoundValue(gateValue)}.`);
+    }
+    if (context.expectedRequestId && requestId !== context.expectedRequestId) {
+        errors.push(`Request must be ${context.expectedRequestId}; found ${renderFoundValue(requestId)}.`);
+    }
+    if (decisionValue !== "approve" && decisionValue !== "request_changes") {
+        errors.push(`Decision must be exactly approve|request_changes; found ${renderFoundValue(decisionValue)}.`);
+    }
+    if (!isSubstantiveValue(summary)) {
+        errors.push("Summary must contain a substantive one-line value.");
+    }
+    let analysis = {};
+    if (gate) {
+        const expectedHeading = GATE_ANALYSIS_HEADINGS[gate];
+        for (const candidate of Object.values(GATE_ANALYSIS_HEADINGS)) {
+            const count = countMarkdownHeading(content, candidate);
+            if (candidate === expectedHeading && count !== 1) {
+                errors.push(`${expectedHeading} must appear exactly once; found ${count}.`);
+            }
+            if (candidate !== expectedHeading && count !== 0) {
+                errors.push(`${candidate} is not allowed for the ${gate} gate.`);
+            }
+        }
+        const section = readMarkdownSection(content, expectedHeading);
+        if (section) {
+            analysis = parseRequiredBulletFields(section, GATE_ANALYSIS_FIELDS[gate], errors, expectedHeading);
+        }
+    }
+    const findingsCount = countMarkdownHeading(content, "Findings");
+    if (findingsCount !== 1) {
+        errors.push(`Findings must appear exactly once; found ${findingsCount}.`);
+    }
+    const findingsBody = readMarkdownSection(content, "Findings");
+    let findings = [];
+    if (decisionValue === "approve") {
+        if (findingsBody?.trim() !== "None.") {
+            errors.push('Findings must contain exactly "None." when Decision is approve.');
+        }
+    }
+    else if (decisionValue === "request_changes") {
+        const parsedFindings = parseGateFindings(findingsBody ?? "", gate, errors);
+        findings = parsedFindings;
+        if (findings.length === 0) {
+            errors.push("Decision request_changes requires at least one structured finding.");
+        }
+    }
+    if (errors.length > 0 || !gate || !requestId || !summary) {
+        return { errors };
+    }
+    return {
+        errors: [],
+        parsed: {
+            gate,
+            requestId,
+            decision: decisionValue,
+            summary,
+            findings,
+            analysis
+        }
+    };
+}
+export function parseMemoryProposalArtifact(content) {
+    const result = parseMemoryProposal(content);
+    return result.error
+        ? { errors: [`Memory proposal ${result.error}.`] }
+        : { errors: [], parsed: result.proposal };
+}
+export function parseHarnessFeedbackArtifact(content) {
+    const errors = [];
+    const titleMatches = [...content.matchAll(/^#\s+(\S.+?)\s*$/gm)];
+    if (titleMatches.length !== 1) {
+        errors.push(`Harness Feedback requires exactly one '# <short problem title>' heading.`);
+    }
+    const fieldNames = [
+        "Reporter role",
+        "Task slug",
+        "Summary",
+        "Observed problem",
+        "Expected behavior",
+        "Evidence",
+        "Suspected harness area",
+        "Impact",
+        "Urgency"
+    ];
+    const values = {};
+    for (const field of fieldNames) {
+        const matches = [...content.matchAll(new RegExp(`^- ${escapeRegExp(field)}:\\s*(.*?)\\s*$`, "gmi"))];
+        if (matches.length !== 1 || !isSubstantiveValue(matches[0]?.[1])) {
+            errors.push(`Harness Feedback field ${field} must appear exactly once with a substantive value.`);
+            continue;
+        }
+        values[field] = matches[0][1].trim();
+    }
+    if (values.Urgency !== "low" && values.Urgency !== "medium" && values.Urgency !== "high") {
+        errors.push(`Urgency must be exactly low|medium|high; found ${renderFoundValue(values.Urgency)}.`);
+    }
+    if (errors.length > 0) {
+        return { errors };
+    }
+    return {
+        errors: [],
+        parsed: {
+            title: titleMatches[0][1].trim(),
+            reporterRole: values["Reporter role"],
+            taskSlug: values["Task slug"],
+            summary: values.Summary,
+            observedProblem: values["Observed problem"],
+            expectedBehavior: values["Expected behavior"],
+            evidence: values.Evidence,
+            suspectedHarnessArea: values["Suspected harness area"],
+            impact: values.Impact,
+            urgency: values.Urgency
+        }
+    };
+}
+export 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 parseGateFindings(content, gate, errors) {
+    const headings = [...content.matchAll(/^### (critical|high|medium|low):\s*(\S.+?)\s*$/gmi)];
+    if (headings.length === 0) {
+        return [];
+    }
+    if (content.slice(0, headings[0].index).trim()) {
+        errors.push("Findings must contain only structured ### <severity>: <title> blocks.");
+    }
+    const findings = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const start = (heading.index ?? 0) + heading[0].length;
+        const end = index + 1 < headings.length ? headings[index + 1].index ?? content.length : content.length;
+        const block = content.slice(start, end).trim();
+        const fields = parseRequiredBulletFields(block, ["Evidence", "Expected", "Gap", "Risk"], errors, heading[2]);
+        const finding = {
+            severity: heading[1].toLowerCase(),
+            title: heading[2].trim(),
+            evidence: fields.Evidence ?? "",
+            expected: fields.Expected ?? "",
+            gap: fields.Gap ?? "",
+            risk: fields.Risk ?? ""
+        };
+        if (gate === "code-diff") {
+            const codeFields = parseRequiredBulletFields(block, ["File", "Line Or Symbol", "Finding Scope"], errors, heading[2]);
+            if (!CODE_DIFF_FINDING_SCOPES.includes(codeFields["Finding Scope"])) {
+                errors.push(`${heading[2]} Finding Scope must be exactly ${CODE_DIFF_FINDING_SCOPES.join("|")}; found ${renderFoundValue(codeFields["Finding Scope"])}.`);
+            }
+            finding.file = codeFields.File;
+            finding.location = codeFields["Line Or Symbol"];
+            finding.scope = codeFields["Finding Scope"];
+        }
+        findings.push(finding);
+    }
+    return findings;
+}
+function parseRequiredBulletFields(content, requiredFields, errors, sectionName) {
+    const values = {};
+    for (const field of requiredFields) {
+        const matches = [...content.matchAll(new RegExp(`^- ${escapeRegExp(field)}:\\s*(.*?)\\s*$`, "gmi"))];
+        if (matches.length !== 1) {
+            errors.push(`${sectionName} field ${field} must appear exactly once; found ${matches.length}.`);
+            continue;
+        }
+        const value = matches[0][1].trim();
+        if (!isSubstantiveValue(value)) {
+            errors.push(`${sectionName} field ${field} must contain a substantive value.`);
+            continue;
+        }
+        values[field] = value;
+    }
+    return values;
+}
+function validateRequiredHeadings(content, headings) {
+    const errors = [];
+    let previous = -1;
+    for (const heading of headings) {
+        const matches = [...content.matchAll(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "gmi"))];
+        if (matches.length !== 1) {
+            errors.push(`Heading ${heading} must appear exactly once; found ${matches.length}.`);
+            continue;
+        }
+        const index = matches[0].index ?? -1;
+        if (index < previous) {
+            errors.push(`Heading ${heading} is out of the required order.`);
+        }
+        previous = index;
+    }
+    return errors;
+}
+function readUniqueField(content, field, errors) {
+    const matches = [...content.matchAll(new RegExp(`^${escapeRegExp(field)}:\\s*(.*?)\\s*$`, "gmi"))];
+    if (matches.length !== 1) {
+        errors.push(`${field} must appear exactly once; found ${matches.length}.`);
+        return undefined;
+    }
+    return matches[0][1].trim();
+}
+function readMarkdownSection(content, heading) {
+    const match = new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "mi").exec(content);
+    if (!match || match.index === undefined) {
+        return undefined;
+    }
+    const remainder = content.slice(match.index + match[0].length);
+    const nextHeading = remainder.search(/^##\s+/m);
+    return (nextHeading >= 0 ? remainder.slice(0, nextHeading) : remainder).trim();
+}
+function countMarkdownHeading(content, heading) {
+    return [...content.matchAll(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "gmi"))].length;
+}
+function parseColonFields(content) {
+    const fields = {};
+    for (const line of content.split(/\r?\n/)) {
+        const delimiter = line.indexOf(":");
+        if (delimiter <= 0) {
+            continue;
+        }
+        fields[line.slice(0, delimiter).trim()] = line.slice(delimiter + 1).trim();
+    }
+    return fields;
+}
+function isSubstantiveValue(value) {
+    return Boolean(value?.trim() && !PLACEHOLDER_VALUE.test(value.trim()));
+}
+function renderFoundValue(value) {
+    return value?.trim() ? JSON.stringify(value.trim()) : "<missing>";
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

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

@@ -2,8 +2,10 @@ import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { CORE_VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
+import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { renderMessageEnvelope } from "../templates/message-envelope.js";
+import { parseRouteMessageArtifact } from "./managed-artifact-validation.js";
 const PM_ROLE = "project-manager";
 const DEFAULT_PRE_DISPATCH_SWITCH_DELAY_MS = 500;
 const DEFAULT_AUTO_DISPATCH_ENTER_DELAY_MS = 500;
@@ -381,6 +383,9 @@ async function listRouteFiles(fs, input) {
         }
         const relativePath = path.posix.join(routeDir, entry);
         const content = await fs.readText(resolveRepoPath(repoRoot, relativePath));
+        if (!content.trim()) {
+            continue;
+        }
         const parsed = parseRouteFileContent(content, route.fromRole, route.toRole);
         routeFiles.push({
             path: relativePath,
@@ -410,71 +415,15 @@ function parseRouteFileName(fileName) {
     return undefined;
 }
 function parseRouteFileContent(content, fromRole, toRole) {
-    const { frontmatter, body } = splitFrontmatter(content);
-    const type = parseMessageType(frontmatter.type) ?? getDefaultMessageType(fromRole, toRole);
-    const artifactRefs = parseArtifactRefs(frontmatter);
-    return {
-        type,
-        body: body.trim(),
-        artifactRefs
-    };
-}
-function splitFrontmatter(content) {
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-    if (!match) {
-        return { frontmatter: {}, body: content };
-    }
-    const frontmatter = {};
-    for (const line of match[1].split(/\r?\n/)) {
-        const delimiter = line.indexOf(":");
-        if (delimiter <= 0) {
-            continue;
-        }
-        const key = line.slice(0, delimiter).trim();
-        const value = line.slice(delimiter + 1).trim();
-        if (key) {
-            frontmatter[key] = value;
-        }
-    }
-    return {
-        frontmatter,
-        body: content.slice(match[0].length)
-    };
-}
-function parseMessageType(value) {
-    const validTypes = [
-        "user-request",
-        "task",
-        "question",
-        "blocked",
-        "result",
-        "finding",
-        "review-request",
-        "revise",
-        "cancel"
-    ];
-    return value && validTypes.includes(value)
-        ? value
-        : undefined;
-}
-function parseArtifactRefs(frontmatter) {
-    const refs = frontmatter.artifact_refs ?? frontmatter.artifactRefs ?? frontmatter.related_artifact;
-    if (!refs) {
-        return [];
-    }
-    return refs
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
-function getDefaultMessageType(fromRole, toRole) {
-    if (fromRole === PM_ROLE && toRole !== PM_ROLE) {
-        return "task";
-    }
-    if (fromRole !== PM_ROLE && toRole === PM_ROLE) {
-        return "result";
+    const result = parseRouteMessageArtifact(content);
+    if (!result.parsed || result.errors.length > 0) {
+        throw new VcmError({
+            code: "ROUTE_MESSAGE_INVALID",
+            message: `Invalid route message ${fromRole} -> ${toRole}: ${result.errors.join(" ")}`,
+            statusCode: 422
+        });
     }
-    return "question";
+    return result.parsed;
 }
 function isAllowedRoute(fromRole, toRole) {
     return (fromRole === PM_ROLE && toRole !== PM_ROLE) || (fromRole !== PM_ROLE && toRole === PM_ROLE);

package/dist/backend/services/runtime-recovery-service.js

@@ -35,6 +35,7 @@ export function createRuntimeRecoveryService(deps) {
                     await recoverMessages(taskRepoRoot, config.stateRoot, task.taskSlug, recoveredAt, context);
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
                     await cleanupCoderWorkers(taskRepoRoot, context);
+                    await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }

package/dist/backend/services/task-close-service.js

@@ -5,7 +5,9 @@ export function createTaskCloseService(deps) {
         async closeTask(repoRoot, taskSlug) {
             const task = await deps.taskService.markTaskCleaned(repoRoot, taskSlug);
             const warnings = [];
-            deps.architectRestartService?.clear(repoRoot, taskSlug);
+            if (deps.architectRestartService) {
+                await bestEffort("Unable to clear Architect restart state", () => deps.architectRestartService.clear(repoRoot, taskSlug), warnings);
+            }
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);

package/dist/backend/templates/harness/architect-agent.js

@@ -38,6 +38,21 @@ ${renderRoleMemoryRules("architect")}
 - Before ending any turn, ensure all information required to continue the current Architect work is present in the current artifacts.
 - Keep artifacts current and self-contained. Replace superseded content instead of appending conversation history or investigation logs.
 
+### Architect Worker Delegation
+
+- Architect may invoke only \`vcm-architect-evidence-worker\`, \`vcm-architect-scaffold-worker\`, and \`vcm-architect-validation-worker\`.
+- Every worker must run in the foreground and return before the current Architect turn continues. Do not run workers in the background or end the turn while a worker is active.
+- Give each worker an exact bounded assignment, repo-relative paths, questions or commands, and one report path. Pass paths instead of copying full source, documents, or plans into the worker prompt.
+- Worker output is evidence or execution output, never an architecture decision. Architect owns every conclusion, plan, change boundary, validation interpretation, and final claim.
+- Use \`vcm-architect-evidence-worker\` for bounded bulk reading when relevant evidence spans multiple files or modules. Evidence workers may run in parallel only when their read scopes are disjoint.
+- Evidence workers write reports under \`.ai/vcm/architect-workers/evidence/\`. Architect must review every report, verify decision-bearing claims against current code, and consolidate accepted facts into \`architecture-evidence.md\`.
+- In Planning Code Reading, supporting non-decision-bearing read requirements may be satisfied by an accepted evidence-worker report; requirements that say Architect must personally read or verify may not.
+- Use \`vcm-architect-scaffold-worker\` after the plan and Scaffold Manifest are complete for exact scaffold execution and mechanical text or configuration changes already fixed by the plan.
+- Use \`vcm-architect-validation-worker\` for exact non-interactive commands already selected by Architect. The worker does not select validation scope, modify tests or code, diagnose failures, or decide whether validation is sufficient.
+- Do not rerun a green command already reported by another Architect worker merely to execute it in the main Architect context.
+- Validation workers write reports under \`.ai/vcm/architect-workers/validation/\`. Architect must interpret the raw results and copy required evidence into the owning Architect artifact.
+- Remove \`.ai/vcm/architect-workers/\` after its accepted facts and command results have been consolidated into Architect-owned artifacts.
+
 ### Architecture Interview
 
 - Before the first Architecture Planning step of Code-Change Flow, use \`vcm-architecture-interview\` and complete \`.ai/vcm/handoffs/architecture-brief.md\` and \`.ai/vcm/handoffs/architecture-evidence.md\`.
@@ -57,10 +72,11 @@ ${renderRoleMemoryRules("architect")}
 ### Planning Code Reading
 
 - Do not plan from session memory, architecture docs, generated context, or code comments alone. Re-read current-worktree source and verify actual behavior from implementation.
-- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation, then read every resolved callable unit in full.
+- Use \`vcm-code-navigation\` for symbol definitions, implementations, references, call hierarchies, and bounded behavior paths. Start from generated indexes, use LSP semantic navigation, then personally read every decision-bearing callable unit in full.
+- Delegate bounded supporting implementation and document reading to \`vcm-architect-evidence-worker\` when it would otherwise add substantial raw context. Worker reports do not replace Architect's LSP verification of decision-bearing symbols, relationships, public surfaces, ownership, lifecycle, failure paths, contradictions, or unresolved evidence.
 - If LSP cannot resolve a required project-owned relationship, record the limitation in \`architecture-evidence.md\` and leave it unresolved.
 - Define the planning boundary as the affected feature or module and identify every existing or intended observable entry point for the behavior being changed.
-- Read the complete implementation of each relevant existing entry point.
+- Personally read the complete implementation of each decision-bearing existing entry point. Supporting entry points may be covered by accepted evidence-worker reports when their facts do not determine the architecture decision.
 - Follow every project-owned call path the plan will change through cross-module calls, state reads and writes, persistence, side effects, completion and failure signals, and consumers.
 - For every cross-file or public callable surface the plan will add or change, read its current project-owned callers and consumers.
 - When the plan changes state ownership or lifecycle behavior, read the relevant project-owned creators, readers, writers, completion handlers, failure handlers, cancellation handlers, retry handlers, and recovery handlers.
@@ -125,7 +141,6 @@ ${renderRoleMemoryRules("architect")}
 #### Code Scaffolding
 
 - Use the Agent tool to invoke \`vcm-architect-scaffold-worker\` in the foreground after the plan and Scaffold Manifest are complete. Give it the exact plan path and require it to return before this Architect turn continues.
-- Do not invoke any other subagent.
 - Use one scaffold worker. Do not run it in the background or end the Architect turn while it is active.
 - Review the worker commit, actual diff, callable surfaces, marker placement, ledger reconciliation, and L0 results yourself. Architect owns every final scaffold claim and must correct any worker error before marking planning complete.
 - Create or update only the minimum module/file scaffolding needed to make boundaries, callable surfaces, and placeholders unambiguous. Minimum limits depth (no business implementation), never breadth: every \`create\`, \`change\`, and \`delete\` item must be scaffolded.