vibe-coding-master 0.7.42 → 0.7.44

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

@@ -80,7 +80,7 @@ export function createClaudeHookService(deps) {
         return { project };
     }
     async function processTranslatorHook(input) {
-        const eventName = parseHookEvent(input.event.hook_event_name);
+        const eventName = parseBusinessHookEvent(input.event.hook_event_name);
         const context = await getTranslatorHookContext();
         const session = input.taskSlug === "__project__"
             ? await deps.sessionService.recordProjectTranslatorHookEvent(context.project.repoRoot, {
@@ -114,7 +114,7 @@ export function createClaudeHookService(deps) {
         };
     }
     async function processHarnessEngineerHook(input) {
-        const eventName = parseHookEvent(input.event.hook_event_name);
+        const eventName = parseBusinessHookEvent(input.event.hook_event_name);
         const context = await getProjectToolHookContext("Harness Engineer");
         const projectScoped = input.taskSlug === "__project_harness_engineer__";
         const session = projectScoped
@@ -158,7 +158,7 @@ export function createClaudeHookService(deps) {
             ? await deps.harnessFeedbackService?.handleTaskRetrospectiveHook(context.project.repoRoot, {
                 taskSlug: activeTask.taskSlug,
                 eventName,
-                memoryReviewSucceeded: memoryState?.status !== "failed"
+                memoryReviewStatus: memoryState?.status ?? "idle"
             })
             : false;
         if (memoryHandled || retrospectiveHandled) {
@@ -212,6 +212,16 @@ export function createClaudeHookService(deps) {
         if (memoryResult) {
             return memoryResult;
         }
+        const prompt = stringOrUndefined(input.event.prompt);
+        if (input.role === "project-manager"
+            && prompt
+            && isDirectUserPrompt(prompt)
+            && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                await deps.workflowControlService.resolveUserInput(createWorkflowControlContext(context));
+            }
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -240,6 +250,12 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 eventName
             });
+            await deps.roleStallDetector?.recordHook({
+                ...createStallContext(context),
+                role: input.role,
+                eventName,
+                event: input.event
+            });
         }
         if (session) {
             await deps.translationService.recordConversationBoundary({
@@ -260,7 +276,7 @@ export function createClaudeHookService(deps) {
             handoffDir: context.task.handoffDir,
             taskSlug: context.taskSlug,
             role: input.role,
-            prompt: stringOrUndefined(input.event.prompt)
+            prompt
         });
         if (submitted) {
             await deps.architectRestartService?.recordRouteAccepted(context.project.repoRoot, context.taskSlug, submitted);
@@ -292,6 +308,7 @@ export function createClaudeHookService(deps) {
             return completedHookResult(input, eventName);
         }
         await clearStopFailureRecoveryState(context, input.role);
+        let pmAwaitingUser = false;
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -313,6 +330,42 @@ export function createClaudeHookService(deps) {
                 };
             }
         }
+        if (input.role === "project-manager" && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                pmAwaitingUser = true;
+            }
+            else {
+                const lastAssistantMessage = stringOrUndefined(input.event.last_assistant_message);
+                if (options.allowBlock && lastAssistantMessage && asksUserQuestion(lastAssistantMessage)) {
+                    return {
+                        ok: true,
+                        eventName,
+                        taskSlug: context.taskSlug,
+                        role: input.role,
+                        sessionUpdated: false,
+                        dispatchedCount: 0,
+                        stopDecision: {
+                            behavior: "block",
+                            reason: "You asked the user a question without registering the wait. Use vcm-ask-user with the exact question, then ask that question and stop. Do not advance or route the workflow."
+                        }
+                    };
+                }
+            }
+        }
+        await deps.roleStallDetector?.recordHook({
+            ...createStallContext(context),
+            role: input.role,
+            eventName,
+            event: input.event
+        });
+        if (pmAwaitingUser) {
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: false,
+                notifyGateway: true,
+                settleGuard: false
+            });
+        }
         return recordTurnEnd(input, context, eventName, {
             dispatchRouteFiles: !isReviewerRoleName(input.role),
             notifyGateway: true,
@@ -357,6 +410,12 @@ export function createClaudeHookService(deps) {
         if (memoryResult) {
             return memoryResult;
         }
+        await deps.roleStallDetector?.recordHook({
+            ...createStallContext(context),
+            role: input.role,
+            eventName,
+            event: input.event
+        });
         const routeDispatchInput = createRouteDispatchInput(input, context);
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
@@ -430,6 +489,14 @@ export function createClaudeHookService(deps) {
             runtimeSessionId: stringOrUndefined(input.event.vcm_runtime_session_id),
             runtimeSessionToken: input.runtimeSessionToken
         });
+        if (session) {
+            await deps.roleStallDetector?.recordHook({
+                ...createStallContext(context),
+                role: input.role,
+                eventName,
+                event: input.event
+            });
+        }
         return {
             ok: true,
             eventName,
@@ -528,6 +595,17 @@ export function createClaudeHookService(deps) {
         if (!deps.autoMemoryService || !(await deps.autoMemoryService.isRoleMemoryTurn(context.taskRepoRoot, input.role))) {
             return undefined;
         }
+        const prompt = stringOrUndefined(input.event.prompt);
+        if (eventName === "UserPromptSubmit"
+            && input.role === "project-manager"
+            && prompt
+            && isDirectUserPrompt(prompt)
+            && deps.workflowControlService) {
+            const workflowState = await deps.workflowControlService.getState(createWorkflowControlContext(context));
+            if (workflowState.awaitingUser) {
+                await deps.workflowControlService.resolveUserInput(createWorkflowControlContext(context));
+            }
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -552,6 +630,14 @@ export function createClaudeHookService(deps) {
                 eventName
             });
         }
+        if (boundToTask) {
+            await deps.roleStallDetector?.recordHook({
+                ...createStallContext(context),
+                role: input.role,
+                eventName,
+                event: input.event
+            });
+        }
         await deps.autoMemoryService.handleRoleHook({
             baseRepoRoot: context.project.repoRoot,
             taskRepoRoot: context.taskRepoRoot,
@@ -559,6 +645,10 @@ export function createClaudeHookService(deps) {
             role: input.role,
             eventName
         });
+        if (eventName === "Stop") {
+            const memoryState = await deps.autoMemoryService.getState(context.project.repoRoot, context.taskRepoRoot);
+            await deps.harnessFeedbackService?.completeWaitingTaskRetrospective(context.project.repoRoot, context.taskSlug, memoryState.status);
+        }
         return {
             ok: true,
             eventName,
@@ -579,6 +669,14 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
+    function createWorkflowControlContext(context) {
+        return {
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            handoffDir: context.task.handoffDir,
+            taskSlug: context.taskSlug
+        };
+    }
     async function isCurrentRoleHook(context, input, eventName) {
         const current = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
         return Boolean(current && matchesRoleHookSession(current, {
@@ -764,6 +862,31 @@ export function createClaudeHookService(deps) {
             taskSlug: context.taskSlug
         };
     }
+    function createStallContext(context) {
+        return {
+            repoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            taskSlug: context.taskSlug
+        };
+    }
+    async function processProgressHook(input, eventName) {
+        const role = input.role;
+        if (!isVcmRoleName(role)) {
+            return completedHookResult(input, eventName);
+        }
+        const context = await getHookContext(input);
+        if (!(await isCurrentRoleHook(context, input, eventName))) {
+            return completedHookResult(input, eventName);
+        }
+        await deps.roleStallDetector?.recordHook({
+            ...createStallContext(context),
+            role,
+            eventName,
+            event: input.event
+        });
+        return completedHookResult(input, eventName);
+    }
     function renderStopFailureRecoveryPrompt() {
         return [
             "[VCM Recovery]",
@@ -806,6 +929,17 @@ export function createClaudeHookService(deps) {
             });
         }
         const preferences = await deps.appSettings.getPreferences();
+        if (deps.roleStallDetector) {
+            const context = await getHookContext(input);
+            if (await isCurrentRoleHook(context, input, "PermissionRequest")) {
+                await deps.roleStallDetector.recordHook({
+                    ...createStallContext(context),
+                    role: input.role,
+                    eventName: "PermissionRequest",
+                    event: input.event
+                });
+            }
+        }
         if (preferences.permissionRequestMode !== "allowAll") {
             return undefined;
         }
@@ -821,13 +955,16 @@ export function createClaudeHookService(deps) {
     return {
         async handleHook(input) {
             return withRoleHookLock(input, async () => {
+                const eventName = parseHookEvent(input.event.hook_event_name);
+                if (isProgressHook(eventName)) {
+                    return processProgressHook(input, eventName);
+                }
                 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);
                 }
@@ -860,6 +997,13 @@ function parseHookEvent(value) {
     if (value === "UserPromptSubmit"
         || value === "Stop"
         || value === "StopFailure"
+        || value === "PreToolUse"
+        || value === "PostToolUse"
+        || value === "PostToolUseFailure"
+        || value === "PostToolBatch"
+        || value === "SubagentStart"
+        || value === "SubagentStop"
+        || value === "PreCompact"
         || value === "PostCompact") {
         return value;
     }
@@ -867,9 +1011,28 @@ function parseHookEvent(value) {
         code: "HOOK_EVENT_UNSUPPORTED",
         message: `Unsupported Claude Code hook event: ${String(value)}`,
         statusCode: 400,
-        hint: "VCM accepts UserPromptSubmit, Stop, StopFailure, and PostCompact hooks only."
+        hint: "Use a Claude Code event installed by the VCM Harness."
     });
 }
+function isProgressHook(eventName) {
+    return eventName === "PreToolUse"
+        || eventName === "PostToolUse"
+        || eventName === "PostToolUseFailure"
+        || eventName === "PostToolBatch"
+        || eventName === "SubagentStart"
+        || eventName === "SubagentStop"
+        || eventName === "PreCompact";
+}
+function parseBusinessHookEvent(value) {
+    const eventName = parseHookEvent(value);
+    if (eventName === "UserPromptSubmit"
+        || eventName === "Stop"
+        || eventName === "StopFailure"
+        || eventName === "PostCompact") {
+        return eventName;
+    }
+    throwUnsupportedEvent(eventName);
+}
 function throwUnsupportedEvent(eventName) {
     throw new VcmError({
         code: "HOOK_EVENT_UNSUPPORTED",
@@ -918,3 +1081,17 @@ function normalizeDiagnosticString(value, maxLength) {
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;
 }
+function isDirectUserPrompt(prompt) {
+    const normalized = prompt.trim();
+    return normalized.length > 0 && !/^\[VCM(?:\s|\])/i.test(normalized);
+}
+function asksUserQuestion(message) {
+    const withoutCodeBlocks = message.replace(/```[\s\S]*?```/g, "");
+    const lines = withoutCodeBlocks
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.some((line) => /[?？]["')\]}】”’]*$/.test(line)
+        || /^(?:please\s+(?:answer|choose|confirm|decide|provide|select|tell)|(?:can|could|do|does|is|are|should|will|would)\s+you\b)/i.test(line)
+        || /^(?:请(?:回答|选择|确认|决定|提供|告知)|你(?:是否|能否|要不要|可否)|是否需要你|需要你(?:选择|确认|决定|提供|告知))/.test(line));
+}