vibe-coding-master 0.7.33 → 0.7.35

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

@@ -12,7 +12,8 @@ const REQUESTS_DIR = ".ai/vcm/gate-reviews/requests";
 const GATE_REVIEW_VERSION = 1;
 const REVIEWER_ROLE = "reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
-const activeRuns = new Set();
+const activeRuns = new Map();
+const gateStateLocks = new Map();
 const ARCHITECTURE_ANALYSIS_FIELDS = [
     "Evidence Read",
     "Architecture Brief Fit",
@@ -111,6 +112,9 @@ export function createGateReviewService(deps) {
     }
     async function requestReviewGateInternal(repoRoot, taskSlug, gate, options = {}) {
         const context = await getContext(repoRoot, taskSlug);
+        return withGateStateLock(context, () => requestReviewGateLocked(context, gate, options));
+    }
+    async function requestReviewGateLocked(context, gate, options) {
         let index = await loadIndex(deps.fs, context, now());
         const record = index.gates[gate];
         const requestedCodeDiffSource = options.codeDiffSource
@@ -147,7 +151,7 @@ export function createGateReviewService(deps) {
                 message: `Gate review is already running for ${index.activeGate}.`
             };
         }
-        if (record.status === "running" && !options.force) {
+        if (record.status === "running") {
             return { status: "running", gate, record, message: "Gate review is already running." };
         }
         if (gate === "code-diff" && !codeDiffSource) {
@@ -401,6 +405,7 @@ export function createGateReviewService(deps) {
         const requestPath = path.posix.join(REQUESTS_DIR, `${requestId}.json`);
         const promptPath = path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
         const requestReportPath = reportPathForRequest(requestId);
+        const inputSnapshots = await captureGateInputSnapshots(deps.fs, context.taskRepoRoot, requestId, getSourceArtifacts(gate, codeDiffSources));
         const nextRecord = {
             ...record,
             status: "running",
@@ -444,13 +449,14 @@ export function createGateReviewService(deps) {
             codeDiffSource,
             codeDiffSources,
             codeDiff: codeDiffInput,
+            inputSnapshots,
             reportPath: requestReportPath,
             latestReportPath: nextRecord.reportPath,
             promptPath: nextRecord.promptPath
         });
         await saveIndex(deps.fs, context.taskRepoRoot, index);
         await notifyArchitecturePlanDisposition(context, gate, false);
-        void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources).catch(() => {
+        void runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots).catch(() => {
             // runGateReview records failures in the persisted gate state.
         });
         return {
@@ -460,26 +466,26 @@ export function createGateReviewService(deps) {
             message: "Gate review started."
         };
     }
-    async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources) {
-        const runKey = `${context.taskRepoRoot}:${context.taskSlug}:${gate}`;
+    async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
+        const runKey = gateRunKey(context, gate, requestId);
         if (activeRuns.has(runKey)) {
             return;
         }
-        activeRuns.add(runKey);
+        const controller = new AbortController();
+        activeRuns.set(runKey, controller);
         try {
             const timestamp = now();
-            await updateGateRecord(context, gate, {
-                status: "running",
-                startedAt: timestamp,
-                updatedAt: timestamp
-            });
-            await updateRequestStatus(deps.fs, context, requestId, "running", { startedAt: timestamp });
+            if (!(await markGateRunStarted(context, gate, requestId, timestamp))) {
+                return;
+            }
+            throwIfGateRunCancelled(controller.signal);
             const reviewDir = resolveRepoPath(context.taskRepoRoot, GATE_REVIEW_DIR);
             const agentPath = resolveRepoPath(context.repoRoot, REVIEWER_AGENT_PATH);
-            const prompt = buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources);
+            const prompt = buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots);
             await deps.fs.ensureDir(reviewDir);
             await deps.fs.ensureDir(resolveRepoPath(context.taskRepoRoot, REQUESTS_DIR));
             await deps.fs.writeText(resolveRepoPath(context.taskRepoRoot, promptPathForRequest(requestId)), prompt);
+            throwIfGateRunCancelled(controller.signal);
             if (!(await deps.fs.pathExists(agentPath))) {
                 throw new VcmError({
                     code: "GATE_REVIEW_AGENT_MISSING",
@@ -489,6 +495,7 @@ export function createGateReviewService(deps) {
                 });
             }
             const session = await ensureReviewerSession(context);
+            throwIfGateRunCancelled(controller.signal);
             await submitTerminalInput(deps.runtime, session.id, prompt);
             await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, REVIEWER_ROLE, session.id);
             await deps.roundService.recordRoleTurnEvent({
@@ -499,9 +506,63 @@ export function createGateReviewService(deps) {
                 role: REVIEWER_ROLE,
                 eventName: "UserPromptSubmit"
             });
-            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs);
-            await publishLatestGateReport(deps.fs, context.taskRepoRoot, gate, parsed.content);
+            const parsed = await waitForGateReport(deps.fs, context.taskRepoRoot, gate, requestId, now(), reportPollIntervalMs, controller.signal);
+            const completedRecord = await completeGateRun(context, gate, requestId, parsed);
+            if (!completedRecord) {
+                return;
+            }
+            await notifyArchitecturePlanDisposition(context, gate, parsed.decision === "approve");
+            await callbackProjectManager(context, gate, "completed", parsed.decision, parsed.reportPath, undefined, requestId, completedRecord.inputHash);
+        }
+        catch (error) {
+            if (isGateRunCancelled(error)) {
+                return;
+            }
+            const message = errorMessage(error);
+            const failedRecord = await failGateRun(context, gate, requestId, message);
+            if (!failedRecord) {
+                return;
+            }
+            await notifyArchitecturePlanDisposition(context, gate, false);
+            await callbackProjectManager(context, gate, "failed", undefined, reportPathForRequest(requestId), message, requestId, failedRecord.inputHash);
+        }
+        finally {
+            if (activeRuns.get(runKey) === controller) {
+                activeRuns.delete(runKey);
+            }
+        }
+    }
+    async function markGateRunStarted(context, gate, requestId, timestamp) {
+        return withGateStateLock(context, async () => {
+            const index = await loadIndex(deps.fs, context, timestamp);
+            if (!isCurrentRunningRequest(index, gate, requestId)) {
+                return false;
+            }
+            await updateRequestStatus(deps.fs, context, requestId, "running", { startedAt: timestamp });
+            const next = applyGateState(index, gate, {
+                status: "running",
+                startedAt: timestamp,
+                updatedAt: timestamp
+            }, timestamp);
+            await saveIndex(deps.fs, context.taskRepoRoot, next);
+            return true;
+        });
+    }
+    async function completeGateRun(context, gate, requestId, parsed) {
+        return withGateStateLock(context, async () => {
             const completedAt = now();
+            const index = await loadIndex(deps.fs, context, completedAt);
+            if (!isCurrentRunningRequest(index, gate, requestId)) {
+                await updateRequestStatus(deps.fs, context, requestId, "stale_completion", {
+                    completedAt,
+                    decision: parsed.decision,
+                    summary: parsed.summary,
+                    findings: parsed.findings,
+                    reportPath: parsed.reportPath
+                });
+                return undefined;
+            }
+            await publishLatestGateReport(deps.fs, context.taskRepoRoot, gate, parsed.content);
             await updateRequestStatus(deps.fs, context, requestId, "completed", {
                 completedAt,
                 decision: parsed.decision,
@@ -510,8 +571,7 @@ export function createGateReviewService(deps) {
                 reportPath: parsed.reportPath,
                 latestReportPath: reportPathForGate(gate)
             });
-            activeRuns.delete(runKey);
-            await updateGateRecord(context, gate, {
+            const next = applyGateState(index, gate, {
                 status: "completed",
                 decision: parsed.decision,
                 summary: parsed.summary,
@@ -521,32 +581,37 @@ export function createGateReviewService(deps) {
                 callbackStatus: "not_sent",
                 callbackError: undefined,
                 updatedAt: completedAt
-            }, { clearActiveGate: true });
-            await notifyArchitecturePlanDisposition(context, gate, parsed.decision === "approve");
-            await callbackProjectManager(context, gate, "completed", parsed.decision, parsed.reportPath);
-        }
-        catch (error) {
-            const timestamp = now();
-            const message = errorMessage(error);
+            }, completedAt, true);
+            await saveIndex(deps.fs, context.taskRepoRoot, next);
+            return next.gates[gate];
+        });
+    }
+    async function failGateRun(context, gate, requestId, message) {
+        return withGateStateLock(context, async () => {
+            const completedAt = now();
+            const index = await loadIndex(deps.fs, context, completedAt);
+            if (!isCurrentRunningRequest(index, gate, requestId)) {
+                await updateRequestStatus(deps.fs, context, requestId, "stale_completion", {
+                    completedAt,
+                    error: message
+                });
+                return undefined;
+            }
             await updateRequestStatus(deps.fs, context, requestId, "failed", {
-                completedAt: timestamp,
+                completedAt,
                 error: message
             });
-            activeRuns.delete(runKey);
-            await updateGateRecord(context, gate, {
+            const next = applyGateState(index, gate, {
                 status: "failed",
                 error: message,
-                completedAt: timestamp,
+                completedAt,
                 callbackStatus: "not_sent",
                 callbackError: undefined,
-                updatedAt: timestamp
-            }, { clearActiveGate: true });
-            await notifyArchitecturePlanDisposition(context, gate, false);
-            await callbackProjectManager(context, gate, "failed", undefined, reportPathForRequest(requestId), message);
-        }
-        finally {
-            activeRuns.delete(runKey);
-        }
+                updatedAt: completedAt
+            }, completedAt, true);
+            await saveIndex(deps.fs, context.taskRepoRoot, next);
+            return next.gates[gate];
+        });
     }
     async function ensureReviewerSession(context) {
         const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE);
@@ -571,16 +636,13 @@ export function createGateReviewService(deps) {
             model: "default"
         });
     }
