vibe-coding-master 0.2.6 → 0.2.8

package/dist/backend/gateway/gateway-settings-service.js

@@ -0,0 +1,214 @@
+import path from "node:path";
+import { homedir } from "node:os";
+const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+const MAX_DEDUPE_IDS = 1000;
+export function createGatewaySettingsService(deps) {
+    const settingsPath = deps.settingsPath ?? path.join(homedir(), ".vcm", "gateway", "settings.json");
+    const auditPath = deps.auditPath ?? path.join(homedir(), ".vcm", "gateway", "audit.jsonl");
+    const now = deps.now ?? (() => new Date().toISOString());
+    let cachedSettings = null;
+    async function loadSettings() {
+        if (cachedSettings) {
+            return cachedSettings;
+        }
+        if (!(await deps.fs.pathExists(settingsPath))) {
+            cachedSettings = normalizeSettings({}, now());
+            await saveSettings(cachedSettings);
+            return cachedSettings;
+        }
+        cachedSettings = normalizeSettings(await deps.fs.readJson(settingsPath), now());
+        return cachedSettings;
+    }
+    async function saveSettings(settings) {
+        cachedSettings = normalizeSettings(settings, now());
+        await deps.fs.writeJsonAtomic(settingsPath, cachedSettings);
+        return cachedSettings;
+    }
+    return {
+        loadSettings,
+        async updateSettings(input) {
+            const current = await loadSettings();
+            return saveSettings({
+                ...current,
+                enabled: input.enabled ?? current.enabled,
+                translationEnabled: input.translationEnabled ?? current.translationEnabled,
+                currentProjectId: input.currentProjectId !== undefined ? normalizeNullableString(input.currentProjectId) : current.currentProjectId,
+                currentTaskSlug: input.currentTaskSlug !== undefined ? normalizeNullableString(input.currentTaskSlug) : current.currentTaskSlug,
+                updatedAt: now()
+            });
+        },
+        saveSettings,
+        async resetBinding() {
+            const current = await loadSettings();
+            return saveSettings({
+                ...current,
+                enabled: false,
+                binding: createDefaultBinding(),
+                dedupe: {
+                    recentInboundMessageIds: []
+                },
+                pushCursors: {},
+                lastPollStatus: {
+                    state: "idle"
+                },
+                lastMessageStatus: null,
+                updatedAt: now()
+            });
+        },
+        expose(settings, running = false) {
+            return {
+                version: 1,
+                enabled: settings.enabled,
+                running,
+                channel: settings.channel,
+                translationEnabled: settings.translationEnabled,
+                currentProjectId: settings.currentProjectId,
+                currentTaskSlug: settings.currentTaskSlug,
+                binding: {
+                    accountId: settings.binding.accountId,
+                    baseUrl: settings.binding.baseUrl,
+                    boundUserId: settings.binding.boundUserId,
+                    loginUserId: settings.binding.loginUserId,
+                    tokenConfigured: Boolean(settings.binding.token)
+                },
+                pendingConfirmations: settings.pendingConfirmations,
+                lastPollStatus: settings.lastPollStatus,
+                lastMessageStatus: settings.lastMessageStatus,
+                updatedAt: settings.updatedAt
+            };
+        },
+        getSettingsPath() {
+            return settingsPath;
+        },
+        getAuditPath() {
+            return auditPath;
+        }
+    };
+}
+export function normalizeSettings(input, timestamp) {
+    const bindingInput = isObject(input.binding) ? input.binding : {};
+    const dedupeInput = isObject(input.dedupe) ? input.dedupe : {};
+    const pendingInput = isObject(input.pendingConfirmations)
+        ? input.pendingConfirmations
+        : {};
+    const pushCursors = isObject(input.pushCursors) ? input.pushCursors : {};
+    return {
+        version: 1,
+        enabled: input.enabled === true,
+        channel: "weixin-ilink",
+        translationEnabled: input.translationEnabled !== false,
+        currentProjectId: normalizeNullableString(input.currentProjectId),
+        currentTaskSlug: normalizeNullableString(input.currentTaskSlug),
+        binding: {
+            ...createDefaultBinding(),
+            accountId: normalizeNullableString(bindingInput.accountId),
+            baseUrl: normalizeBaseUrl(bindingInput.baseUrl),
+            boundUserId: normalizeNullableString(bindingInput.boundUserId),
+            loginUserId: normalizeNullableString(bindingInput.loginUserId),
+            token: normalizeNullableString(bindingInput.token),
+            getUpdatesBuf: typeof bindingInput.getUpdatesBuf === "string" ? bindingInput.getUpdatesBuf : "",
+            contextTokens: isObject(bindingInput.contextTokens)
+                ? normalizeStringRecord(bindingInput.contextTokens)
+                : {}
+        },
+        dedupe: {
+            recentInboundMessageIds: Array.isArray(dedupeInput.recentInboundMessageIds)
+                ? dedupeInput.recentInboundMessageIds.filter((value) => typeof value === "string").slice(-MAX_DEDUPE_IDS)
+                : []
+        },
+        pendingConfirmations: {
+            closeTask: normalizeCloseTaskConfirmation(pendingInput.closeTask)
+        },
+        pushCursors: normalizePushCursors(pushCursors),
+        lastPollStatus: normalizePollStatus(input.lastPollStatus),
+        lastMessageStatus: normalizeMessageStatus(input.lastMessageStatus),
+        updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : timestamp
+    };
+}
+function createDefaultBinding() {
+    return {
+        accountId: null,
+        baseUrl: DEFAULT_BASE_URL,
+        boundUserId: null,
+        loginUserId: null,
+        token: null,
+        getUpdatesBuf: "",
+        contextTokens: {}
+    };
+}
+function normalizeCloseTaskConfirmation(input) {
+    if (!isObject(input)) {
+        return null;
+    }
+    const taskSlug = normalizeNullableString(input.taskSlug);
+    const createdAt = normalizeNullableString(input.createdAt);
+    const expiresAt = normalizeNullableString(input.expiresAt);
+    if (!taskSlug || !createdAt || !expiresAt) {
+        return null;
+    }
+    return { taskSlug, createdAt, expiresAt };
+}
+function normalizePushCursors(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (!isObject(value)) {
+            continue;
+        }
+        out[key] = {
+            lastTranscriptEventId: normalizeNullableString(value.lastTranscriptEventId),
+            lastTranscriptTimestamp: normalizeNullableString(value.lastTranscriptTimestamp)
+        };
+    }
+    return out;
+}
+function normalizePollStatus(input) {
+    if (!isObject(input)) {
+        return { state: "idle" };
+    }
+    const state = input.state === "running" || input.state === "error" || input.state === "expired"
+        ? input.state
+        : "idle";
+    return {
+        state,
+        checkedAt: normalizeNullableString(input.checkedAt) ?? undefined,
+        error: normalizeNullableString(input.error) ?? undefined
+    };
+}
+function normalizeMessageStatus(input) {
+    if (!isObject(input)) {
+        return null;
+    }
+    return {
+        checkedAt: normalizeNullableString(input.checkedAt) ?? undefined,
+        direction: input.direction === "inbound" || input.direction === "outbound" ? input.direction : undefined,
+        command: normalizeNullableString(input.command) ?? undefined,
+        result: input.result === "ok" || input.result === "ignored" || input.result === "error" ? input.result : undefined,
+        preview: normalizeNullableString(input.preview) ?? undefined,
+        error: normalizeNullableString(input.error) ?? undefined
+    };
+}
+function normalizeBaseUrl(input) {
+    const raw = typeof input === "string" ? input.trim() : "";
+    if (!raw) {
+        return DEFAULT_BASE_URL;
+    }
+    if (raw.startsWith("http://") || raw.startsWith("https://")) {
+        return raw.replace(/\/+$/, "");
+    }
+    return `https://${raw.replace(/\/+$/, "")}`;
+}
+function normalizeNullableString(input) {
+    return typeof input === "string" && input.trim() ? input.trim() : null;
+}
+function normalizeStringRecord(input) {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value === "string") {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/backend/server.js

@@ -14,6 +14,12 @@ import { createHarnessService, createScriptFixedHarnessInstaller } from "./servi
 import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
 import { createOpenAiCompatibleTranslationProvider } from "./adapters/translation-provider.js";
+import { registerGatewayRoutes } from "./api/gateway-routes.js";
+import { createWeixinIlinkChannel } from "./gateway/channels/weixin-ilink-channel.js";
+import { createGatewayAuditLog } from "./gateway/gateway-audit-log.js";
+import { createGatewayService } from "./gateway/gateway-service.js";
+import { createGatewaySettingsService } from "./gateway/gateway-settings-service.js";
+import { createJobGuardService } from "./services/job-guard-service.js";
 import { createProjectService } from "./services/project-service.js";
 import { createSessionRegistry } from "./runtime/session-registry.js";
 import { createSessionService } from "./services/session-service.js";
@@ -90,7 +96,14 @@ export async function createServer(deps, options = {}) {
         taskService: deps.taskService,
         translationService: deps.translationService
     });
