vibe-coding-master 0.3.25 → 0.3.27

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

@@ -1,7 +1,10 @@
 import { isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
+import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const MAX_STOP_FAILURE_RECOVERY_ATTEMPTS = 2;
 export function createClaudeHookService(deps) {
+    const stopFailureRecoveryAttempts = new Map();
     async function getHookContext(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -92,6 +95,7 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -113,23 +117,72 @@ export function createClaudeHookService(deps) {
                 };
             }
         }
-        const scopedRouteDispatchInput = {
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            handoffDir: context.task.handoffDir,
+        return recordTurnEnd(input, context, eventName, {
+            dispatchRouteFiles: true,
+            notifyGateway: true,
+            settleGuard: true
+        });
+    }
+    async function processStopFailureHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "StopFailure") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const routeDispatchInput = createRouteDispatchInput(input, context);
+        const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
+        const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
+        if (hasCompletionEvidence) {
+            clearStopFailureRecovery(context.project.repoRoot, input.taskSlug, input.role);
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: true,
+                notifyGateway: false,
+                settleGuard: true
+            });
+        }
+        const recovered = await dispatchStopFailureRecovery(input, context);
+        if (recovered) {
+            return {
+                ok: true,
+                eventName,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionUpdated: true,
+                dispatchedCount: 0
+            };
+        }
+        return recordTurnEnd(input, context, eventName, {
+            dispatchRouteFiles: false,
+            notifyGateway: false,
+            settleGuard: false
+        });
+    }
+    async function processPostCompactHook(input) {
+        const eventName = parseHookEvent(input.event.hook_event_name);
+        if (eventName !== "PostCompact") {
+            throwUnsupportedEvent(eventName);
+        }
+        const context = await getHookContext(input);
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
-            stoppedRole: input.role
-        };
-        const settleRouteDispatchInput = {
-            repoRoot: context.project.repoRoot,
-            taskRepoRoot: context.taskRepoRoot,
-            stateRepoRoot: context.taskRepoRoot,
-            stateRoot: context.config.stateRoot,
-            handoffDir: context.task.handoffDir,
-            taskSlug: input.taskSlug
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: input.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
         };