-    async function updateGateRecord(context, gate, patch, options = {}) {
-        const index = await loadIndex(deps.fs, context, now());
-        const next = applyGateState(index, gate, patch, now(), options.clearActiveGate);
-        await saveIndex(deps.fs, context.taskRepoRoot, next);
-        return next;
-    }
-    async function callbackProjectManager(context, gate, status, decision, reportPath, error) {
+    async function callbackProjectManager(context, gate, status, decision, reportPath, error, requestId, inputHash) {
+        if (!(await gateStateMatches(context, gate, status, requestId))) {
+            return;
+        }
         const session = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, "project-manager");
         if (!session || session.status !== "running") {
-            await updateGateRecord(context, gate, {
+            await updateGateCallbackState(context, gate, status, requestId, {
                 callbackStatus: "skipped",
                 callbackError: "project-manager session is not running",
                 updatedAt: now()
@@ -593,7 +655,9 @@ export function createGateReviewService(deps) {
             status,
             decision,
             reportPath,
-            error
+            error,
+            requestId,
+            inputHash
         });
         try {
             await submitTerminalInput(deps.runtime, session.id, prompt);
@@ -606,20 +670,40 @@ export function createGateReviewService(deps) {
                 role: "project-manager",
                 eventName: "UserPromptSubmit"
             });
-            await updateGateRecord(context, gate, {
+            await updateGateCallbackState(context, gate, status, requestId, {
                 callbackStatus: "sent",
                 callbackError: undefined,
                 updatedAt: now()
             });
         }
         catch (caught) {
-            await updateGateRecord(context, gate, {
+            await updateGateCallbackState(context, gate, status, requestId, {
                 callbackStatus: "failed",
                 callbackError: errorMessage(caught),
                 updatedAt: now()
             });
         }
     }
+    async function gateStateMatches(context, gate, expectedStatus, requestId) {
+        return withGateStateLock(context, async () => {
+            const index = await loadIndex(deps.fs, context, now());
+            const record = index.gates[gate];
+            return record.status === expectedStatus
+                && (requestId === undefined || record.requestId === requestId);
+        });
+    }
+    async function updateGateCallbackState(context, gate, expectedStatus, requestId, patch) {
+        await withGateStateLock(context, async () => {
+            const timestamp = now();
+            const index = await loadIndex(deps.fs, context, timestamp);
+            const record = index.gates[gate];
+            if (record.status !== expectedStatus || (requestId !== undefined && record.requestId !== requestId)) {
+                return;
+            }
+            const next = applyGateState(index, gate, patch, timestamp);
+            await saveIndex(deps.fs, context.taskRepoRoot, next);
+        });
+    }
     async function notifyArchitecturePlanDisposition(context, gate, accepted) {
         if (gate !== "architecture-plan" || !deps.onArchitecturePlanDisposition) {
             return;
@@ -641,27 +725,44 @@ export function createGateReviewService(deps) {
             return loadIndex(deps.fs, context, now());
         },
         async updateSettings(repoRoot, taskSlug, input) {
-            const currentSettings = await deps.appSettings.getGateReviewSettings(repoRoot, taskSlug);
-            const requiredGates = new Set(currentSettings.requiredGates);
-            for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
-                if (!isGateReviewGate(gate)) {
-                    continue;
-                }
-                if (enabled) {
-                    requiredGates.add(gate);
-                }
-                else {
-                    requiredGates.delete(gate);
+            const context = await getContext(repoRoot, taskSlug);
+            return withGateStateLock(context, async () => {
+                const timestamp = now();
+                const currentIndex = await loadIndex(deps.fs, context, timestamp);
+                const currentSettings = await deps.appSettings.getGateReviewSettings(repoRoot, taskSlug);
+                const requiredGates = new Set(currentSettings.requiredGates);
+                for (const [gate, enabled] of Object.entries(input?.gates ?? {})) {
+                    if (!isGateReviewGate(gate)) {
+                        continue;
+                    }
+                    if (!enabled && currentIndex.gates[gate].status === "running") {
+                        throw new VcmError({
+                            code: "GATE_REVIEW_RUNNING",
+                            message: `Cannot disable ${gate} while its Gate Review request is running.`,
+                            statusCode: 409,
+                            hint: "Cancel the running request first, then disable this Gate."
+                        });
+                    }
+                    if (enabled) {
+                        requiredGates.add(gate);
+                    }
+                    else {
+                        requiredGates.delete(gate);
+                    }
                 }
-            }
-            await deps.appSettings.updateGateReviewSettings(repoRoot, taskSlug, [...requiredGates]);
-            const nextContext = await getContext(repoRoot, taskSlug);
-            const index = await loadIndex(deps.fs, nextContext, now());
-            await saveIndex(deps.fs, nextContext.taskRepoRoot, {
-                ...index,
-                updatedAt: now()
+                const settings = await deps.appSettings.updateGateReviewSettings(repoRoot, taskSlug, [...requiredGates]);
+                const nextContext = {
+                    ...context,
+                    config: loadRuntimeConfig(settings)
+                };
+                const index = await loadIndex(deps.fs, nextContext, timestamp);
+                const next = {
+                    ...index,
+                    updatedAt: timestamp
+                };
+                await saveIndex(deps.fs, nextContext.taskRepoRoot, next);
+                return next;
             });
-            return loadIndex(deps.fs, nextContext, now());
         },
         requestReviewGate(repoRoot, taskSlug, gate, input) {
             return requestReviewGateInternal(repoRoot, taskSlug, gate, {
@@ -671,28 +772,89 @@ export function createGateReviewService(deps) {
         retryReviewGate(repoRoot, taskSlug, gate) {
             return requestReviewGateInternal(repoRoot, taskSlug, gate, { force: true });
         },
+        async cancelReviewGate(repoRoot, taskSlug, gate, input) {
+            const context = await getContext(repoRoot, taskSlug);
+            assertCancelRequest(input);
+            return withGateStateLock(context, async () => {
+                const timestamp = now();
+                const index = await loadIndex(deps.fs, context, timestamp);
+                const record = index.gates[gate];
+                if (record.status !== "running") {
+                    throw new VcmError({
+                        code: "GATE_REVIEW_NOT_RUNNING",
+                        message: `Gate review ${gate} is not running.`,
+                        statusCode: 409
+                    });
+                }
+                if (record.requestId !== input.requestId) {
+                    throw new VcmError({
+                        code: "GATE_REVIEW_REQUEST_MISMATCH",
+                        message: `Gate review ${gate} is running request ${record.requestId ?? "unknown"}, not ${input.requestId}.`,
+                        statusCode: 409,
+                        hint: "Refresh Gate Review state before cancelling the current request."
+                    });
+                }
+                activeRuns.get(gateRunKey(context, gate, input.requestId))?.abort();
+                await deps.sessionService.restartRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE);
+                await updateRequestStatus(deps.fs, context, input.requestId, "cancelled", {
+                    completedAt: timestamp,
+                    cancelReason: input.reason.trim()
+                });
+                const next = applyGateState(index, gate, {
+                    status: "pending",
+                    decision: undefined,
+                    summary: undefined,
+                    findings: undefined,
+                    error: undefined,
+                    exceptionReason: undefined,
+                    requestId: undefined,
+                    requestPath: undefined,
+                    inputHash: undefined,
+                    baseCommit: undefined,
+                    headCommit: undefined,
+                    commits: undefined,
+                    changedFiles: undefined,
+                    diffStat: undefined,
+                    codeDiffSource: undefined,
+                    codeDiffSources: undefined,
+                    requestedAt: undefined,
+                    startedAt: undefined,
+                    completedAt: undefined,
+                    callbackStatus: "not_sent",
+                    callbackError: undefined,
+                    updatedAt: timestamp
+                }, timestamp, true);
+                await saveIndex(deps.fs, context.taskRepoRoot, next);
+                return next;
+            });
+        },
         async skipReviewGate(repoRoot, taskSlug, gate, input) {
             const context = await getContext(repoRoot, taskSlug);
             assertExceptionReason(input.reason);
-            const current = await loadIndex(deps.fs, context, now());
-            if (current.gates[gate].status === "running") {
-                throw new VcmError({
-                    code: "GATE_REVIEW_RUNNING",
-                    message: "Cannot skip a running Gate review gate.",
-                    statusCode: 409,
-                    hint: "Wait for the gate review to finish, then choose retry, skip, or override."
-                });
-            }
-            const index = await updateGateRecord(context, gate, {
-                status: "skipped",
-                decision: undefined,
-                exceptionReason: input.reason,
-                error: undefined,
-                completedAt: now(),
-                callbackStatus: "not_sent",
-                callbackError: undefined,
-                updatedAt: now()
-            }, { clearActiveGate: true });
+            const index = await withGateStateLock(context, async () => {
+                const timestamp = now();
+                const current = await loadIndex(deps.fs, context, timestamp);
+                if (current.gates[gate].status === "running") {
+                    throw new VcmError({
+                        code: "GATE_REVIEW_RUNNING",
+                        message: "Cannot skip a running Gate review gate.",
+                        statusCode: 409,
+                        hint: "Cancel the running request first, then choose retry, skip, or override."
+                    });
+                }
+                const next = applyGateState(current, gate, {
+                    status: "skipped",
+                    decision: undefined,
+                    exceptionReason: input.reason,
+                    error: undefined,
+                    completedAt: timestamp,
+                    callbackStatus: "not_sent",
+                    callbackError: undefined,
+                    updatedAt: timestamp
+                }, timestamp, true);
+                await saveIndex(deps.fs, context.taskRepoRoot, next);
+                return next;
+            });
             await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "skipped", undefined, index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
@@ -700,25 +862,30 @@ export function createGateReviewService(deps) {
         async overrideReviewGate(repoRoot, taskSlug, gate, input) {
             const context = await getContext(repoRoot, taskSlug);
             assertExceptionReason(input.reason);
-            const current = await loadIndex(deps.fs, context, now());
-            if (current.gates[gate].status === "running") {
-                throw new VcmError({
-                    code: "GATE_REVIEW_RUNNING",
-                    message: "Cannot override a running Gate review gate.",
-                    statusCode: 409,
-                    hint: "Wait for the gate review to finish, then choose retry, skip, or override."
-                });
-            }
-            const index = await updateGateRecord(context, gate, {
-                status: "overridden",
-                decision: "approve",
-                exceptionReason: input.reason,
-                error: undefined,
-                completedAt: now(),
-                callbackStatus: "not_sent",
-                callbackError: undefined,
-                updatedAt: now()
-            }, { clearActiveGate: true });
+            const index = await withGateStateLock(context, async () => {
+                const timestamp = now();
+                const current = await loadIndex(deps.fs, context, timestamp);
+                if (current.gates[gate].status === "running") {
+                    throw new VcmError({
+                        code: "GATE_REVIEW_RUNNING",
+                        message: "Cannot override a running Gate review gate.",
+                        statusCode: 409,
+                        hint: "Cancel the running request first, then choose retry, skip, or override."
+                    });
+                }
+                const next = applyGateState(current, gate, {
+                    status: "overridden",
+                    decision: "approve",
+                    exceptionReason: input.reason,
+                    error: undefined,
+                    completedAt: timestamp,
+                    callbackStatus: "not_sent",
+                    callbackError: undefined,
+                    updatedAt: timestamp
+                }, timestamp, true);
+                await saveIndex(deps.fs, context.taskRepoRoot, next);
+                return next;
+            });
             await notifyArchitecturePlanDisposition(context, gate, true);
             await callbackProjectManager(context, gate, "overridden", "approve", index.gates[gate].reportPath);
             return loadIndex(deps.fs, context, now());
@@ -818,6 +985,27 @@ function applyGateState(index, gate, patch, timestamp, clearActiveGate = false)
         updatedAt: timestamp
     };
 }
+function isCurrentRunningRequest(index, gate, requestId) {
+    const record = index.gates[gate];
+    return record.status === "running" && record.requestId === requestId;
+}
+function gateRunKey(context, gate, requestId) {
+    return `${context.taskRepoRoot}:${context.taskSlug}:${gate}:${requestId}`;
+}
+async function withGateStateLock(context, run) {
+    const key = getIndexPath(context.taskRepoRoot);
+    const previous = gateStateLocks.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(run);
+    gateStateLocks.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (gateStateLocks.get(key) === next) {
+            gateStateLocks.delete(key);
+        }
+    }
+}
 async function saveIndex(fs, taskRepoRoot, index) {
     await fs.writeJsonAtomic(getIndexPath(taskRepoRoot), index);
 }
@@ -1130,12 +1318,22 @@ function splitLines(value) {
         .map((line) => line.trim())
         .filter(Boolean);
 }
-function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources) {
+function buildGatePrompt(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
     const reportPath = reportPathForRequest(requestId);
     const absoluteReportPath = resolveRepoPath(context.taskRepoRoot, reportPath);
     const evidence = getSourceArtifacts(gate, codeDiffSources)
         .map((relativePath) => `- ${relativePath}`)
         .join("\n");
+    const capturedEvidence = inputSnapshots.length > 0
+        ? `
+
+Captured Task Evidence:
+${inputSnapshots.map((snapshot) => snapshot.status === "captured"
+            ? `- ${snapshot.sourcePath} -> ${snapshot.snapshotPath}`
+            : `- ${snapshot.sourcePath} -> <missing at request time>`).join("\n")}
+
+Use each captured snapshot as the immutable handoff or prior-Gate input for this request. Do not substitute a later rewritten live artifact.`
+        : "";
     const gitLine = gate === "architecture-plan"
         ? "\nDiff: inspect git status/diff in Worktree."
         : "";
@@ -1174,7 +1372,7 @@ Request: ${requestId}
 Report: ${absoluteReportPath}
 
 Evidence:
-${evidence}${gitLine}${architectureContract}${validationContract}${codeDiffContract}${codeDiffSection}
+${evidence}${capturedEvidence}${gitLine}${architectureContract}${validationContract}${codeDiffContract}${codeDiffSection}
 
 Write only Report. Start exactly:
 Gate: ${gate}
@@ -1183,9 +1381,28 @@ Decision: approve|request_changes
 Summary: <one or two sentences>
 [/VCM GATE REVIEW]`;
 }
-async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
+async function captureGateInputSnapshots(fs, taskRepoRoot, requestId, sourcePaths) {
+    const snapshots = [];
+    for (const sourcePath of new Set(sourcePaths.filter(isTaskEvidencePath))) {
+        const absoluteSourcePath = resolveRepoPath(taskRepoRoot, sourcePath);
+        if (!(await fs.pathExists(absoluteSourcePath))) {
+            snapshots.push({ sourcePath, status: "missing" });
+            continue;
+        }
+        const snapshotPath = inputSnapshotPathForRequest(requestId, sourcePath);
+        await fs.writeText(resolveRepoPath(taskRepoRoot, snapshotPath), await fs.readText(absoluteSourcePath));
+        snapshots.push({ sourcePath, snapshotPath, status: "captured" });
+    }
+    return snapshots;
+}
+function isTaskEvidencePath(sourcePath) {
+    return sourcePath.startsWith(".ai/vcm/handoffs/")
+        || sourcePath.startsWith(".ai/vcm/gate-reviews/");
+}
+async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs, signal) {
     const reportPath = reportPathForRequest(requestId);
     while (true) {
+        throwIfGateRunCancelled(signal);
         try {
             return await parseGateReport(fs, taskRepoRoot, gate, requestId, timestamp, reportPath);
         }
@@ -1427,6 +1644,10 @@ function reportPathForRequest(requestId) {
 function promptPathForRequest(requestId) {
     return path.posix.join(REQUESTS_DIR, `${requestId}.prompt.md`);
 }
+function inputSnapshotPathForRequest(requestId, sourcePath) {
+    const taskEvidencePath = sourcePath.replace(/^\.ai\/vcm\//, "");
+    return path.posix.join(REQUESTS_DIR, `${requestId}.inputs`, taskEvidencePath);
+}
 function promptPathForGate(gate) {
     return path.posix.join(GATE_REVIEW_DIR, "prompts", `${gate}-gate.md`);
 }
@@ -1576,6 +1797,30 @@ function assertExceptionReason(reason) {
         });
     }
 }
+function assertCancelRequest(input) {
+    if (!input?.requestId?.trim()) {
+        throw new VcmError({
+            code: "GATE_REVIEW_REQUEST_ID_REQUIRED",
+            message: "The current Gate Review request ID is required.",
+            statusCode: 400
+        });
+    }
+    assertExceptionReason(input.reason);
+}
+class GateReviewRunCancelledError extends Error {
+    constructor() {
+        super("Gate Review run was cancelled.");
+        this.name = "GateReviewRunCancelledError";
+    }
+}
+function throwIfGateRunCancelled(signal) {
+    if (signal.aborted) {
+        throw new GateReviewRunCancelledError();
+    }
+}
+function isGateRunCancelled(error) {
+    return error instanceof GateReviewRunCancelledError;
+}
 function renderProjectManagerCallback(input) {
     const lines = [
         "[VCM GATE REVIEW CALLBACK]",
@@ -1583,6 +1828,8 @@ function renderProjectManagerCallback(input) {
         `gate: ${input.gate}`,
         `status: ${input.status}`,
         `decision: ${input.decision ?? "none"}`,
+        `request_id: ${input.requestId ?? "none"}`,
+        `input_hash: ${input.inputHash ?? "none"}`,
         `report: ${input.reportPath}`,
         ...(input.error ? [`error: ${input.error}`] : []),
         "",