vibe-coding-master 0.7.47 → 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/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);