vibe-coding-master 0.7.16 → 0.7.18

package/dist/backend/services/architect-restart-service.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const ARCHITECT_ROLE = "architect";
+const PM_ROLE = "project-manager";
+const COMPLETE_PLAN_PATTERN = /^Planning Result:\s*complete\s*$/im;
+export const ARCHITECT_RESTORE_PROMPT = `This Architect session continues the current task after completed architecture planning.
+
+Before performing any assigned work, read:
+- .ai/vcm/handoffs/architecture-brief.md
+- .ai/vcm/handoffs/architecture-evidence.md
+- .ai/vcm/handoffs/architecture-plan.md
+- the current scaffold commit and worktree state
+- the latest Gate Review report when present
+
+Treat the current artifacts and worktree as the source of truth. Do not repeat the completed interview or planning work unless current evidence contradicts them.`;
+export function createArchitectRestartService(deps) {
+    const pendingByTask = new Map();
+    return {
+        async schedule(repoRoot, taskSlug) {
+            const session = await requireRunningArchitect(repoRoot, taskSlug);
+            await requireCompletePlan(repoRoot, taskSlug);
+            const key = taskKey(repoRoot, taskSlug);
+            const existing = pendingByTask.get(key);
+            if (existing?.sessionId === session.id) {
+                return { taskSlug, sessionId: session.id, status: "scheduled" };
+            }
+            pendingByTask.set(key, {
+                repoRoot,
+                taskSlug,
+                sessionId: session.id,
+                stopped: false,
+                executing: false
+            });
+            return { taskSlug, sessionId: session.id, status: "scheduled" };
+        },
+        async recordArchitectStop(repoRoot, taskSlug, sessionId) {
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending || pending.sessionId !== sessionId) {
+                return;
+            }
+            pending.stopped = true;
+            await tryRestart(pending);
+        },
+        async recordRouteDelivered(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.deliveredMessageId = message.id;
+            await tryRestart(pending);
+        },
+        async recordRouteAccepted(repoRoot, taskSlug, message) {
+            if (!isArchitectToPm(message)) {
+                return;
+            }
+            const pending = pendingByTask.get(taskKey(repoRoot, taskSlug));
+            if (!pending) {
+                return;
+            }
+            pending.acceptedMessageId = message.id;
+            await tryRestart(pending);
+        },
+        clear(repoRoot, taskSlug) {
+            pendingByTask.delete(taskKey(repoRoot, taskSlug));
+        }
+    };
+    async function requireRunningArchitect(repoRoot, taskSlug) {
+        const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, ARCHITECT_ROLE);
+        if (!session || session.status !== "running") {
+            throw new VcmError({
+                code: "ARCHITECT_SESSION_NOT_RUNNING",
+                message: "Architect session is not running.",
+                statusCode: 409
+            });
+        }
+        return session;
+    }
+    async function requireCompletePlan(repoRoot, taskSlug) {
+        const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+        const planPath = resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(task.handoffDir, "architecture-plan.md"));
+        if (!(await deps.fs.pathExists(planPath))) {
+            throw incompletePlanError("architecture-plan.md does not exist.");
+        }
+        const content = await deps.fs.readText(planPath);
+        if (!COMPLETE_PLAN_PATTERN.test(content)) {
+            throw incompletePlanError("architecture-plan.md is not marked complete.");
+        }
+    }
+    async function tryRestart(pending) {
+        if (pending.executing
+            || !pending.stopped
+            || !pending.deliveredMessageId
+            || pending.deliveredMessageId !== pending.acceptedMessageId) {
+            return;
+        }
+        const session = await deps.sessionService.getRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE);
+        if (!session
+            || session.id !== pending.sessionId
+            || session.status !== "running"
+            || session.activityStatus !== "idle") {
+            return;
+        }
+        pending.executing = true;
+        try {
+            await requireCompletePlan(pending.repoRoot, pending.taskSlug);
+            await deps.sessionService.restartRoleSession(pending.repoRoot, pending.taskSlug, ARCHITECT_ROLE, {
+                permissionMode: session.permissionMode,
+                model: session.model,
+                effort: session.effort,
+                appendSystemPrompt: ARCHITECT_RESTORE_PROMPT
+            });
+            pendingByTask.delete(taskKey(pending.repoRoot, pending.taskSlug));
+        }
+        catch {
+            pending.executing = false;
+        }
+    }
+}
+function isArchitectToPm(message) {
+    return message.fromRole === ARCHITECT_ROLE && message.toRole === PM_ROLE;
+}
+function taskKey(repoRoot, taskSlug) {
+    return `${repoRoot}\0${taskSlug}`;
+}
+function incompletePlanError(reason) {
+    return new VcmError({
+        code: "ARCHITECT_PLAN_INCOMPLETE",
+        message: `Architect restart cannot be scheduled. ${reason}`,
+        statusCode: 409
+    });
+}

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

