vibe-coding-master 0.7.34 → 0.7.35

package/README.md

@@ -277,6 +277,11 @@ gateway from the native child process. Configure CCR without enabling its
 global Claude Code or Claude App takeover if those clients should remain on
 Anthropic.
 
+CCR/GPT child processes use an effective context limit of `258400` tokens.
+VCM leaves Claude Code's automatic compaction threshold unset so Claude Code
+can compact against that limit. Native Claude sessions receive no VCM-owned
+context override.
+
 Resume keeps the provider recorded by the existing Session. Use Restart when
 switching between a native Claude model and `GPT-5.6 Sol (CCR)`. If CCR is
 disabled, unreachable, rejects the key, or does not expose
@@ -344,6 +349,11 @@ only:
 Reviewer does not run tests and does not choose owners or fixes. PM routes
 findings back to the responsible role.
 
+Each run has its own request ID and immutable request artifacts. A running
+review must be cancelled before replacement; cancellation restarts Reviewer,
+and a late result from the cancelled request cannot replace the current Gate
+state, stable report, or PM callback.
+
 ## Translation
 
 Conversation translation is controlled from the sidebar `Translation` section.

package/dist/backend/api/gate-review-routes.js

@@ -19,6 +19,11 @@ export function registerGateReviewRoutes(app, deps) {
         const gate = parseGate(request.params.gate);
         return deps.gateReviewService.retryReviewGate(project.repoRoot, request.params.taskSlug, gate);
     });
+    app.post("/api/tasks/:taskSlug/gate-review/:gate/cancel", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const gate = parseGate(request.params.gate);
+        return deps.gateReviewService.cancelReviewGate(project.repoRoot, request.params.taskSlug, gate, request.body);
+    });
     app.post("/api/tasks/:taskSlug/gate-review/:gate/skip", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const gate = parseGate(request.params.gate);

package/dist/backend/services/ccr-integration-service.js

@@ -1,4 +1,4 @@
-import { CCR_GATEWAY_BASE_URL, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
+import { CCR_GATEWAY_BASE_URL, CCR_GPT_EFFECTIVE_CONTEXT_TOKENS, CCR_GPT_MODEL_ID, createSessionModelOptions, isCcrSessionModel } from "../../shared/types/session.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { VcmError } from "../errors.js";
@@ -162,6 +162,7 @@ export function createCcrIntegrationService(deps) {
                 CODEXL_CLAUDE_CODE_MODEL: CCR_GPT_MODEL_ID,
                 ANTHROPIC_SMALL_FAST_MODEL: CCR_GPT_MODEL_ID,
                 CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+                CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(CCR_GPT_EFFECTIVE_CONTEXT_TOKENS),
                 CLAUDE_CONFIG_DIR: configDir,
                 NO_PROXY: noProxy,
                 no_proxy: noProxy

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

@@ -16,6 +16,12 @@ const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
     "terminal_session_exited",
     "terminal_session_missing"
 ]);
+const NON_RETRYABLE_CONTEXT_FAILURE_PATTERNS = [
+    "context_length_exceeded",
+    "request_too_large",
+    "prompt too long",
+    "maximum context length"
+];
 const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
     const stopFailureRetryTimers = new Map();
@@ -876,11 +882,16 @@ function parseStopFailureDiagnostic(event) {
     const error = (normalizeDiagnosticString(event.error, 200) ?? "unknown").toLowerCase();
     const errorDetails = normalizeDiagnosticString(event.error_details, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
     const lastAssistantMessage = normalizeDiagnosticString(event.last_assistant_message, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
+    const diagnosticText = [error, errorDetails, lastAssistantMessage]
+        .filter((value) => Boolean(value))
+        .join("\n")
+        .toLowerCase();
     return {
         error,
         errorDetails,
         lastAssistantMessage,
         retryable: !NON_RETRYABLE_STOP_FAILURE_ERRORS.has(error)
+            && !NON_RETRYABLE_CONTEXT_FAILURE_PATTERNS.some((pattern) => diagnosticText.includes(pattern))
     };
 }
 function normalizeDiagnosticString(value, maxLength) {

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) {
@@ -463,25 +467,25 @@ export function createGateReviewService(deps) {
         };
     }
     async function runGateReview(context, gate, requestId, codeDiffInput, codeDiffSources, inputSnapshots = []) {
-        const runKey = `${context.taskRepoRoot}:${context.taskSlug}:${gate}`;
+        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, 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",
@@ -491,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({
@@ -501,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,
@@ -512,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,
@@ -523,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);
@@ -573,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()
@@ -595,7 +655,9 @@ export function createGateReviewService(deps) {
             status,
             decision,
             reportPath,
-            error
+            error,
+            requestId,
+            inputHash
         });
         try {
             await submitTerminalInput(deps.runtime, session.id, prompt);
@@ -608,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;
@@ -643,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, {
@@ -673,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());
@@ -702,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());
@@ -820,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);
 }
@@ -1213,9 +1399,10 @@ function isTaskEvidencePath(sourcePath) {
     return sourcePath.startsWith(".ai/vcm/handoffs/")
         || sourcePath.startsWith(".ai/vcm/gate-reviews/");
 }
-async function waitForGateReport(fs, taskRepoRoot, gate, requestId, timestamp, intervalMs) {
+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);
         }
@@ -1610,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]",
@@ -1617,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}`] : []),
         "",