+    }
+    async function recordTurnEnd(input, context, eventName, options) {
+        const scopedRouteDispatchInput = createRouteDispatchInput(input, context, input.role);
+        const settleRouteDispatchInput = createRouteDispatchInput(input, context);
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
             role: input.role,
@@ -145,16 +198,20 @@ export function createClaudeHookService(deps) {
             taskSlug: input.taskSlug,
             role: input.role,
             eventName,
-            settleGuard: async () => {
-                const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
-                if (pending.length === 0) {
-                    return { action: "stop" };
+            ...(options.settleGuard
+                ? {
+                    settleGuard: async () => {
+                        const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
+                        if (pending.length === 0) {
+                            return { action: "stop" };
+                        }
+                        const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
+                        return retried.some((result) => result.delivered)
+                            ? { action: "continue", reason: "pending route message dispatched" }
+                            : { action: "stop" };
+                    }
                 }
-                const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
-                return retried.some((result) => result.delivered)
-                    ? { action: "continue", reason: "pending route message dispatched" }
-                    : { action: "stop" };
-            }
+                : {})
         });
         if (session) {
             await deps.translationService.recordConversationBoundary({
@@ -167,14 +224,16 @@ export function createClaudeHookService(deps) {
                 occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
-        if (session && input.role === "project-manager") {
+        if (options.notifyGateway && session && input.role === "project-manager") {
             void deps.gatewayService?.handlePmStop({
                 repoRoot: context.project.repoRoot,
                 taskSlug: input.taskSlug,
                 session
             }).catch(() => undefined);
         }
-        const dispatched = await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput);
+        const dispatched = options.dispatchRouteFiles
+            ? await deps.messageService.scanAndDispatchPendingRouteFiles(scopedRouteDispatchInput)
+            : [];
         return {
             ok: true,
             eventName,
@@ -184,6 +243,51 @@ export function createClaudeHookService(deps) {
             dispatchedCount: dispatched.filter((result) => result.delivered).length
         };
     }
+    function createRouteDispatchInput(input, context, stoppedRole) {
+        return {
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: input.taskSlug,
+            ...(stoppedRole ? { stoppedRole } : {})
+        };
+    }
+    async function dispatchStopFailureRecovery(input, context) {
+        if (!deps.runtime) {
+            return false;
+        }
+        const key = stopFailureRecoveryKey(context.project.repoRoot, input.taskSlug, input.role);
+        const attempt = (stopFailureRecoveryAttempts.get(key) ?? 0) + 1;
+        if (attempt > MAX_STOP_FAILURE_RECOVERY_ATTEMPTS) {
+            return false;
+        }
+        const session = await deps.sessionService.getRoleSession(context.project.repoRoot, input.taskSlug, input.role);
+        if (!session || session.status !== "running") {
+            return false;
+        }
+        stopFailureRecoveryAttempts.set(key, attempt);
+        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt(attempt));
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, input.taskSlug, input.role);
+        return true;
+    }
+    function clearStopFailureRecovery(repoRoot, taskSlug, role) {
+        stopFailureRecoveryAttempts.delete(stopFailureRecoveryKey(repoRoot, taskSlug, role));
+    }
+    function stopFailureRecoveryKey(repoRoot, taskSlug, role) {
+        return `${repoRoot}:${taskSlug}:${role}`;
+    }
+    function renderStopFailureRecoveryPrompt(attempt) {
+        return [
+            "[VCM Recovery]",
+            "Your previous turn ended unexpectedly after context compaction or an API error.",
+            "Continue the same assigned work from the current repository and VCM handoff state.",
+            "Do not repeat completed edits, duplicate validation, or duplicate route messages.",
+            "If the assigned work is already complete, write/send the expected VCM handoff now.",
+            `Recovery attempt: ${attempt}/${MAX_STOP_FAILURE_RECOVERY_ATTEMPTS}.`
+        ].join("\n");
+    }
     async function handlePermissionRequestHook(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -220,6 +324,12 @@ export function createClaudeHookService(deps) {
             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 });
@@ -231,14 +341,14 @@ export function createClaudeHookService(deps) {
     };
 }
 function parseHookEvent(value) {
-    if (value === "UserPromptSubmit" || value === "Stop") {
+    if (value === "UserPromptSubmit" || value === "Stop" || value === "StopFailure" || value === "PostCompact") {
         return value;
     }
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",
         message: `Unsupported Claude Code hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts UserPromptSubmit and Stop hooks only."
+        hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
     });
 }
 function throwUnsupportedEvent(eventName) {

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

@@ -1,6 +1,5 @@
 import { isCodexRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
-import { getTaskRuntimeRepoRoot } from "./task-service.js";
 export function createCodexHookService(deps) {
     async function getHookContext(input) {
         if (!isCodexRoleName(input.role)) {
@@ -18,20 +17,8 @@ export function createCodexHookService(deps) {
                 statusCode: 409
             });
         }
-        if (input.role === "codex-translator") {
-            return {
-                project,
-                config: undefined,
-                taskRepoRoot: undefined
-            };
-        }
-        const config = await deps.projectService.loadConfig(project.repoRoot);
-        const task = await deps.taskService.loadTask(project.repoRoot, input.taskSlug);
-        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
         return {
-            project,
-            config,
-            taskRepoRoot
+            project
         };
     }
     async function processHook(input, expectedEventName) {
@@ -44,42 +31,13 @@ export function createCodexHookService(deps) {
             });
         }
         const context = await getHookContext(input);
-        const session = input.role === "codex-translator"
-            ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
-                eventName,
-                sessionId: stringOrUndefined(input.event.session_id),
-                transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd)
-            })
-            : await deps.sessionService.recordRoleHookEvent(context.project.repoRoot, {
-                taskSlug: input.taskSlug,
-                role: input.role,
-                eventName,
-                sessionId: stringOrUndefined(input.event.session_id),
-                transcriptPath: stringOrUndefined(input.event.transcript_path),
-                cwd: stringOrUndefined(input.event.cwd),
-                allowSessionMismatch: true
-            });
-        if (input.role === "codex-reviewer") {
-            if (!context.config || !context.taskRepoRoot) {
-                throw new VcmError({
-                    code: "CODEX_HOOK_TASK_CONTEXT_MISSING",
-                    message: "Codex Reviewer hook is missing task context.",
-                    statusCode: 500
-                });
-            }
-            await deps.roundService.recordRoleTurnEvent({
-                repoRoot: context.project.repoRoot,
-                stateRepoRoot: context.taskRepoRoot,
-                stateRoot: context.config.stateRoot,
-                taskSlug: input.taskSlug,
-                role: input.role,
-                eventName
-            });
-        }
-        if (input.role === "codex-translator") {
-            await deps.codexTranslationService?.handleCodexHook(context.project.repoRoot, eventName, input.taskSlug);
-        }
+        const session = await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
+            eventName,
+            sessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd)
+        });
+        await deps.codexTranslationService?.handleCodexHook(context.project.repoRoot, eventName, input.taskSlug);
         return {
             ok: true,
             eventName,