vibe-coding-master 0.7.33 → 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.
@@ -467,8 +477,9 @@ files.
 Review Task Harness after Final Acceptance, Project Manager, Architect, Coder,
 Tester, and an enabled Reviewer submit proposals in sequence through
 `vcm-propose-memory`. Harness Engineer verifies and consolidates them before VCM
-applies the result as part of the same Task Harness Retrospective. Roles cannot
-edit active memory directly.
+records the result as part of the same Task Harness Retrospective. Workflow roles
+cannot edit active memory directly; Harness Engineer edits it only during the
+assigned Auto Memory Retrospective.
 
 When Auto Memory is enabled, the planning Architect writes a provisional memory
 candidate before its post-planning Session restart. VCM snapshots that candidate
@@ -477,11 +488,12 @@ the completed implementation and tests, and Harness Engineer reviews it with all
 final role proposals before anything becomes active memory.
 
 Shared memory is stored in the root `CLAUDE.md` `<VCM-memory>` block. Role memory
-is stored in the matching `.claude/agents/*.md` block. VCM changes only block
-contents and creates a dedicated commit in the active task worktree. Harness
-Studio shows current memory and task-local applied history. Memory is applied
-before user review; while the task worktree remains available, the user can edit
-current memory or revert a recorded change through another commit.
+is stored in the matching `.claude/agents/*.md` block. Harness Engineer changes
+only those blocks and creates a dedicated commit in the active task worktree.
+VCM verifies the mechanical commit boundary and records the after snapshot and
+diff. Harness Studio shows current memory and task-local applied history. Memory
+is applied before user review; while the task worktree remains available, the
+user can edit current memory or revert a recorded change through another commit.
 
 Post-task processing is ordered by the backend:
 
@@ -493,7 +505,8 @@ Final Acceptance
   -> Task Harness Retrospective
        -> Review pending Harness Feedback
        -> Review Auto Memory proposals, when Auto Memory is enabled