@@ -2,6 +2,7 @@ import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorTool
 import { VcmError } from "../errors.js";
 import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { matchesRoleHookSession } from "./session-service.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
 const MAX_ROLE_RETRY_ATTEMPTS = 20;
 const ROLE_RETRY_BASE_DELAY_MS = 60_000;
@@ -18,6 +19,7 @@ const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
 const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
     const stopFailureRetryTimers = new Map();
+    const roleHookLocks = new Map();
     const now = deps.now ?? (() => new Date().toISOString());
     const retrySetTimeout = deps.retrySetTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
     const retryClearTimeout = deps.retryClearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
@@ -79,7 +81,9 @@ export function createClaudeHookService(deps) {
                 eventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             })
             : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
                 taskSlug: input.taskSlug,
@@ -88,9 +92,12 @@ export function createClaudeHookService(deps) {
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
-                allowSessionMismatch: true
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             });
-        await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        if (session) {
+            await deps.translationWorkerService?.handleTranslatorHook(context.project.repoRoot, eventName, input.taskSlug);
+        }
         return {
             ok: true,
             eventName,
@@ -109,7 +116,9 @@ export function createClaudeHookService(deps) {
                 eventName,
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+                cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             })
             : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
                 taskSlug: input.taskSlug,
@@ -118,8 +127,12 @@ export function createClaudeHookService(deps) {
                 sessionId: stringOrUndefined(input.event.session_id),
                 transcriptPath: stringOrUndefined(input.event.transcript_path),
                 cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
-                allowSessionMismatch: true
+                runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+                runtimeSessionToken: input.runtimeSessionToken
             });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
         const activeTask = deps.autoMemoryService
             ? (await deps.taskService.listTasks(context.project.repoRoot))
                 .find((task) => task.cleanupStatus !== "cleaned" && (projectScoped || task.taskSlug === input.taskSlug))
@@ -176,27 +189,33 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
         }