+    registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
     registerTerminalWs(app, { runtime: deps.runtime });
+    app.addHook("onReady", async () => {
+        await deps.gatewayService.start();
+    });
+    app.addHook("onClose", async () => {
+        deps.gatewayService.stop();
+    });
     if (options.staticDir) {
         await app.register(fastifyStatic, {
             root: options.staticDir,
@@ -162,7 +175,12 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         taskService
     });
-    const roundService = createRoundService({ fs });
+    const roundService = createRoundService({
+        fs,
+        onSessionStatusChange: async ({ repoRoot, taskSlug, status }) => {
+            await taskService.updateTaskStatus(repoRoot, taskSlug, status);
+        }
+    });
     const transcripts = createClaudeTranscriptService();
     const translationService = createTranslationService({
         runtime,
@@ -174,6 +192,25 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         provider: createOpenAiCompatibleTranslationProvider()
     });
+    const gatewaySettings = createGatewaySettingsService({ fs });
+    const gatewayAudit = createGatewayAuditLog({
+        fs,
+        auditPath: gatewaySettings.getAuditPath()
+    });
+    const gatewayService = createGatewayService({
+        fs,
+        settings: gatewaySettings,
+        audit: gatewayAudit,
+        channel: createWeixinIlinkChannel(),
+        projectService,
+        taskService,
+        sessionService,
+        messageService,
+        translationService,
+        roundService,
+        runtime,
+        appSettings
+    });
     const claudeHookService = createClaudeHookService({
         projectService,
         taskService,
@@ -181,7 +218,9 @@ export function createDefaultServerDeps(options = {}) {
         messageService,
         roundService,
         translationService,
-        appSettings
+        appSettings,
+        gatewayService,
+        jobGuard: createJobGuardService()
     });
     return {
         appSettings,
@@ -196,6 +235,7 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         statusService,
         translationService,
+        gatewayService,
         runtime
     };
 }

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

@@ -34,6 +34,11 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        deps.jobGuard?.notePromptSubmitted({
+            repoRoot: context.project.repoRoot,
+            taskSlug: input.taskSlug,
+            role: input.role
+        });
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: input.taskSlug,
             role: input.role,
@@ -43,6 +48,7 @@ export function createClaudeHookService(deps) {
             cwd: stringOrUndefined(input.event.cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
+            repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
@@ -57,7 +63,7 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "start",
-                occurredAt: session.lastPromptSubmittedAt ?? session.updatedAt
+                occurredAt: session.lastTurnStartedAt ?? session.updatedAt
             });
         }
         const submitted = await deps.messageService.confirmPromptSubmitted({
@@ -80,12 +86,33 @@ export function createClaudeHookService(deps) {
             acceptedMessageId: submitted?.id
         };
     }
-    async function handleStopHook(input) {
+    async function processStopHook(input, options) {
         const eventName = parseHookEvent(input.event.hook_event_name ?? "Stop");
         if (eventName !== "Stop") {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        if (options.allowBlock && deps.jobGuard) {
+            const verdict = await deps.jobGuard.evaluateStop({
+                repoRoot: context.project.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                taskRepoRoot: context.taskRepoRoot
+            });
+            if (verdict.behavior === "block") {
+                // The role turn stays alive: skip all turn-end bookkeeping so the
+                // round keeps running and no route dispatch happens yet.
+                return {
+                    ok: true,
+                    eventName,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    sessionUpdated: false,
+                    dispatchedCount: 0,
+                    stopDecision: { behavior: "block", reason: verdict.reason }
+                };
+            }
+        }
         const scopedRouteDispatchInput = {
             repoRoot: context.project.repoRoot,
             taskRepoRoot: context.taskRepoRoot,
@@ -112,6 +139,7 @@ export function createClaudeHookService(deps) {
             cwd: stringOrUndefined(input.event.cwd)
         });
         await deps.roundService.recordClaudeHookEvent({
+            repoRoot: context.project.repoRoot,
             stateRepoRoot: context.taskRepoRoot,
             stateRoot: context.config.stateRoot,
             taskSlug: input.taskSlug,
@@ -120,12 +148,12 @@ export function createClaudeHookService(deps) {
             settleGuard: async () => {
                 const pending = await deps.messageService.listPendingRouteFiles(settleRouteDispatchInput);
                 if (pending.length === 0) {
-                    return { action: "pause" };
+                    return { action: "stop" };
                 }
                 const retried = await deps.messageService.scanAndDispatchPendingRouteFiles(settleRouteDispatchInput);
                 return retried.some((result) => result.delivered)
                     ? { action: "continue", reason: "pending route message dispatched" }
-                    : { action: "pause" };
+                    : { action: "stop" };
             }
         });
         if (session) {
@@ -136,9 +164,16 @@ export function createClaudeHookService(deps) {
                 role: input.role,
                 sessionId: session.id,
                 boundaryKind: "end",
-                occurredAt: session.lastStopAt ?? session.updatedAt
+                occurredAt: session.lastTurnEndedAt ?? session.updatedAt
             });
         }
+        if (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);
         return {
             ok: true,
@@ -185,9 +220,13 @@ export function createClaudeHookService(deps) {
             if (eventName === "UserPromptSubmit") {
                 return handleUserPromptSubmitHook(input);
             }
-            return handleStopHook(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) {
+            return processStopHook(input, { allowBlock: true });
         },
-        handleStopHook,
         handlePermissionRequestHook
     };
 }

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

@@ -6,7 +6,6 @@ import { renderArchitectHarnessRules } from "../templates/harness/architect-agen
 import { renderCoderHarnessRules } from "../templates/harness/coder-agent.js";
 import { renderRootClaudeHarnessRules } from "../templates/harness/claude-root.js";
 import { renderGitignoreHarnessRules } from "../templates/harness/gitignore.js";
-import { renderKnownIssuesDocHarnessRules } from "../templates/harness/known-issues-doc.js";
 import { renderProjectManagerHarnessRules } from "../templates/harness/project-manager-agent.js";
 import { renderPullRequestTemplateHarnessRules } from "../templates/harness/pull-request-template.js";
 import { renderReviewerHarnessRules } from "../templates/harness/reviewer-agent.js";
@@ -26,13 +25,22 @@ const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
-const VCM_HOOK_EVENTS = ["UserPromptSubmit", "Stop", "PermissionRequest"];
+const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; exec python3 "\${CLAUDE_PROJECT_DIR:-.}/.ai/tools/vcm-bash-guard"'`;
+const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";
+const VCM_HOOK_DEFINITIONS = [
+    { eventName: "PreToolUse", matcher: "Bash", command: VCM_BASH_GUARD_HOOK_COMMAND, timeout: 10 },
+    { eventName: "UserPromptSubmit", command: VCM_HOOK_COMMAND, timeout: 5 },
+    { eventName: "Stop", command: VCM_STOP_HOOK_COMMAND, timeout: 10 },
+    { eventName: "PermissionRequest", command: VCM_PERMISSION_REQUEST_HOOK_COMMAND, timeout: 5 }
+];
 const HARNESS_FILES = [
     {
         kind: "root-claude",
         path: "CLAUDE.md",
         title: "CLAUDE.md",
+        blankLineBeforeEnd: true,
         renderRules: renderRootClaudeHarnessRules
     },
     {
@@ -42,12 +50,6 @@ const HARNESS_FILES = [
         commentStyle: "hash",
         renderRules: renderGitignoreHarnessRules
     },
-    {
-        kind: "docs-known-issues",
-        path: "docs/known-issues.md",
-        title: "Known Issues",
-        renderRules: renderKnownIssuesDocHarnessRules
-    },
     {
         kind: "pull-request-template",
         path: ".github/pull_request_template.md",
@@ -97,6 +99,7 @@ const HARNESS_FILES = [
         kind: "agent-architect",
         path: ".claude/agents/architect.md",
         title: "Architect Agent",
+        blankLineBeforeEnd: true,
         frontmatter: renderAgentFrontmatter("architect", "VCM architecture role for plans, module boundaries, public contracts, verifiable behavior, and docs sync."),
         renderRules: renderArchitectHarnessRules
     },
@@ -111,7 +114,7 @@ const HARNESS_FILES = [
         kind: "agent-reviewer",
         path: ".claude/agents/reviewer.md",
         title: "Reviewer Agent",
-        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent review role for acceptance, test adequacy, scope checks, docs gaps, and risk findings."),
+        frontmatter: renderAgentFrontmatter("reviewer", "VCM independent review role for acceptance, test adequacy, scope checks, and risk findings."),
         renderRules: renderReviewerHarnessRules
     }
 ];
@@ -344,10 +347,11 @@ function renderHarnessStatus(analyses) {
     };
 }
 function renderManagedBlock(definition, rules) {
+    const endSpacing = definition.blankLineBeforeEnd ? "\n\n" : "\n";
     if (definition.commentStyle === "hash") {
-        return `# VCM:BEGIN version=${VCM_HARNESS_VERSION}\n${rules.trimEnd()}\n# VCM:END`;
+        return `# VCM:BEGIN version=${VCM_HARNESS_VERSION}\n${rules.trimEnd()}${endSpacing}# VCM:END`;
     }
-    return `<!-- VCM:BEGIN version=${VCM_HARNESS_VERSION} -->\n${rules.trimEnd()}\n<!-- VCM:END -->`;
+    return `<!-- VCM:BEGIN version=${VCM_HARNESS_VERSION} -->\n${rules.trimEnd()}${endSpacing}<!-- VCM:END -->`;
 }
 function getManagedBlockPattern(definition) {
     return definition.commentStyle === "hash"
@@ -427,29 +431,30 @@ function withVcmClaudeHooks(settings) {
             delete hooks[eventName];
         }
     }
-    for (const eventName of VCM_HOOK_EVENTS) {
-        const existingMatchers = Array.isArray(hooks[eventName])
-            ? hooks[eventName]
+    for (const definition of VCM_HOOK_DEFINITIONS) {
+        const existingMatchers = Array.isArray(hooks[definition.eventName])
+            ? hooks[definition.eventName]
             : [];
-        hooks[eventName] = [
+        hooks[definition.eventName] = [
             ...existingMatchers.filter((entry) => !isVcmHookMatcher(entry)),
-            createVcmHookMatcher(eventName)
+            {
+                ...(definition.matcher ? { matcher: definition.matcher } : {}),
+                hooks: [
+                    {
+                        type: "command",
+                        command: definition.command,
+                        timeout: definition.timeout
+                    }
+                ]
+            }
         ];
     }
+    const env = isPlainObject(settings.env) ? { ...settings.env } : {};
+    env.BASH_DEFAULT_TIMEOUT_MS = VCM_BASH_DEFAULT_TIMEOUT_MS;
     return {
         ...settings,
-        hooks
-    };
-}
-function createVcmHookMatcher(eventName) {
-    return {
-        hooks: [
-            {
-                type: "command",
-                command: eventName === "PermissionRequest" ? VCM_PERMISSION_REQUEST_HOOK_COMMAND : VCM_HOOK_COMMAND,
-                timeout: 5
-            }
-        ]
+        hooks,
+        env
     };
 }
 function isVcmHookMatcher(value) {
@@ -460,12 +465,12 @@ function isVcmHookMatcher(value) {
         if (!isPlainObject(hook)) {
             return false;
         }
-        return typeof hook.command === "string" && hook.command.includes("hook-event");
-    }) || value.hooks.some((hook) => {
-        if (!isPlainObject(hook)) {
+        if (typeof hook.command !== "string") {
             return false;
         }
-        return typeof hook.command === "string" && hook.command.includes("/api/hooks/claude-code");
+        return hook.command.includes("VCM") ||
+            hook.command.includes("/api/hooks/claude-code") ||
+            hook.command.includes("hook-event");
     });
 }
 function isPlainObject(value) {