-  -> Apply reviewed memory, when Auto Memory is enabled
+       -> Harness Engineer updates and commits memory, when Auto Memory is enabled
+  -> VCM records the committed memory result
 ```
 
 Memory proposal prompts sent to Project Manager, Architect, Coder, Tester, and
@@ -507,10 +520,10 @@ impact, and durable-document disposition, then evaluates every proposal item
 independently. Each Add or Update decision records why the memory is necessary,
 what happens if it is absent, whether it belongs in memory or a durable
 document, and the exact final memory content when retained. VCM validates that
-every candidate has one matching decision and that the reviewed memory files
-implement those decisions before applying them. Harness Engineer review and
-retrospective work remain tool role activity and do not participate in Round
-completion.
+the commit changes only assigned memory host files and only their
+`<VCM-memory>` blocks; it does not parse or apply Harness Engineer's semantic
+decisions. Harness Engineer review and retrospective work remain tool role
+activity and do not participate in Round completion.
 
 When Auto Memory is disabled, Review Task Harness does not collect proposals or
 ask Harness Engineer to update memory. When enabled, both automatic and manual

package/dist/backend/adapters/git-adapter.js

@@ -157,6 +157,27 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
+        async getChangedPaths(repoRoot, baseRef, headRef = null) {
+            const result = await runGit(runner, repoRoot, [
+                "diff",
+                "--name-only",
+                "-z",
+                baseRef,
+                ...(headRef ? [headRef] : [])
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read changed Git paths.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout
+                .split("\0")
+                .map((changedPath) => changedPath.trim())
+                .filter(Boolean);
+        },
         async getCommitList(repoRoot, range) {
             const result = await runGit(runner, repoRoot, ["log", "--format=%H%x00%s%x00%cI%x1e", range]);
             if (result.exitCode !== 0) {

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/auto-memory-service.js

@@ -7,7 +7,6 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
 import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
 import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
-import { parseMemoryReviewReport, validateMemoryReviewOutput } from "./memory-review-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
     { path: ".claude/agents/project-manager.md", title: "Project Manager Memory", role: "project-manager" },
@@ -97,6 +96,26 @@ export function createAutoMemoryService(deps) {
         }
         return memory;
     }
+    async function writeRunMemoryHostSnapshot(taskRepoRoot, runId) {
+        for (const definition of MEMORY_FILE_DEFINITIONS) {
+            await deps.fs.writeText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)), await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path)));
+        }
+    }
+    async function assertOnlyMemoryBlocksChanged(taskRepoRoot, runId, currentMemory) {
+        for (const definition of MEMORY_FILE_DEFINITIONS) {
+            const beforeHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, memoryRunHostFilePath(runId, definition.path)));
+            const currentHost = await deps.fs.readText(resolveRepoPath(taskRepoRoot, definition.path));
+            const expectedHost = replaceVcmMemoryBlock(beforeHost, currentMemory[definition.path]);
+            if (currentHost !== expectedHost) {
+                throw new VcmError({
+                    code: "MEMORY_REVIEW_SCOPE_CHANGED",
+                    message: `Harness Engineer changed content outside the VCM memory block: ${definition.path}`,
+                    statusCode: 409,
+                    hint: "Restore non-memory content, keep only the reviewed <VCM-memory> edit, and commit the correction."
+                });
+            }
+        }
+    }
     async function getState(baseRepoRoot, taskRepoRoot) {
         let [active, runs, memoryFiles] = await Promise.all([
             loadActiveState(taskRepoRoot),
@@ -172,7 +191,6 @@ export function createAutoMemoryService(deps) {
         };
         const before = await readMemorySet(input.taskRepoRoot);
         await writeRunMemorySet(input.taskRepoRoot, runId, "before", before);
-        await writeRunMemorySet(input.taskRepoRoot, runId, "after", before);
         await snapshotArchitectPlanningCandidate(input.taskRepoRoot, runId);
         await persistRun(input.taskRepoRoot, {
             version: 1,
@@ -252,9 +270,31 @@ export function createAutoMemoryService(deps) {
             });
         }
         const proposalCandidates = await readReviewCandidates(taskRepoRoot, state);
+        const currentMemory = await readMemorySet(taskRepoRoot);
+        const beforeMemory = await readRunMemorySet(taskRepoRoot, state.runId, "before");
+        if (!sameHashes(hashMemorySet(currentMemory), hashMemorySet(beforeMemory))) {
+            throw new VcmError({
+                code: "MEMORY_TARGET_CHANGED",
+                message: "VCM memory changed while role proposals were being collected.",
+                statusCode: 409,
+                hint: "Review the current memory, then retry Auto Memory."
+            });
+        }
+        const memoryPaths = MEMORY_FILE_DEFINITIONS.map((definition) => definition.path);
+        const existingDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, memoryPaths);
+        if (existingDiff.trim()) {
+            throw new VcmError({
+                code: "MEMORY_HOST_FILE_DIRTY",
+                message: "A file containing VCM memory has uncommitted changes before Harness Engineer review.",
+                statusCode: 409,
+                hint: "Commit or discard the existing host-file changes before starting Task Harness Retrospective."
+            });
+        }
+        await writeRunMemoryHostSnapshot(taskRepoRoot, state.runId);
         const timestamp = now();
         state.reviewPromptDispatchedAt = timestamp;
         state.retrospectiveReportPath = retrospectiveReportPath;
+        state.reviewBaseCommit = await deps.git.getHeadCommit(taskRepoRoot);
         state.updatedAt = timestamp;
         await persistActiveState(taskRepoRoot, state);
         const runRoot = resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}`);