-        const boundToTask = await isHookSessionBoundToTask(context, input.role);
-        if (boundToTask) {
-            deps.jobGuard?.notePromptSubmitted({
-                repoRoot: context.project.repoRoot,
-                taskSlug: context.taskSlug,
-                role: input.role
-            });
-        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
+            deps.jobGuard?.notePromptSubmitted({
+                repoRoot: context.project.repoRoot,
+                taskSlug: context.taskSlug,
+                role: input.role
+            });
             await deps.roundService.recordClaudeHookEvent({
                 repoRoot: context.project.repoRoot,
                 stateRepoRoot: context.taskRepoRoot,
@@ -227,6 +246,9 @@ export function createClaudeHookService(deps) {
             role: input.role,
             prompt: stringOrUndefined(input.event.prompt)
         });
+        if (submitted) {
+            await deps.architectRestartService?.recordRouteAccepted(context.project.repoRoot, context.taskSlug, submitted);
+        }
         return {
             ok: true,
             eventName,
@@ -243,6 +265,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -309,6 +334,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -369,6 +397,9 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
         const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
         if (memoryResult) {
             return memoryResult;
@@ -379,7 +410,9 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
         return {
             ok: true,
@@ -393,15 +426,20 @@ export function createClaudeHookService(deps) {
     async function recordTurnEnd(input, context, eventName, options) {
         const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
         const settleRouteDispatchInput = createRouteDispatchInput(input, context);
-        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
+        const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             await deps.roundService.recordClaudeHookEvent({
                 repoRoot: context.project.repoRoot,
@@ -437,6 +475,9 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
+        if (eventName === "Stop" && input.role === "architect" && session) {
+            await deps.architectRestartService?.recordArchitectStop(context.project.repoRoot, context.taskSlug, session.id);
+        }
         if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,
@@ -477,8 +518,13 @@ export function createClaudeHookService(deps) {
             eventName,
             claudeSessionId: stringOrUndefined(input.event.session_id),
             transcriptPath: stringOrUndefined(input.event.transcript_path),
-            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
         });
+        if (!session) {
+            return completedHookResult(input, eventName);
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask && eventName !== "PostCompact") {
             await deps.roundService.recordClaudeHookEvent({
@@ -517,6 +563,31 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
+    async function isCurrentRoleHook(context, input, eventName) {
+        const current = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        return Boolean(current && matchesRoleHookSession(current, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
+            runtimeSessionToken: input.runtimeSessionToken
+        }));
+    }
+    async function withRoleHookLock(input, run) {
+        const key = `${input.taskSlug}:${input.role}`;
+        const previous = roleHookLocks.get(key) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(run);
+        const tail = result.then(() => undefined, () => undefined);
+        roleHookLocks.set(key, tail);
+        try {
+            return await result;
+        }
+        finally {
+            if (roleHookLocks.get(key) === tail) {
+                roleHookLocks.delete(key);
+            }
+        }
+    }
     async function scheduleStopFailureRetry(input, context, failure) {
         const preferences = await deps.appSettings.getPreferences();
         if (!preferences.roleRetryEnabled || !deps.runtime) {
@@ -556,7 +627,10 @@ export function createClaudeHookService(deps) {
                 nextRetryAt
             }
         });
-        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
+        if (session) {
+            await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role, session.id);
+        }
         scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
         return "scheduled";
     }
@@ -624,7 +698,7 @@ export function createClaudeHookService(deps) {
             }
         });
         await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt());
-        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role, session.id);
     }
     async function markStopFailureRecoveryFailed(input, context, failure, attempt, timestamp = now()) {
         clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
@@ -730,44 +804,50 @@ export function createClaudeHookService(deps) {
     }
     return {
         async handleHook(input) {
-            if (isTranslatorToolRoleName(input.role)) {
-                return processTranslatorHook(input);
-            }
-            if (isHarnessEngineerToolRoleName(input.role)) {
-                return processHarnessEngineerHook(input);
-            }
-            const eventName = parseHookEvent(input.event.hook_event_name);
-            if (eventName === "UserPromptSubmit") {
-                return handleUserPromptSubmitHook(input);
-            }
-            if (eventName === "StopFailure") {
-                return processStopFailureHook(input);
-            }
-            if (eventName === "PostCompact") {
-                return processPostCompactHook(input);
-            }
-            // Legacy combined endpoint: the installed hook discards the response,
-            // so a block decision could not be enforced. Never block here.
-            return processStopHook(input, { allowBlock: false });
+            return withRoleHookLock(input, async () => {
+                if (isTranslatorToolRoleName(input.role)) {
+                    return processTranslatorHook(input);
+                }
+                if (isHarnessEngineerToolRoleName(input.role)) {
+                    return processHarnessEngineerHook(input);
+                }
+                const eventName = parseHookEvent(input.event.hook_event_name);
+                if (eventName === "UserPromptSubmit") {
+                    return handleUserPromptSubmitHook(input);
+                }
+                if (eventName === "StopFailure") {
+                    return processStopFailureHook(input);
+                }
+                if (eventName === "PostCompact") {
+                    return processPostCompactHook(input);
+                }
+                // Legacy combined endpoint: the installed hook discards the response,
+                // so a block decision could not be enforced. Never block here.
+                return processStopHook(input, { allowBlock: false });
+            });
         },
         handleStopHook(input) {
-            if (isTranslatorToolRoleName(input.role)) {
-                return processTranslatorHook(input);
-            }
-            if (isHarnessEngineerToolRoleName(input.role)) {
-                return processHarnessEngineerHook(input);
-            }
-            return processStopHook(input, { allowBlock: true });
+            return withRoleHookLock(input, async () => {
+                if (isTranslatorToolRoleName(input.role)) {
+                    return processTranslatorHook(input);
+                }
+                if (isHarnessEngineerToolRoleName(input.role)) {
+                    return processHarnessEngineerHook(input);
+                }
+                return processStopHook(input, { allowBlock: true });
+            });
         },
         handleReconciledTurnEnd(input) {
-            const eventName = parseHookEvent(input.event.hook_event_name);
-            if (eventName === "Stop") {
-                return processStopHook(input, { allowBlock: false });
-            }
-            if (eventName === "StopFailure") {
-                return processStopFailureHook(input);
-            }
-            throwUnsupportedEvent(eventName);
+            return withRoleHookLock(input, async () => {
+                const eventName = parseHookEvent(input.event.hook_event_name);
+                if (eventName === "Stop") {
+                    return processStopHook(input, { allowBlock: false });
+                }
+                if (eventName === "StopFailure") {
+                    return processStopFailureHook(input);
+                }
+                throwUnsupportedEvent(eventName);
+            });
         },
         handlePermissionRequestHook
     };