vibe-coding-master 0.6.20 → 0.6.22

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

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import path from "node:path";
-import { GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
+import { CODE_DIFF_SOURCES, GATE_REVIEW_GATES } from "../../shared/types/gate-review.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -19,18 +19,25 @@ const SOURCE_ARTIFACTS = {
     ],
     "validation-adequacy": [
         ".ai/vcm/handoffs/architecture-plan.md",
-        ".ai/vcm/handoffs/review-report.md"
+        ".ai/vcm/handoffs/test-report.md"
     ],
-    "final-diff": [
+    "code-diff": []
+};
+const CODE_DIFF_SOURCE_ARTIFACTS = {
+    coder: [
         ".ai/vcm/handoffs/architecture-plan.md",
-        ".ai/vcm/handoffs/review-report.md",
-        ".ai/vcm/handoffs/docs-sync-report.md",
-        ".ai/vcm/handoffs/final-acceptance.md"
+        ".ai/vcm/handoffs/coder-completion.md"
+    ],
+    "architect-debug": [
+        ".ai/vcm/handoffs/role-commands/architect.md"
+    ],
+    "architect-diagnosis": [
+        ".ai/vcm/handoffs/architecture-diagnosis.md"
     ]
 };
 const CORE_INPUT_ARTIFACTS = {
     "architecture-plan": ".ai/vcm/handoffs/architecture-plan.md",
-    "validation-adequacy": ".ai/vcm/handoffs/review-report.md"
+    "validation-adequacy": ".ai/vcm/handoffs/test-report.md"
 };
 const VALID_SEVERITIES = new Set(["critical", "high", "medium", "low"]);
 export function createGateReviewService(deps) {
@@ -54,6 +61,11 @@ export function createGateReviewService(deps) {
         const context = await getContext(repoRoot, taskSlug);
         let index = await loadIndex(deps.fs, context, now());
         const record = index.gates[gate];
+        const requestedCodeDiffSource = options.codeDiffSource
+            ?? (options.force ? record.codeDiffSource : undefined);
+        const codeDiffSource = gate === "code-diff" && isCodeDiffSource(requestedCodeDiffSource)
+            ? requestedCodeDiffSource
+            : undefined;
         if (!context.config.enabled) {
             index = applyGateState(index, gate, {
                 status: "disabled",
@@ -84,6 +96,68 @@ export function createGateReviewService(deps) {
         if (record.status === "running" && !options.force) {
             return { status: "running", gate, record, message: "Gate review is already running." };
         }
+        if (gate === "code-diff" && !codeDiffSource) {
+            const message = "code-diff requires --source coder, --source architect-debug, or --source architect-diagnosis.";
+            index = applyGateState(index, gate, {
+                status: "failed",
+                decision: undefined,
+                error: message,
+                codeDiffSource: undefined,
+                requestId: undefined,
+                requestPath: undefined,
+                inputHash: undefined,
+                baseCommit: undefined,
+                headCommit: undefined,
+                commits: undefined,
+                changedFiles: undefined,
+                diffStat: undefined,
+                requestedAt: undefined,
+                startedAt: undefined,
+                completedAt: now(),
+                callbackStatus: "not_sent",
+                callbackError: undefined
+            }, now(), true);
+            await saveIndex(deps.fs, context.taskRepoRoot, index);
+            return {
+                status: "failed_to_start",
+                gate,
+                record: index.gates[gate],
+                message
+            };
+        }
+        if (gate === "code-diff") {
+            const dirtyStatus = await getDirtyCodeDiffStatus(deps.runner, context.taskRepoRoot);
+            if (dirtyStatus) {
+                const message = `code-diff requires committed inputs; commit or clean these changes first: ${dirtyStatus}`;
+                index = applyGateState(index, gate, {
+                    status: "failed",
+                    decision: undefined,
+                    error: message,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    baseCommit: undefined,
+                    headCommit: undefined,
+                    commits: undefined,
+                    changedFiles: undefined,
+                    diffStat: undefined,
+                    codeDiffSource,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: now(),
+                    callbackStatus: "not_sent",
+                    callbackError: undefined
+                }, now(), true);
+                await saveIndex(deps.fs, context.taskRepoRoot, index);
+                return {
+                    status: "failed_to_start",
+                    gate,
+                    record: index.gates[gate],
+                    message
+                };
+            }
+        }
         const coreInput = await readCoreInputArtifact(deps.fs, context.taskRepoRoot, gate);
         if (coreInput && coreInput.status !== "ready") {
             index = applyGateState(index, gate, {
@@ -108,7 +182,39 @@ export function createGateReviewService(deps) {
                 message: `${coreInput.path} is ${coreInput.status}.`
             };
         }
-        const inputHash = await computeInputHash(deps, context.taskRepoRoot, gate);
+        const codeDiffInput = gate === "code-diff"
+            ? await resolveCodeDiffInput(deps, context, record)
+            : undefined;
+        if (gate === "code-diff" && !codeDiffInput) {
+            index = applyGateState(index, gate, {
+                status: "not_required",
+                decision: undefined,
+                error: undefined,
+                exceptionReason: undefined,
+                requestId: undefined,
+                requestPath: undefined,
+                inputHash: undefined,
+                baseCommit: undefined,
+                headCommit: undefined,
+                commits: undefined,
+                changedFiles: undefined,
+                diffStat: undefined,
+                codeDiffSource,
+                requestedAt: undefined,
+                startedAt: undefined,
+                completedAt: undefined,
+                callbackStatus: "not_sent",
+                callbackError: undefined
+            }, now(), true);
+            await saveIndex(deps.fs, context.taskRepoRoot, index);
+            return {
+                status: "not_required",
+                gate,
+                record: index.gates[gate],
+                message: "No new commits to review."
+            };
+        }
+        const inputHash = await computeInputHash(deps, context.taskRepoRoot, gate, codeDiffInput, codeDiffSource);
         if (!options.force
             && record.status === "completed"
             && record.decision === "approve"
@@ -134,6 +240,12 @@ export function createGateReviewService(deps) {
             requestPath,
             promptPath,
             inputHash,
+            baseCommit: codeDiffInput?.baseCommit,
+            headCommit: codeDiffInput?.headCommit,
+            commits: codeDiffInput?.commits,
+            changedFiles: codeDiffInput?.changedFiles,
+            diffStat: codeDiffInput?.diffStat,
+            codeDiffSource,
             requestedAt: timestamp,
             startedAt: undefined,
             completedAt: undefined,
@@ -157,11 +269,13 @@ export function createGateReviewService(deps) {
             status: "requested",
             requestedAt: timestamp,
             inputHash,
+            codeDiffSource,
+            codeDiff: codeDiffInput,
             reportPath: nextRecord.reportPath,
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
-        void runGateReview(context, gate, requestId).catch(() => {
+        void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSource).catch(() => {
             // runGateReview records failures in the persisted gate state.
         });
         return {
@@ -171,7 +285,7 @@ export function createGateReviewService(deps) {
             message: "Gate review started."
         };
     }
-    async function runGateReview(context, gate, requestId) {
+    async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSource) {
         const runKey = `${context.taskRepoRoot}:${context.taskSlug}:${gate}`;
         if (activeRuns.has(runKey)) {
             return;
@@ -188,7 +302,7 @@ export function createGateReviewService(deps) {
             await updateRequestStatus(deps.fs, context, requestId, "running", { startedAt: timestamp });
             const reviewDir = resolveRepoPath(context.taskRepoRoot, GATE_REVIEW_DIR);
             const agentPath = resolveRepoPath(context.repoRoot, GATE_REVIEW_AGENT_PATH);
-            const prompt = buildGatePrompt(context, gate, requestId);
+            const prompt = buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSource);
             await deps.fs.ensureDir(reviewDir);
             await deps.fs.ensureDir(resolveRepoPath(context.taskRepoRoot, REQUESTS_DIR));
             await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, promptPathForRequest(requestId)), prompt);
@@ -374,8 +488,10 @@ export function createGateReviewService(deps) {
             });
             return loadIndex(deps.fs, nextContext, now());
         },
-        requestReviewGate(repoRoot, taskSlug, gate) {
-            return requestReviewGateInternal(repoRoot, taskSlug, gate);
+        requestReviewGate(repoRoot, taskSlug, gate, input) {
+            return requestReviewGateInternal(repoRoot, taskSlug, gate, {
+                codeDiffSource: input?.codeDiffSource
+            });
         },
         retryReviewGate(repoRoot, taskSlug, gate) {
             return requestReviewGateInternal(repoRoot, taskSlug, gate, { force: true });
@@ -476,6 +592,12 @@ function normalizeIndex(raw, config, timestamp) {
             requestId: typeof existing?.requestId === "string" ? existing.requestId : undefined,
             requestPath: typeof existing?.requestPath === "string" ? existing.requestPath : undefined,
             inputHash: typeof existing?.inputHash === "string" ? existing.inputHash : undefined,
+            baseCommit: typeof existing?.baseCommit === "string" ? existing.baseCommit : undefined,
+            headCommit: typeof existing?.headCommit === "string" ? existing.headCommit : undefined,
+            commits: Array.isArray(existing?.commits) ? existing.commits.filter(isString) : undefined,
+            changedFiles: Array.isArray(existing?.changedFiles) ? existing.changedFiles.filter(isString) : undefined,
+            diffStat: typeof existing?.diffStat === "string" ? existing.diffStat : undefined,
+            codeDiffSource: isCodeDiffSource(existing?.codeDiffSource) ? existing.codeDiffSource : undefined,
             summary: typeof existing?.summary === "string" ? existing.summary : undefined,
             findings: Array.isArray(existing?.findings) ? existing.findings.filter(isFinding) : undefined,
             error: typeof existing?.error === "string" ? existing.error : undefined,
@@ -521,7 +643,130 @@ function applyGateState(index, gate, patch, timestamp, clearActiveGate = false)
 async function saveIndex(fs, taskRepoRoot, index) {
     await fs.writeJsonAtomic(getIndexPath(taskRepoRoot), index);
 }
-async function computeInputHash(deps, taskRepoRoot, gate) {
+async function getDirtyCodeDiffStatus(runner, taskRepoRoot) {
+    const status = splitLines(await commandStdout(runner, taskRepoRoot, ["status", "--porcelain=v1"]));
+    if (status.length === 0) {
+        return undefined;
+    }
+    const visible = status.slice(0, 8).join("; ");
+    return status.length > 8
+        ? `${visible}; ... ${status.length - 8} more`
+        : visible;
+}
+async function resolveCodeDiffInput(deps, context, record) {
+    const headCommit = (await commandStdout(deps.runner, context.taskRepoRoot, ["rev-parse", "HEAD"])).trim();
+    if (!headCommit) {
+        throw new VcmError({
+            code: "GATE_REVIEW_CODE_DIFF_HEAD_MISSING",
+            message: "Unable to resolve current task worktree HEAD for code-diff gate.",
+            statusCode: 409
+        });
+    }
+    const baseCommit = await resolveCodeDiffBaseCommit(deps, context, record, headCommit);
+    if (!baseCommit || baseCommit === headCommit) {
+        return undefined;
+    }
+    const range = `${baseCommit}..${headCommit}`;
+    const commits = splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
+        "log",
+        "--oneline",
+        "--reverse",
+        range
+    ]));
+    if (commits.length === 0) {
+        return undefined;
+    }
+    const changedFiles = splitLines(await commandStdout(deps.runner, context.taskRepoRoot, [
+        "diff",
+        "--name-only",
+        "--find-renames",
+        range
+    ]));
+    const diffStat = await commandStdout(deps.runner, context.taskRepoRoot, [
+        "diff",
+        "--stat",
+        "--find-renames",
+        range
+    ]);
+    const diff = await commandStdout(deps.runner, context.taskRepoRoot, [
+        "diff",
+        "--binary",
+        "--find-renames",
+        range
+    ]);
+    const diffHash = createHash("sha256").update(diff).digest("hex");
+    return {
+        baseCommit,
+        headCommit,
+        commits,
+        changedFiles,
+        diffStat,
+        diffHash
+    };
+}
+async function resolveCodeDiffBaseCommit(deps, context, record, headCommit) {
+    if (record.gate === "code-diff"
+        && record.status === "completed"
+        && record.decision === "request_changes"
+        && record.baseCommit
+        && await isAncestor(deps.runner, context.taskRepoRoot, record.baseCommit, headCommit)) {
+        return record.baseCommit;
+    }
+    if (record.gate === "code-diff"
+        && record.status === "completed"
+        && record.decision === "approve"
+        && record.headCommit
+        && await isAncestor(deps.runner, context.taskRepoRoot, record.headCommit, headCommit)) {
+        return record.headCommit;
+    }
+    const rootHead = (await commandStdout(deps.runner, context.repoRoot, ["rev-parse", "HEAD"])).trim();
+    if (rootHead
+        && rootHead !== headCommit
+        && await isAncestor(deps.runner, context.taskRepoRoot, rootHead, headCommit)) {
+        return rootHead;
+    }
+    const rootBranch = (await commandStdout(deps.runner, context.repoRoot, [
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD"
+    ])).trim();
+    if (rootBranch && rootBranch !== "HEAD") {
+        const mergeBase = (await commandStdout(deps.runner, context.taskRepoRoot, [
+            "merge-base",
+            "HEAD",
+            rootBranch
+        ])).trim();
+        if (mergeBase
+            && mergeBase !== headCommit
+            && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
+            return mergeBase;
+        }
+    }
+    const upstream = (await commandStdout(deps.runner, context.taskRepoRoot, [
+        "rev-parse",
+        "--abbrev-ref",
+        "--symbolic-full-name",
+        "@{upstream}"
+    ])).trim();
+    if (upstream) {
+        const mergeBase = (await commandStdout(deps.runner, context.taskRepoRoot, [
+            "merge-base",
+            "HEAD",
+            upstream
+        ])).trim();
+        if (mergeBase
+            && mergeBase !== headCommit
+            && await isAncestor(deps.runner, context.taskRepoRoot, mergeBase, headCommit)) {
+            return mergeBase;
+        }
+    }
+    return headCommit;
+}
+async function isAncestor(runner, cwd, ancestor, descendant) {
+    const result = await runner.run("git", ["merge-base", "--is-ancestor", ancestor, descendant], { cwd });
+    return result.exitCode === 0;
+}
+async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDiffSource) {
     const digest = createHash("sha256");
     const coreArtifact = CORE_INPUT_ARTIFACTS[gate];
     if (coreArtifact) {
@@ -533,9 +778,11 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
         "CLAUDE.md",
         ".claude/agents/gate-reviewer.md",
         ".claude/skills/vcm-gate-review/SKILL.md",
-        ".ai/tools/request-gate-review"
+        ".ai/tools/request-gate-review",
+        "docs/CODING_STANDARDS.md"
     ];
-    for (const relativePath of [...common, ...SOURCE_ARTIFACTS[gate]]) {
+    const sourceArtifacts = getSourceArtifacts(gate, codeDiffSource);
+    for (const relativePath of [...common, ...sourceArtifacts]) {
         digest.update(relativePath);
         const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);
         if (await deps.fs.pathExists(absolutePath)) {
@@ -545,7 +792,21 @@ async function computeInputHash(deps, taskRepoRoot, gate) {
             digest.update("<missing>");
         }
     }
-    if (gate === "architecture-plan" || gate === "final-diff") {
+    if (gate === "code-diff" && codeDiffInput) {
+        digest.update("codeDiffSource");
+        digest.update(codeDiffSource ?? "<missing>");
+        digest.update("baseCommit");
+        digest.update(codeDiffInput.baseCommit);
+        digest.update("headCommit");
+        digest.update(codeDiffInput.headCommit);
+        digest.update("commits");
+        digest.update(codeDiffInput.commits.join("\n"));
+        digest.update("changedFiles");
+        digest.update(codeDiffInput.changedFiles.join("\n"));
+        digest.update("diffHash");
+        digest.update(codeDiffInput.diffHash);
+    }
+    if (gate === "architecture-plan") {
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["status", "--porcelain=v1"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--binary"]));
         digest.update(await commandStdout(deps.runner, taskRepoRoot, ["diff", "--cached", "--binary"]));
@@ -571,15 +832,39 @@ async function commandStdout(runner, cwd, args) {
     const result = await runner.run("git", args, { cwd });
     return result.exitCode === 0 ? result.stdout : "";
 }
-function buildGatePrompt(context, gate, requestId) {
+function splitLines(value) {
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSource) {
     const reportPath = reportPathForGate(gate);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
-    const evidence = SOURCE_ARTIFACTS[gate]
+    const evidence = getSourceArtifacts(gate, codeDiffSource)
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
-    const gitLine = gate === "architecture-plan" || gate === "final-diff"
+    const gitLine = gate === "architecture-plan"
         ? "\nDiff: inspect git status/diff in Worktree."
         : "";
+    const codeDiffSection = gate === "code-diff" && codeDiffInput
+        ? `
+
+Code Diff Input:
+This code-diff gate reviews the new commits from one PM route flow, not the whole task and not one terminal turn.
+Code source: ${codeDiffSource}
+Base commit: ${codeDiffInput.baseCommit}
+Head commit: ${codeDiffInput.headCommit}
+Commits:
+${codeDiffInput.commits.map((line) => `- ${line}`).join("\n")}
+Changed files:
+${codeDiffInput.changedFiles.length > 0 ? codeDiffInput.changedFiles.map((line) => `- ${line}`).join("\n") : "- <none>"}
+Diff commands:
+- git diff --stat --find-renames ${codeDiffInput.baseCommit}..${codeDiffInput.headCommit}
+- git diff --find-renames ${codeDiffInput.baseCommit}..${codeDiffInput.headCommit}
+- git show --stat --oneline <commit>
+Review only this commit range.`
+        : "";
     return `[VCM GATE REVIEW]
 Task: ${context.taskSlug}
 Worktree: ${context.taskRepoRoot}
@@ -588,7 +873,7 @@ Request: ${requestId}
 Report: ${absoluteReportPath}
 
 Evidence:
-${evidence}${gitLine}
+${evidence}${gitLine}${codeDiffSection}
 
 Write only Report. Start exactly:
 Gate: ${gate}
@@ -707,7 +992,7 @@ async function readJsonOrNull(fs, targetPath) {
     }
 }
 function matchField(content, field) {
-    const match = content.match(new RegExp(`^\\s*${escapeRegex(field)}\\s*:\\s*(.+?)\\s*$`, "mi"));
+    const match = content.match(new RegExp(`^\\s*(?:[-*]\\s*)?${escapeRegex(field)}\\s*:\\s*(.+?)\\s*$`, "mi"));
     return match?.[1]?.trim();
 }
 function extractSummary(content) {
@@ -722,8 +1007,9 @@ 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 severity = normalizeSeverity(matchField(block, "severity"));
-        const title = matchField(block, "title") ?? block.match(/^#{2,4}\s+(.+)$/m)?.[1]?.trim();
+        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;
         }
@@ -740,6 +1026,15 @@ function extractFindings(content) {
     }
     return findings;
 }
+function getSourceArtifacts(gate, codeDiffSource) {
+    if (gate !== "code-diff") {
+        return SOURCE_ARTIFACTS[gate];
+    }
+    return codeDiffSource ? CODE_DIFF_SOURCE_ARTIFACTS[codeDiffSource] : [];
+}
+export function isCodeDiffSource(value) {
+    return typeof value === "string" && CODE_DIFF_SOURCES.includes(value);
+}
 function normalizeGateStatus(value) {
     return typeof value === "string" && [
         "disabled",
@@ -775,6 +1070,9 @@ function isFinding(value) {
     const candidate = value;
     return Boolean(normalizeSeverity(candidate.severity) && candidate.title);
 }
+function isString(value) {
+    return typeof value === "string";
+}
 function parsePositiveInteger(value) {
     if (!value) {
         return undefined;

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

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
-import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
+import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/validation/artifact-check.js";
 import { resolveRepoPath, toRepoRelativePath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -47,10 +47,15 @@ export function createHarnessFeedbackService(deps) {
         const finalAcceptanceAbsolutePath = resolveRepoPath(input.taskRepoRoot, finalAcceptancePath);
         const finalAcceptanceContent = await readAbsoluteOptionalText(finalAcceptanceAbsolutePath);
         const finalAcceptanceCheck = checkMarkdownArtifact("final-acceptance", finalAcceptancePath, finalAcceptanceContent ?? null);
-        if (finalAcceptanceCheck.status !== "ok" || !finalAcceptanceContent) {
+        const finalAcceptanceDecision = finalAcceptanceContent
+            ? readArtifactSectionValue(finalAcceptanceContent, "Decision")?.toLowerCase()
+            : undefined;
+        if (finalAcceptanceCheck.status !== "ok"
+            || !finalAcceptanceContent
+            || (finalAcceptanceDecision !== "accepted" && finalAcceptanceDecision !== "accepted-with-known-risks")) {
             throw new VcmError({
                 code: "TASK_FINAL_ACCEPTANCE_NOT_READY",
-                message: "Task final acceptance is not complete yet.",
+                message: "Task Harness Retrospective requires a completed code-change flow.",
                 statusCode: 409,
                 hint: `${finalAcceptancePath} must pass the final-acceptance artifact check before Task Harness Retrospective can start.`
             });