@@ -263,7 +303,7 @@ export function createAutoMemoryService(deps) {
             runId: state.runId,
             roleDraftsPath: path.join(runRoot, "drafts"),
             currentMemoryPath: path.join(runRoot, "before"),
-            reviewedMemoryPath: path.join(runRoot, "after"),
+            activeMemoryPaths: memoryPaths.map((memoryPath) => resolveRepoPath(taskRepoRoot, memoryPath)),
             proposalCandidates,
             ...(planningCandidatePath
                 ? { planningCandidatePath: resolveRepoPath(taskRepoRoot, planningCandidatePath) }
@@ -277,6 +317,7 @@ export function createAutoMemoryService(deps) {
         }
         delete state.reviewPromptDispatchedAt;
         delete state.retrospectiveReportPath;
+        delete state.reviewBaseCommit;
         state.updatedAt = now();
         await persistActiveState(taskRepoRoot, state);
     }
@@ -362,26 +403,12 @@ export function createAutoMemoryService(deps) {
                 return true;
             }
             try {
-                const report = await deps.fs.readText(state.retrospectiveReportPath);
-                const currentMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "before");
-                const reviewedMemorySnapshot = await readRunMemorySet(input.taskRepoRoot, state.runId, "after");
-                const candidates = await readReviewCandidates(input.taskRepoRoot, state);
-                const reportResult = parseMemoryReviewReport(report, candidates, hasSubstantiveMemory(currentMemorySnapshot));
-                if (reportResult.error) {
-                    await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review report ${reportResult.error}.`);
-                    return true;
-                }
-                const outputError = await validateReviewedMemoryOutput(input.taskRepoRoot, currentMemorySnapshot, reviewedMemorySnapshot, reportResult.decisions ?? []);
-                if (outputError) {
-                    await failReview(input.taskRepoRoot, state, `Task Harness Retrospective reviewed memory ${outputError}.`);
-                    return true;
-                }
+                await recordHarnessEngineerMemoryResult(input.taskRepoRoot, state);
             }
             catch (error) {
-                await failReview(input.taskRepoRoot, state, `Task Harness Retrospective memory review validation failed: ${errorMessage(error)}`);
+                await failReview(input.taskRepoRoot, state, `Harness Engineer memory result could not be recorded: ${errorMessage(error)}`);
                 return true;
             }
-            await applyReviewedMemory(input.taskRepoRoot, state);
             return true;
         }
         return true;
@@ -559,44 +586,75 @@ export function createAutoMemoryService(deps) {
         }
         return candidates;
     }
-    async function validateReviewedMemoryOutput(taskRepoRoot, before, after, decisions) {
-        return validateMemoryReviewOutput({
-            before: memorySetByTarget(before),
-            after: memorySetByTarget(after),
-            decisions,
-            durableDocExists: async (durableDocPath) => {
-                try {
-                    return await deps.fs.pathExists(resolveRepoPath(taskRepoRoot, durableDocPath));
-                }
-                catch {
-                    return false;
-                }
-            }
-        });
-    }
-    async function applyReviewedMemory(taskRepoRoot, state) {
-        try {
-            const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
-            const after = await readRunMemorySet(taskRepoRoot, state.runId, "after");
-            assertCompleteMemorySet(after);
-            await applyAndCommitMemorySet(taskRepoRoot, before, after, "chore: update VCM memory");
-            const timestamp = now();
-            const diff = renderMemoryDiff(before, after);
-            const run = await readRun(taskRepoRoot, state.runId);
-            await persistRun(taskRepoRoot, {
-                ...run,
-                status: "applied",
-                updatedAt: timestamp,
-                appliedAt: timestamp,
-                afterHashes: hashMemorySet(after),
-                diff
+    async function recordHarnessEngineerMemoryResult(taskRepoRoot, state) {
+        if (!state.reviewBaseCommit) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_BASE_MISSING",
+                message: "Harness Engineer memory review has no recorded base commit.",
+                statusCode: 409,
+                hint: "Retry Auto Memory before running Task Harness Retrospective again."
             });
-            await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}/applied.patch`), diff);
-            await clearActiveState(taskRepoRoot);
         }
