vibe-coding-master 0.9.7 → 0.9.9

package/dist/backend/server.js

@@ -275,7 +275,8 @@ export function createDefaultServerDeps(options = {}) {
     const workflowControlService = createWorkflowControlService({ fs });
     const artifactService = createArtifactService(fs, {
         workflowControlService,
-        getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role)
+        getDurableDocAssignment: (taskRepoRoot, role) => autoMemoryService.getDurableDocAssignment(taskRepoRoot, role),
+        getCompletedDurableDocAssignment: (taskRepoRoot, role, artifactPath) => autoMemoryService.getCompletedDurableDocAssignment(taskRepoRoot, role, artifactPath)
     });
     const projectService = createProjectService({
         fs,

package/dist/backend/services/artifact-service.js

@@ -22,6 +22,9 @@ const ARTIFACT_PATH_KEYS = [
     ["workflow-progress", "workflowProgressPath"],
     ["final-acceptance", "finalAcceptancePath"]
 ];
+// Gate requests whose report VCM still waits for; any other status means the
+// run already ended and a report would be ignored.
+const OPEN_GATE_REQUEST_STATUSES = new Set(["requested", "running"]);
 const ROLE_COMMAND_PLACEHOLDER_PATTERN = /(^|\n)\s*(TBD|status:\s*draft)\s*(\n|$)/i;
 const DEFAULT_MESSAGE_ROUTES = [
     ["project-manager", "architect"],
@@ -217,6 +220,16 @@ export function createArtifactService(fs, deps = {}) {
                     }
                 }
                 else if (input.artifactPath?.trim()) {
+                    const completed = input.kind === "docs-update-report"
+                        ? await deps.getCompletedDurableDocAssignment?.(input.repoRoot, input.role, input.artifactPath.trim())
+                        : undefined;
+                    if (completed) {
+                        throw new VcmError({
+                            code: "DURABLE_DOC_ASSIGNMENT_COMPLETED",
+                            message: `Durable-documentation assignment ${completed.id} is already completed${completed.commit ? ` (commit ${completed.commit})` : ""}, and VCM accepted its report. No action is needed; end the turn.`,
+                            statusCode: 409
+                        });
+                    }
                     throw artifactRejected(input.kind, ["--path is not allowed for fixed artifact kinds."]);
                 }
                 const artifactPath = assignment?.reportPath ?? path.posix.join(input.handoffDir, definition.fileName ?? "");
@@ -331,6 +344,11 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
                 `Report path must match the assigned request path ${request.reportPath ?? "<missing>"}.`
             ]);
         }
