vibe-coding-master 0.7.42 → 0.7.43

package/README.md

@@ -474,14 +474,19 @@ Use it to:
 - merge task harness commits back to the connected repository branch when
   appropriate
 
-VCM bundles the Claude Code LSP bridge and loads it for Architect, Coder, and
-Reviewer sessions, including CCR launches. The project environment must still
+VCM bundles the Claude Code LSP bridge and loads it only for Architect sessions,
+including CCR launches. The project environment must still
 provide the language server for each detected language: `rust-analyzer`,
 `typescript-language-server`, `pyright-langserver`, `gopls`, `clangd`, or
-`jdtls`. Their Agent definitions preload `vcm-code-navigation`. Architect,
-Coder, and Reviewer use LSP for semantic relationships. Harness Studio reports
+`jdtls`. Architect preloads `vcm-code-navigation` and uses LSP for semantic
+relationships; other roles use generated context and ordinary source reads.
+Harness Studio reports
 whether the server executable and plugin can run; the role Session performs the
-real workspace warm-up and semantic query retries.
+real workspace indexing and semantic query retries. VCM uses Claude Code progress
+hooks to detect a model response, tool call, subagent, or compaction that may be
+stalled. Detection only opens a warning; it does not interrupt the Session or
+change the Round. The user can ignore that warning or explicitly stop and resume
+the same Claude Session from the warning dialog.
 
 Harness Engineer is task-scoped and runs from the active task worktree. The
 backend automatically starts a fresh Harness Engineer for each active task or

package/dist/backend/api/task-routes.js

@@ -71,7 +71,8 @@ export function registerTaskRoutes(app, deps) {
                 orchestration,
                 roundState,
                 workflowState,
-                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug)
+                architectRestart: deps.architectRestartService.getState(project.repoRoot, taskSlug),
+                roleStallWarning: deps.roleStallDetector.getWarning(project.repoRoot, taskSlug)
             };
         }
         catch (error) {
@@ -86,12 +87,30 @@ export function registerTaskRoutes(app, deps) {
                     },
                     roundState: degradedRoundState(taskSlug),
                     workflowState: degradedWorkflowState(taskSlug),
-                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug)
+                    architectRestart: deps.architectRestartService.getState(repoRoot, taskSlug),
+                    roleStallWarning: deps.roleStallDetector.getWarning(repoRoot, taskSlug)
                 };
             }
             throw error;
         }
     });
+    app.post("/api/tasks/:taskSlug/role-stall/ignore", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        return deps.roleStallDetector.ignoreWarning(project.repoRoot, request.params.taskSlug, requireWarningId(request.body?.warningId));
+    });
+    app.post("/api/tasks/:taskSlug/role-stall/recover", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const config = await deps.projectService.loadConfig(project.repoRoot);
+        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        return deps.roleStallDetector.recoverWarning({
+            repoRoot: project.repoRoot,
+            taskRepoRoot,
+            stateRoot: config.stateRoot,
+            taskSlug: task.taskSlug,
+            warningId: requireWarningId(request.body?.warningId)
+        });
+    });
     app.post("/api/tasks/:taskSlug/workflow-state", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const config = await deps.projectService.loadConfig(project.repoRoot);
@@ -117,6 +136,16 @@ export function registerTaskRoutes(app, deps) {
         return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
+function requireWarningId(value) {
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    throw new VcmError({
+        code: "ROLE_STALL_WARNING_ID_REQUIRED",
+        message: "A role stall warning id is required.",
+        statusCode: 400
+    });
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

package/dist/backend/api/workflow-control-routes.js

@@ -1,31 +1,10 @@
 import { VcmError } from "../errors.js";
-import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerWorkflowControlRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/workflow-control", async (request) => {
         const context = await getContext(deps, request.params.taskSlug);
         return deps.workflowControlService.getState(context);
     });
-    app.post("/api/tasks/:taskSlug/workflow-overrides/:overrideId/approve", async (request) => {
-        const authorizationText = request.body?.authorizationText?.trim();
-        if (!authorizationText) {
-            throw new VcmError({
-                code: "WORKFLOW_OVERRIDE_AUTHORIZATION_REQUIRED",
-                message: "Enter the exact workflow exception that the user authorizes.",
-                statusCode: 400
-            });
-        }
-        const context = await getContext(deps, request.params.taskSlug);
-        const state = await deps.workflowControlService.approveOverride(context, request.params.overrideId, authorizationText);
-        await notifyProjectManager(deps, context, request.params.overrideId, "approved", authorizationText);
-        return state;
-    });
-    app.post("/api/tasks/:taskSlug/workflow-overrides/:overrideId/reject", async (request) => {
-        const context = await getContext(deps, request.params.taskSlug);
-        const state = await deps.workflowControlService.rejectOverride(context, request.params.overrideId);
-        await notifyProjectManager(deps, context, request.params.overrideId, "rejected");
-        return state;
-    });
 }
 async function getContext(deps, taskSlug) {
     const project = await deps.projectService.getCurrentProject();
@@ -44,13 +23,3 @@ async function getContext(deps, taskSlug) {
         taskSlug: task.taskSlug
     };
 }