-        catch (error) {
-            await failReview(taskRepoRoot, state, `Harness Engineer memory result could not be applied: ${errorMessage(error)}`);
+        const before = await readRunMemorySet(taskRepoRoot, state.runId, "before");
+        const after = await readMemorySet(taskRepoRoot);
+        await assertOnlyMemoryBlocksChanged(taskRepoRoot, state.runId, after);
+        const memoryPaths = MEMORY_FILE_DEFINITIONS.map((definition) => definition.path);
+        const uncommittedMemoryDiff = await deps.git.getDiff(taskRepoRoot, "HEAD", null, memoryPaths);
+        if (uncommittedMemoryDiff.trim()) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_NOT_COMMITTED",
+                message: "Harness Engineer left reviewed memory changes uncommitted.",
+                statusCode: 409,
+                hint: "Commit the reviewed <VCM-memory> changes before ending the retrospective turn."
+            });
+        }
+        const changedMemoryPaths = MEMORY_FILE_DEFINITIONS
+            .filter((definition) => before[definition.path] !== after[definition.path])
+            .map((definition) => definition.path);
+        const currentHead = await deps.git.getHeadCommit(taskRepoRoot);
+        const committedPaths = currentHead === state.reviewBaseCommit
+            ? []
+            : await deps.git.getChangedPaths(taskRepoRoot, state.reviewBaseCommit, currentHead);
+        const unexpectedPaths = committedPaths.filter((changedPath) => !memoryPaths.includes(changedPath));
+        if (unexpectedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_COMMIT_SCOPE_INVALID",
+                message: `Harness Engineer memory commit contains files outside managed memory hosts: ${unexpectedPaths.join(", ")}`,
+                statusCode: 409,
+                hint: "Move unrelated changes to a separate workflow and keep the memory review commit limited to managed memory files."
+            });
+        }
+        const missingCommittedPaths = changedMemoryPaths.filter((changedPath) => !committedPaths.includes(changedPath));
+        if (missingCommittedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_COMMIT_MISSING",
+                message: `Harness Engineer did not commit reviewed memory files: ${missingCommittedPaths.join(", ")}`,
+                statusCode: 409,
+                hint: "Commit every changed memory host file before ending the retrospective turn."
+            });
+        }
+        if (changedMemoryPaths.length === 0 && committedPaths.length > 0) {
+            throw new VcmError({
+                code: "MEMORY_REVIEW_EMPTY_COMMIT_RANGE",
+                message: "Harness Engineer created memory-host commits but left no final memory change.",
+                statusCode: 409,
+                hint: "Remove the unnecessary memory commits or leave memory unchanged without committing."
+            });
         }
+        await writeRunMemorySet(taskRepoRoot, state.runId, "after", after);
+        const timestamp = now();
+        const diff = renderMemoryDiff(before, after);
+        const run = await readRun(taskRepoRoot, state.runId);
+        await persistRun(taskRepoRoot, {
+            ...run,
+            status: "applied",
+            updatedAt: timestamp,
+            appliedAt: timestamp,
+            afterHashes: hashMemorySet(after),
+            diff
+        });
+        await deps.fs.writeText(resolveRepoPath(taskRepoRoot, `${MEMORY_REVIEW_RUNS_ROOT}/${state.runId}/applied.patch`), diff);
+        await clearActiveState(taskRepoRoot);
     }
     async function createAppliedRun(taskRepoRoot, taskSlug, source, before, after) {
         assertCompleteMemorySet(after);
@@ -815,27 +873,6 @@ function toReviewCandidates(source, currentRole, items) {
         ...(item.existing ? { existing: item.existing } : {})
     }));
 }
-function memoryPathForTarget(target) {
-    if (target === "shared") {
-        return "CLAUDE.md";
-    }
-    const definition = MEMORY_FILE_DEFINITIONS.find((candidate) => "role" in candidate && candidate.role === target);
-    if (!definition) {
-        throw new Error(`Missing memory file definition for review target: ${target}`);
-    }
-    return definition.path;
-}
-function memorySetByTarget(memory) {
-    return {
-        shared: memory["CLAUDE.md"],
-        "project-manager": memory[memoryPathForTarget("project-manager")],
-        architect: memory[memoryPathForTarget("architect")],
-        coder: memory[memoryPathForTarget("coder")],
-        tester: memory[memoryPathForTarget("tester")],
-        reviewer: memory[memoryPathForTarget("reviewer")],
-        "harness-engineer": memory[memoryPathForTarget("harness-engineer")]
-    };
-}
 function toActiveReview(state) {
     return {
         runId: state.runId,
@@ -902,6 +939,9 @@ function requireSafeRunId(runId) {
 function memoryRunFilePath(runId, snapshot, memoryPath) {
     return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/${snapshot}/${memoryPath}`;
 }
+function memoryRunHostFilePath(runId, memoryPath) {
+    return `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/host-before/${memoryPath}`;
+}
 function missingMemoryBlockError(filePath) {
     return new VcmError({
         code: "MEMORY_BLOCK_MISSING",
@@ -923,12 +963,6 @@ function hashMemorySet(memory) {
         sha256(memory[definition.path] ?? "")
     ]));
 }
-function hasSubstantiveMemory(memory) {
-    return Object.values(memory).some((content) => {
-        const normalized = content.trim();
-        return Boolean(normalized && normalized !== "No accumulated project memory yet.");
-    });
-}
 function sameHashes(left, right) {
     return MEMORY_FILE_DEFINITIONS.every((definition) => left[definition.path] === right[definition.path]);
 }

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) {