+        if (request.status && !OPEN_GATE_REQUEST_STATUSES.has(request.status)) {
+            throw artifactRejected(input.kind, [
+                `Gate request ${request.requestId ?? requestId} is already ${request.status}, so VCM will not use this report. Stop this review; VCM sends a new request if the gate runs again.`
+            ]);
+        }
         assertManagedArtifactContent(input.kind, content, artifactPath, input.mode, {
             expectedGate: request.gate,
             expectedRequestId: request.requestId ?? requestId

package/dist/backend/services/auto-memory-service.js

@@ -18,6 +18,7 @@ const MEMORY_FILE_DEFINITIONS = [
     { path: ".claude/agents/reviewer.md", title: "Reviewer Memory", role: "reviewer" },
     { path: ".claude/agents/harness-engineer.md", title: "Harness Engineer Memory", role: "harness-engineer" }
 ];
+const DURABLE_DOC_TURN_END_GRACE_MS = 30 * 1000;
 export function createAutoMemoryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const taskLocks = new Map();
@@ -382,6 +383,24 @@ export function createAutoMemoryService(deps) {
         const assignment = state?.status === "documenting" ? currentDurableDocAssignment(state) : undefined;
         return assignment?.status === "running" && assignment.owner === role ? assignment : undefined;
     }
+    async function getCompletedDurableDocAssignment(taskRepoRoot, role, artifactPath) {
+        const runId = artifactPath.startsWith(`${MEMORY_REVIEW_RUNS_ROOT}/`)
+            ? artifactPath.slice(MEMORY_REVIEW_RUNS_ROOT.length + 1).split("/")[0]
+            : undefined;
+        if (!runId) {
+            return undefined;
+        }
+        let run;
+        try {
+            run = await readRun(taskRepoRoot, runId);
+        }
+        catch {
+            return undefined;
+        }
+        return run.assignments?.find((assignment) => assignment.status === "completed"
+            && assignment.owner === role
+            && assignment.reportPath === artifactPath);
+    }
     async function handleRoleHook(input) {
         const state = await loadActiveState(input.taskRepoRoot);
         if (!(await deps.appSettings.getPreferences()).autoMemoryEnabled && !preserveDisabledReview(state)) {
@@ -764,7 +783,12 @@ export function createAutoMemoryService(deps) {
                 return;
             }
             const existing = await deps.sessionService.getRoleSession(baseRepoRoot, state.taskSlug, role);
-            if (existing?.activityStatus === "running" && deps.runtime.getSession(existing.id)) {
+            // The assignment's turn reports its own end through the Stop hook, so a
+            // live session keeps the assignment. Sending it again here would queue a
+            // duplicate prompt behind that turn.
+            if (existing?.status === "running"
+                && deps.runtime.getSession(existing.id)
+                && !turnInterruptedAfterDispatch(existing, assignment)) {
                 return;
             }
             assignment.status = assignment.owner ? "pending" : "waiting-owner";
@@ -803,6 +827,21 @@ export function createAutoMemoryService(deps) {
         await submitTerminalInput(deps.runtime, session.id, assignment.owner
             ? buildDurableDocAssignmentPrompt(taskRepoRoot, assignment)
             : buildDurableDocOwnerPrompt(taskRepoRoot, assignment));
+        // Until the role's UserPromptSubmit hook arrives the session still looks
+        // idle; mark it running so nothing dispatches into it meanwhile.
+        await deps.sessionService.markRoleActivityRunning(baseRepoRoot, state.taskSlug, assignment.owner ?? "project-manager", session.id);
+    }
+    // An interrupted turn sends no Stop hook, so its assignment would otherwise
+    // stay running. A turn that ends normally records its end on the session
+    // just before its Stop hook completes or fails the assignment, so the grace
+    // period keeps a reconcile from racing that hook.
+    function turnInterruptedAfterDispatch(session, assignment) {
+        if (session.activityStatus === "running" || !session.lastTurnEndedAt || !assignment.dispatchedAt) {
+            return false;
+        }
+        const endedAt = Date.parse(session.lastTurnEndedAt);
+        return endedAt > Date.parse(assignment.dispatchedAt)
+            && Date.parse(now()) - endedAt >= DURABLE_DOC_TURN_END_GRACE_MS;
     }
     async function finishDurableDocAssignments(taskRepoRoot, state) {
         const failed = state.assignments.filter((assignment) => assignment.status === "failed");
@@ -1471,6 +1510,7 @@ export function createAutoMemoryService(deps) {
         cancelTaskRetrospectiveReview,
         isRoleMemoryTurn,
         getDurableDocAssignment,
+        getCompletedDurableDocAssignment,
         handleRoleHook: (input) => withTaskLock(input.taskRepoRoot, () => handleRoleHook(input)),
         handleHarnessEngineerHook: (input) => withTaskLock(input.taskRepoRoot, () => handleHarnessEngineerHook(input)),
         assertHarnessEngineerAvailable

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

@@ -1029,7 +1029,11 @@ function normalizeDiagnosticString(value, maxLength) {
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;
 }
+// VCM submits its prompts as a terminal paste, and newer Claude Code versions
+// report a pasted prompt wrapped in <pasted_content id="..."> tags, so the
+// wrapper is removed before looking for VCM's marker.
+const PASTED_CONTENT_OPEN_TAG = /^<pasted_content\b[^>]*>/i;
 function isDirectUserPrompt(prompt) {
-    const normalized = prompt.trim();
+    const normalized = prompt.trim().replace(PASTED_CONTENT_OPEN_TAG, "").trim();
     return normalized.length > 0 && !/^\[VCM(?:\s|\])/i.test(normalized);
 }

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

@@ -15,6 +15,9 @@ const GATE_REVIEW_VERSION = 1;
 const HARNESS_COMMIT_PREFIX = "[VCM Harness] ";
 const REVIEWER_ROLE = "reviewer";
 const DEFAULT_REPORT_POLL_INTERVAL_MS = 1000;
+// A Reviewer that just submitted a report usually ends its turn within
+// seconds; a missed Stop hook leaves the activity stale, so the wait is capped.
+const DEFAULT_REVIEWER_IDLE_WAIT_MS = 5 * 60 * 1000;
 const activeRuns = new Map();
 const gateStateLocks = new Map();
 const SOURCE_ARTIFACTS = {
@@ -35,6 +38,14 @@ const SOURCE_ARTIFACTS = {
         ".ai/vcm/gate-reviews/validation-adequacy-review.md"
     ]
 };
+// Reviewer reads the Debug and Diagnosis handoffs, but they stay out of the
+// validation-adequacy input hash: a Post-Validation Docs Correction rewrites
+// them, and like docs it changes no code or test evidence. Code and test
+// changes still change the tracked-evidence hash.
+const VALIDATION_HASH_EXCLUDED_ARTIFACTS = new Set([
+    ".ai/vcm/handoffs/architect-debug.md",
+    ".ai/vcm/handoffs/architecture-diagnosis.md"
+]);
 const CODE_DIFF_SOURCE_ARTIFACTS = {
     coder: [
         ".ai/vcm/handoffs/architecture-plan.md",
@@ -54,6 +65,7 @@ const VALID_CODE_DIFF_FINDING_SCOPES = new Set(CODE_DIFF_FINDING_SCOPES);
 export function createGateReviewService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const reportPollIntervalMs = deps.reportPollIntervalMs ?? DEFAULT_REPORT_POLL_INTERVAL_MS;
+    const reviewerIdleWaitMs = deps.reviewerIdleWaitMs ?? DEFAULT_REVIEWER_IDLE_WAIT_MS;
     async function getContext(repoRoot, taskSlug) {
         const projectConfig = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
@@ -529,6 +541,7 @@ export function createGateReviewService(deps) {
                 });
             }
             const session = await ensureReviewerSession(context);
+            await waitForReviewerIdle(context, controller.signal);
             throwIfGateRunCancelled(controller.signal);
             await submitTerminalInput(deps.runtime, session.id, prompt);
             await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, REVIEWER_ROLE, session.id);
@@ -647,6 +660,20 @@ export function createGateReviewService(deps) {
             return next.gates[gate];
         });
     }
+    // Claude Code queues a prompt typed into a running turn but sends its
+    // UserPromptSubmit hook at once, so the running turn's Stop would look like
+    // the end of this request's turn and fail it. Wait for that turn to end.
+    async function waitForReviewerIdle(context, signal) {
+        const deadline = Date.now() + reviewerIdleWaitMs;
+        while (true) {
+            throwIfGateRunCancelled(signal);
+            const session = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE);
+            if (session?.activityStatus !== "running" || Date.now() >= deadline) {
+                return;
+            }
+            await delay(reportPollIntervalMs);
+        }
+    }
     async function ensureReviewerSession(context) {
         const existing = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, REVIEWER_ROLE);
         if (existing?.status === "running" && deps.runtime.getSession(existing.id)) {
@@ -1260,7 +1287,7 @@ async function computeInputHash(deps, taskRepoRoot, gate, codeDiffInput, codeDif
         ".ai/tools/request-gate-review",
         "docs/CODING_STANDARDS.md"
     ];
-    const sourceArtifacts = getSourceArtifacts(gate, codeDiffSources);
+    const sourceArtifacts = getSourceArtifacts(gate, codeDiffSources).filter((item) => gate !== "validation-adequacy" || !VALIDATION_HASH_EXCLUDED_ARTIFACTS.has(item));
     for (const relativePath of new Set([...common, ...sourceArtifacts].filter((item) => item !== coreArtifact))) {
         digest.update(relativePath);
         const absolutePath = resolveRepoPath(taskRepoRoot, relativePath);

package/dist/backend/services/workflow-control-service.js

@@ -833,9 +833,12 @@ async function allowedArchitectFix(fs, input, state, segment, source, resumedFro
             return [`${source}/architect`];
         }
         // A new fix needs validation; any other post-validation Architect change
-        // is reviewed by an incremental code-diff Gate.
-        if (artifactFresh && artifact.complete)
+        // is reviewed by an incremental code-diff Gate. Architect also rewrites its
+        // artifact for a docs correction, so once a code-diff Gate has reviewed
+        // this dispatch, that Gate's result routes the flow instead.
+        if (artifactFresh && artifact.complete && !(await codeDiffReviewedDispatch(fs, input, state, source))) {
             return [`${source}/tester`];
+        }
         return allowedPostImplementationArchitect(fs, input, state, source, acceptanceFlow);
     }
     return allowedAfterTester(fs, input, state, source, source, {
@@ -843,6 +846,18 @@ async function allowedArchitectFix(fs, input, state, segment, source, resumedFro
         acceptanceFlow
     });
 }
+// True when a code-diff Gate finished, or was skipped or overridden, after the
+// active Architect dispatch was confirmed.
+async function codeDiffReviewedDispatch(fs, input, state, flow) {
+    if (!matchingEvidenceBaseline(state, flow, "architect"))
+        return false;
+    const codeDiff = await gateState(fs, input, "code-diff");
+    // A disabled Gate reviews nothing, so it never stands in for Tester.
+    if (!codeDiff || codeDiff.status === "disabled")
+        return false;
+    return (codeDiff.status === "completed" && freshGateDecision(state, flow, "architect", "code-diff", codeDiff) !== undefined)
+        || gatePassedForDispatch(state, flow, "architect", "code-diff", codeDiff);
+}
 async function allowedPostImplementationArchitect(fs, input, state, flow, acceptanceFlow) {
     if (flow === "code-change") {
         const planningTransition = await allowedFreshArchitecturePlan(fs, input, state, matchingEvidenceBaseline(state, "code-change", "architect")?.confirmedAt);