-async function notifyProjectManager(deps, context, overrideId, decision, authorizationText) {
-    const session = await deps.sessionService.getRoleSession(context.repoRoot, context.taskSlug, "project-manager");
-    if (!session || session.status !== "running" || session.activityStatus === "running")
-        return;
-    const prompt = decision === "approved"
-        ? `[VCM Workflow Override Decision]\nDecision: approved\nAuthorization ID: ${overrideId}\nAuthorization Text: ${authorizationText}\n\nResubmit workflow-progress.md with this Authorization ID and exact Authorization Text.`
-        : `[VCM Workflow Override Decision]\nDecision: rejected\nAuthorization ID: ${overrideId}\n\nKeep the current workflow and choose a legal next dispatch.`;
-    await submitTerminalInput(deps.runtime, session.id, prompt);
-    await deps.sessionService.markRoleActivityRunning(context.repoRoot, context.taskSlug, "project-manager", session.id);
-}

package/dist/backend/cli/install-vcm-harness.js

@@ -57,8 +57,15 @@ const VCM_HOOK_DEFINITIONS = [
     { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "PreToolUse", matcher: "Write|Edit", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
     { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUse", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolUseFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PostToolBatch", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStart", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "SubagentStop", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
     { eventName: "StopFailure", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "PreCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PostCompact", command: VCM_HOOK_COMMAND, timeout: 5 },
     { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
 ];
@@ -74,8 +81,7 @@ const AGENT_FRONTMATTER = {
     },
     coder: {
         description: "VCM implementation role for scoped code changes and focused tests.",
-        disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", "),
-        skills: ["vcm-code-navigation"]
+        disallowedTools: CODE_ROLE_DISALLOWED_TOOLS.join(", ")
     },
     tester: {
         description: "VCM testing role for validation, test adequacy, approved-scope validation, and risk findings.",
@@ -83,8 +89,7 @@ const AGENT_FRONTMATTER = {
     },
     reviewer: {
         description: "VCM independent gate review role for architecture plans, validation adequacy, and code diffs.",
-        disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", "),
-        skills: ["vcm-code-navigation"]
+        disallowedTools: REVIEWER_DISALLOWED_TOOLS.join(", ")
     },
     translator: {
         description: "VCM task-scoped translation tool role for conversation translation, file translation, bootstrap, and memory updates."
@@ -114,7 +119,9 @@ const REQUIRED_AGENT_TOOLS = {
     "harness-engineer": ["Skill"]
 };
 const REQUIRED_AGENT_SKILLS = {
-    architect: ["vcm-code-navigation"],
+    architect: ["vcm-code-navigation"]
+};
+const REMOVED_AGENT_SKILLS = {
     coder: ["vcm-code-navigation"],
     reviewer: ["vcm-code-navigation"]
 };
@@ -285,7 +292,7 @@ const WHOLE_FILES = [
         path: ".claude/skills/vcm-code-navigation/SKILL.md",
         category: "skill",
         mode: 0o644,
-        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect, Coder, or Reviewer must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
+        content: renderSkillFile("VCM Code Navigation Skill", "vcm-code-navigation", "Use when Architect must resolve code symbols, references, implementations, call hierarchies, or bounded dependency paths.", renderVcmCodeNavigationSkillRules())
     },
     {
         path: ".claude/skills/vcm-final-acceptance/SKILL.md",
@@ -711,6 +718,9 @@ async function installManagedFile({ projectRoot, definition, dryRun, operations
     for (const requiredSkill of REQUIRED_AGENT_SKILLS[definition.agentName] ?? []) {
         nextContent = ensureAgentSkill(nextContent, requiredSkill);
     }
+    for (const removedSkill of REMOVED_AGENT_SKILLS[definition.agentName] ?? []) {
+        nextContent = removeAgentSkill(nextContent, removedSkill);
+    }
     await writeIfChanged({
         targetPath,
         relativePath: definition.path,
@@ -829,6 +839,30 @@ function ensureAgentSkill(content, requiredSkill) {
     const nextSkills = `${skillsMatch[0].trimEnd()}\n  - ${requiredSkill}`;
     return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], nextSkills));
 }
+function removeAgentSkill(content, removedSkill) {
+    const frontmatterMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---/);
+    if (!frontmatterMatch) {
+        return content;
+    }
+    const frontmatter = frontmatterMatch[0];
+    const skillsMatch = frontmatter.match(/^skills:[ \t]*(?:\r?\n((?:\s+-\s+[^\r\n]+\r?\n?)*))?/m);
+    if (!skillsMatch) {
+        return content;
+    }
+    const listedSkills = (skillsMatch[1] ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s+-\s+(.+)$/)?.[1]?.trim())
+        .filter(Boolean);
+    const remainingSkills = listedSkills.filter((skill) => skill !== removedSkill);
+    if (remainingSkills.length === listedSkills.length) {
+        return content;
+    }
+    const lineEnding = skillsMatch[0].includes("\r\n") ? "\r\n" : "\n";
+    const replacement = remainingSkills.length > 0
+        ? `skills:${lineEnding}${remainingSkills.map((skill) => `  - ${skill}`).join(lineEnding)}${lineEnding}`
+        : "";
+    return content.replace(frontmatter, frontmatter.replace(skillsMatch[0], replacement));
+}
 function migrateLegacyManagedFile(definition, currentContent, block) {
     const legacyContent = definition.legacyWholeFile?.trimEnd();
     if (!legacyContent) {

package/dist/backend/role-tool-policy.js

@@ -44,7 +44,7 @@ export const REVIEWER_RUNTIME_DISALLOWED_TOOLS = [
     "Edit",
     ...NON_VCM_ROLE_RUNTIME_TOOLS
 ];
-const LSP_ROLE_NAMES = new Set(["architect", "coder", "reviewer"]);
+const LSP_ROLE_NAMES = new Set(["architect"]);
 export function roleUsesLsp(role) {
     return LSP_ROLE_NAMES.has(role);
 }

package/dist/backend/server.js

@@ -13,6 +13,7 @@ import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCcrIntegrationService } from "./services/ccr-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
+import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -134,7 +135,8 @@ export async function createServer(deps, options = {}) {
         taskLaunchService: deps.taskLaunchService,
         roundService: deps.roundService,
         taskWorkflowService: deps.taskWorkflowService,
-        architectRestartService: deps.architectRestartService
+        architectRestartService: deps.architectRestartService,
+        roleStallDetector: deps.roleStallDetector
     });
     registerSessionRoutes(app, {
         projectService: deps.projectService,
@@ -154,9 +156,7 @@ export async function createServer(deps, options = {}) {
         registerWorkflowControlRoutes(app, {
             projectService: deps.projectService,
             taskService: deps.taskService,
-            sessionService: deps.sessionService,
-            workflowControlService: deps.workflowControlService,
-            runtime: deps.runtime
+            workflowControlService: deps.workflowControlService
         });
     }
     registerMessageRoutes(app, {
@@ -340,6 +340,10 @@ export function createDefaultServerDeps(options = {}) {
         sessionService
     });
     const transcripts = createClaudeTranscriptService();
+    const roleStallDetector = createRoleStallDetectorService({
+        sessionService,
+        roundService
+    });
     const translationService = createTranslationService({
         runtime,
         sessionRegistry: registry,
@@ -411,7 +415,8 @@ export function createDefaultServerDeps(options = {}) {
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService,
-        architectRestartService
+        architectRestartService,
+        roleStallDetector
     });
     const runtimeCoordinator = createRuntimeCoordinatorService({
         appSettings,
@@ -423,6 +428,7 @@ export function createDefaultServerDeps(options = {}) {
         harnessFeedbackService,
         autoMemoryService,
         roundService,
+        roleStallDetector,
         gatewayService,
         async getStateRoot(repoRoot) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
@@ -463,6 +469,7 @@ export function createDefaultServerDeps(options = {}) {
         autoMemoryService,
         commandDispatcher,
         claudeHookService,
+        roleStallDetector,
         messageService,
         taskLaunchService,
         gateReviewService,

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

@@ -7,6 +7,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { renderArchitectureBriefTemplate, renderArchitectureDiagnosisTemplate, renderArchitectureEvidenceTemplate, renderArchitecturePlanTemplate, renderArchitectDebugTemplate, renderCoderCompletionTemplate, renderDocsSyncReportTemplate, renderFinalAcceptanceTemplate, renderKnownIssuesTemplate, renderPlanningProgressTemplate, renderMessageRouteTemplate, renderTestReportTemplate, renderWorkflowProgressTemplate } from "../templates/handoff.js";
 import { renderRoleCommandTemplate } from "../templates/role-command.js";
 import { validateMemoryProposal } from "./memory-proposal-validation.js";
+import { isMemoryProposalSubmissionPath } from "./memory-review-paths.js";
 const ARTIFACT_PATH_KEYS = [
     ["architecture-brief", "architectureBriefPath"],
     ["architecture-evidence", "architectureEvidencePath"],
@@ -314,8 +315,8 @@ async function validateDynamicArtifact(fs, input, content, workflowControlServic
         if (!VCM_ROLE_NAMES.includes(input.role)) {
             throw artifactRejected(input.kind, ["Only a VCM workflow role may submit a Memory Proposal."]);
         }
-        if (!/^\.ai\/vcm\/memory-review\/(?:runs\/[A-Za-z0-9._-]+\/drafts|candidates)\/[A-Za-z0-9._-]+\.md$/.test(artifactPath)) {
-            throw artifactRejected(input.kind, ["Memory proposal path is outside the VCM memory-review draft locations."]);
+        if (!isMemoryProposalSubmissionPath(artifactPath, input.role)) {
+            throw artifactRejected(input.kind, ["Memory proposal path is not assigned to the submitting role."]);
         }
         const memoryError = validateMemoryProposal(content);
         if (memoryError) {

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

@@ -5,7 +5,7 @@ import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { readVcmMemoryBlock, replaceVcmMemoryBlock } from "../templates/harness/memory-block.js";
-import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
+import { ARCHITECT_PLANNING_MEMORY_CANDIDATE_PATH, architectPlanningCandidateSnapshotPath, memoryReviewRoleDraftPath, MEMORY_REVIEW_RUNS_ROOT, MEMORY_REVIEW_STATE_PATH } from "./memory-review-paths.js";
 import { parseMemoryProposal, validateMemoryProposal } from "./memory-proposal-validation.js";
 const MEMORY_FILE_DEFINITIONS = [
     { path: "CLAUDE.md", title: "Shared Memory" },
@@ -175,7 +175,7 @@ export function createAutoMemoryService(deps) {
         const runId = createRunId(timestamp, "auto");
         const drafts = roles.map((role) => ({
             role,
-            path: `${MEMORY_REVIEW_RUNS_ROOT}/${runId}/drafts/${role}.md`,
+            path: memoryReviewRoleDraftPath(runId, role),
             status: "pending"
         }));
         const state = {

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
@@ -240,6 +240,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({
@@ -313,6 +319,12 @@ export function createClaudeHookService(deps) {
                 };
             }
         }
+        await deps.roleStallDetector?.recordHook({
+            ...createStallContext(context),
+            role: input.role,
+            eventName,
+            event: input.event
+        });
         return recordTurnEnd(input, context, eventName, {
             dispatchRouteFiles: !isReviewerRoleName(input.role),
             notifyGateway: true,
@@ -357,6 +369,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 +448,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,
@@ -552,6 +578,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,
@@ -764,6 +798,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 +865,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 +891,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 +933,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 +947,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",