vibe-coding-master 0.9.8 → 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

@@ -220,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 ?? "");

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/gate-review-service.js

@@ -38,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",
@@ -1279,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);