patchwork-os 0.2.0-alpha.0

package/dist/automation.js

@@ -0,0 +1,1038 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { executeAutomationPolicy } from "./fp/automationInterpreter.js";
+import { EMPTY_AUTOMATION_STATE, setLatestDiagnostics, setTestRunnerStatus, tasksInLastHour, } from "./fp/automationState.js";
+import { VsCodeBackend } from "./fp/interpreterContext.js";
+import { parsePolicy } from "./fp/policyParser.js";
+/** Maximum length (chars) of an automation policy prompt template (matches runClaudeTask cap) */
+const MAX_POLICY_PROMPT_CHARS = 32_768;
+/** Default system prompt for automation subprocesses when none is set in policy. */
+const DEFAULT_AUTOMATION_SYSTEM_PROMPT = "You are a concise automation assistant. " +
+    "Respond in \u22645 lines. No preamble. No markdown headers. " +
+    "Call the tools listed in the task prompt, then report results only.";
+/**
+ * Deterministic signature over a diagnostic list — used for content-aware
+ * dedupe in onDiagnosticsError. Sorting by a stable key makes the signature
+ * order-independent so LSP re-emissions with the same diagnostics in a
+ * different order still collide.
+ */
+export function diagnosticSignature(diagnostics) {
+    const keyOf = (d) => `${d.severity}|${d.code ?? ""}|${(d.source ?? "").toLowerCase()}|${d.message.slice(0, 200)}`;
+    const sigText = [...diagnostics].map(keyOf).sort().join("\n");
+    return crypto.createHash("sha256").update(sigText).digest("hex").slice(0, 12);
+}
+const MIN_COOLDOWN_MS = 5_000;
+/** Maximum length of a promptName value in a policy. */
+const MAX_PROMPT_NAME_CHARS = 64;
+// ── Policy loading ────────────────────────────────────────────────────────────
+/**
+ * Validates that a hook config has exactly one of `prompt` (non-empty inline string)
+ * or `promptName` (reference to a built-in MCP prompt), plus optional `promptArgs`.
+ * Throws a descriptive error on violation.
+ */
+function validatePromptSource(hookName, cfg) {
+    const hasPrompt = typeof cfg.prompt === "string" && cfg.prompt.trim() !== "";
+    const hasPromptName = typeof cfg.promptName === "string" && cfg.promptName.trim() !== "";
+    if (hasPrompt && hasPromptName) {
+        throw new Error(`"${hookName}" must specify either "prompt" or "promptName", not both`);
+    }
+    if (!hasPrompt && !hasPromptName) {
+        throw new Error(`"${hookName}" must have a non-empty "prompt" or "promptName"`);
+    }
+    if (hasPrompt && (cfg.prompt?.length ?? 0) > MAX_POLICY_PROMPT_CHARS) {
+        throw new Error(`"${hookName}.prompt" must be ≤ ${MAX_POLICY_PROMPT_CHARS} characters`);
+    }
+    if (hasPromptName) {
+        if ((cfg.promptName?.length ?? 0) > MAX_PROMPT_NAME_CHARS) {
+            throw new Error(`"${hookName}.promptName" must be ≤ ${MAX_PROMPT_NAME_CHARS} characters`);
+        }
+        if (cfg.promptArgs !== undefined) {
+            if (typeof cfg.promptArgs !== "object" ||
+                cfg.promptArgs === null ||
+                Array.isArray(cfg.promptArgs)) {
+                throw new Error(`"${hookName}.promptArgs" must be a plain object`);
+            }
+            for (const [k, v] of Object.entries(cfg.promptArgs)) {
+                if (typeof v !== "string") {
+                    throw new Error(`"${hookName}.promptArgs.${k}" must be a string`);
+                }
+            }
+        }
+    }
+    if (cfg.condition !== undefined) {
+        if (typeof cfg.condition !== "string" || cfg.condition.length > 1024) {
+            throw new Error(`"${hookName}.condition" must be a string ≤ 1024 characters`);
+        }
+    }
+    if (cfg.model !== undefined) {
+        if (typeof cfg.model !== "string" || cfg.model.trim() === "") {
+            throw new Error(`"${hookName}.model" must be a non-empty string`);
+        }
+    }
+    if (cfg.effort !== undefined) {
+        if (!["low", "medium", "high", "max"].includes(cfg.effort)) {
+            throw new Error(`"${hookName}.effort" must be one of "low", "medium", "high", "max"`);
+        }
+    }
+}
+/**
+ * Expand a discriminated unified hook (e.g. onCompaction.phase="pre"|"post")
+ * into the corresponding internal legacy slot, then clear the unified key.
+ * Throws if the discriminator value is invalid or if both the unified hook
+ * and the legacy slot are set simultaneously.
+ * legacyA/legacyB may be null when there is no legacy field to guard against.
+ */
+function expandDiscriminatedHook(policy, unifiedKey, discriminatorKey, valueA, slotA, legacyA, valueB, slotB, legacyB, filePath) {
+    const p = policy;
+    const hook = p[unifiedKey];
+    if (hook === undefined)
+        return;
+    if (typeof hook !== "object" || hook === null) {
+        throw new Error(`"${unifiedKey}" must be an object`);
+    }
+    const discriminator = hook[discriminatorKey];
+    if (discriminator !== valueA && discriminator !== valueB) {
+        throw new Error(`"${unifiedKey}.${discriminatorKey}" must be "${valueA}" or "${valueB}" (got ${JSON.stringify(discriminator)})`);
+    }
+    // Only guard the slot that matches the actual discriminator value.
+    if (discriminator === valueA &&
+        legacyA !== null &&
+        p[legacyA] !== undefined) {
+        throw new Error(`Cannot set both "${unifiedKey}" (${discriminatorKey}: "${valueA}") and "${legacyA}" — use ${unifiedKey} only.`);
+    }
+    if (discriminator === valueB &&
+        legacyB !== null &&
+        p[legacyB] !== undefined) {
+        throw new Error(`Cannot set both "${unifiedKey}" (${discriminatorKey}: "${valueB}") and "${legacyB}" — use ${unifiedKey} only.`);
+    }
+    const { [discriminatorKey]: _disc, ...rest } = hook;
+    const targetKey = discriminator === valueA ? slotA : slotB;
+    p[targetKey] = rest;
+    p[unifiedKey] = undefined;
+    // Deprecation warnings for pre-existing legacy fields (set before expansion).
+    // These are emitted after the expansion so callers can check the hadLegacy*
+    // flags they captured before calling this helper.
+    void filePath; // filePath passed through to callers for their warn messages
+}
+/** Load and validate a JSON automation policy file. Throws on any failure. */
+export function loadPolicy(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        throw new Error(`Failed to read automation policy file "${filePath}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse automation policy file "${filePath}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Automation policy must be a JSON object in "${filePath}"`);
+    }
+    const policy = parsed;
+    // ── onCompaction normalization (v2.43.0+) ───────────────────────────────
+    // Expand unified `onCompaction` into internal onPreCompact/onPostCompact.
+    // hadLegacy* captured BEFORE expansion so warn only for user-set values.
+    const hadLegacyPreCompact = policy.onPreCompact !== undefined;
+    const hadLegacyPostCompact = policy.onPostCompact !== undefined;
+    expandDiscriminatedHook(policy, "onCompaction", "phase", "pre", "onPreCompact", "onPreCompact", "post", "onPostCompact", "onPostCompact", filePath);
+    if (hadLegacyPreCompact) {
+        console.warn(`[automation-policy] "onPreCompact" in "${filePath}" is deprecated — migrate to "onCompaction" with phase: "pre". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    if (hadLegacyPostCompact) {
+        console.warn(`[automation-policy] "onPostCompact" in "${filePath}" is deprecated — migrate to "onCompaction" with phase: "post". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    // ── onDiagnosticsStateChange normalization (v2.43.0+) ───────────────────
+    // Expand into internal onDiagnosticsError/onDiagnosticsCleared based on state.
+    const hadLegacyDiagError = policy.onDiagnosticsError !== undefined;
+    const hadLegacyDiagCleared = policy.onDiagnosticsCleared !== undefined;
+    expandDiscriminatedHook(policy, "onDiagnosticsStateChange", "state", "error", "onDiagnosticsError", "onDiagnosticsError", "cleared", "onDiagnosticsCleared", "onDiagnosticsCleared", filePath);
+    if (hadLegacyDiagError) {
+        console.warn(`[automation-policy] "onDiagnosticsError" in "${filePath}" is deprecated — migrate to "onDiagnosticsStateChange" with state: "error". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    if (hadLegacyDiagCleared) {
+        console.warn(`[automation-policy] "onDiagnosticsCleared" in "${filePath}" is deprecated — migrate to "onDiagnosticsStateChange" with state: "cleared". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    // ── onDebugSession normalization (v2.43.0+) ─────────────────────────────
+    // Expand into internal onDebugSessionStart/onDebugSessionEnd based on phase.
+    const hadLegacyDebugStart = policy.onDebugSessionStart !== undefined;
+    const hadLegacyDebugEnd = policy.onDebugSessionEnd !== undefined;
+    expandDiscriminatedHook(policy, "onDebugSession", "phase", "start", "onDebugSessionStart", "onDebugSessionStart", "end", "onDebugSessionEnd", "onDebugSessionEnd", filePath);
+    if (hadLegacyDebugStart) {
+        console.warn(`[automation-policy] "onDebugSessionStart" in "${filePath}" is deprecated — migrate to "onDebugSession" with phase: "start". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    if (hadLegacyDebugEnd) {
+        console.warn(`[automation-policy] "onDebugSessionEnd" in "${filePath}" is deprecated — migrate to "onDebugSession" with phase: "end". Legacy name removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    // ── onTestRun(filter) normalization (v2.43.0+) ──────────────────────────
+    // The new canonical form is `onTestRun.filter: "any"|"failure"|"pass-after-fail"`.
+    // - "any" / "failure" rewrite to onFailureOnly:false/true on the same hook.
+    // - "pass-after-fail" is routed into the onTestPassAfterFailure slot (a
+    //   separate internal hook with its own dispatch path).
+    // Legacy `onFailureOnly` field + legacy `onTestPassAfterFailure` hook still
+    // work but warn at load time.
+    const hadLegacyOnFailureOnly = policy.onTestRun !== undefined &&
+        policy.onTestRun.onFailureOnly !==
+            undefined;
+    const hadLegacyTestPassAfterFailure = policy.onTestPassAfterFailure !== undefined;
+    if (policy.onTestRun !== undefined &&
+        typeof policy.onTestRun === "object" &&
+        policy.onTestRun !== null) {
+        const tr = policy.onTestRun;
+        if (tr.filter !== undefined) {
+            if (tr.filter !== "any" &&
+                tr.filter !== "failure" &&
+                tr.filter !== "pass-after-fail") {
+                throw new Error(`"onTestRun.filter" must be one of "any", "failure", "pass-after-fail" (got ${JSON.stringify(tr.filter)})`);
+            }
+            if (tr.onFailureOnly !== undefined) {
+                throw new Error(`Cannot set both "onTestRun.filter" and "onTestRun.onFailureOnly" — use "filter" only.`);
+            }
+            if (tr.filter === "pass-after-fail") {
+                if (hadLegacyTestPassAfterFailure) {
+                    throw new Error(`Cannot set both "onTestRun" (filter: "pass-after-fail") and legacy "onTestPassAfterFailure" — use onTestRun.filter only.`);
+                }
+                const { filter: _f, onFailureOnly: _ofo, ...rest } = tr;
+                policy.onTestPassAfterFailure =
+                    rest;
+                policy.onTestRun = undefined;
+            }
+            else {
+                tr.onFailureOnly = tr.filter === "failure";
+                tr.filter = undefined;
+            }
+        }
+    }
+    if (hadLegacyOnFailureOnly) {
+        console.warn(`[automation-policy] "onTestRun.onFailureOnly" in "${filePath}" is deprecated — migrate to "onTestRun.filter" ("failure" or "any"). Legacy field removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    if (hadLegacyTestPassAfterFailure) {
+        console.warn(`[automation-policy] "onTestPassAfterFailure" in "${filePath}" is deprecated — migrate to "onTestRun" with filter: "pass-after-fail". Legacy hook removed no earlier than v2.46 + 30 days after v2.43.0 release.`);
+    }
+    // Helper: throw with actual value in message for easier debugging
+    function expectType(value, type, field) {
+        if (typeof value !== type) {
+            throw new Error(`"${field}" must be ${type} (got ${typeof value}: ${JSON.stringify(value)})`);
+        }
+    }
+    // Validate top-level fields
+    if (policy.defaultModel !== undefined &&
+        typeof policy.defaultModel !== "string") {
+        throw new Error(`"defaultModel" must be a string`);
+    }
+    if (policy.maxTasksPerHour !== undefined) {
+        if (typeof policy.maxTasksPerHour !== "number" ||
+            !Number.isInteger(policy.maxTasksPerHour) ||
+            policy.maxTasksPerHour < 0) {
+            throw new Error(`"maxTasksPerHour" must be a non-negative integer`);
+        }
+    }
+    if (policy.automationSystemPrompt !== undefined) {
+        if (typeof policy.automationSystemPrompt !== "string") {
+            throw new Error(`"automationSystemPrompt" must be a string`);
+        }
+        if (policy.automationSystemPrompt.length > 4096) {
+            throw new Error(`"automationSystemPrompt" must be ≤ 4096 characters`);
+        }
+    }
+    if (policy.defaultEffort !== undefined) {
+        if (!["low", "medium", "high", "max"].includes(policy.defaultEffort)) {
+            throw new Error(`"defaultEffort" must be one of "low", "medium", "high", "max"`);
+        }
+    }
+    const HOOK_SUBJECT_KEY = {
+        onFileSave: "file",
+        onFileChanged: "file",
+        onGitCommit: "message",
+        onGitPush: "branch",
+        onGitPull: "branch",
+        onBranchCheckout: "branch",
+        onPullRequest: "title",
+        onTestPassAfterFailure: "runner",
+        onTaskCreated: "prompt",
+        onTaskSuccess: "output",
+        onPermissionDenied: "tool",
+        onDiagnosticsCleared: "file",
+        onCwdChanged: "cwd",
+        onPreCompact: "session",
+        onPostCompact: "session",
+        onTestRun: "runner",
+        onDebugSessionStart: "sessionName",
+        onDebugSessionEnd: "sessionName",
+    };
+    void HOOK_SUBJECT_KEY; // referenced by callers; kept for documentation
+    // Standard hooks: required cooldownMs, no extra fields
+    const STANDARD_HOOK_KEYS = [
+        "onTestPassAfterFailure",
+        "onGitCommit",
+        "onGitPush",
+        "onGitPull",
+        "onBranchCheckout",
+        "onPullRequest",
+        "onTaskCreated",
+        "onPermissionDenied",
+        "onDiagnosticsCleared",
+        "onTaskSuccess",
+        "onDebugSessionStart",
+        "onDebugSessionEnd",
+        "onCwdChanged",
+        "onPreCompact",
+        "onPostCompact",
+    ];
+    for (const key of STANDARD_HOOK_KEYS) {
+        const cfg = policy[key];
+        if (cfg === undefined)
+            continue;
+        if (typeof cfg !== "object" || cfg === null) {
+            throw new Error(`"${key}" must be an object`);
+        }
+        const rec = cfg;
+        if (typeof rec.enabled !== "boolean") {
+            throw new Error(`"${key}.enabled" must be a boolean`);
+        }
+        validatePromptSource(key, rec);
+        expectType(rec.cooldownMs, "number", `${key}.cooldownMs`);
+        if (!Number.isFinite(rec.cooldownMs)) {
+            throw new Error(`"${key}.cooldownMs" must be a finite number`);
+        }
+        rec.cooldownMs = Math.max(rec.cooldownMs, MIN_COOLDOWN_MS);
+    }
+    // ── Per-hook extras (after generic fold) ─────────────────────────────────
+    // Validate onDiagnosticsError (extra: minSeverity required, diagnosticTypes,
+    // dedupeByContent, dedupeContentCooldownMs)
+    if (policy.onDiagnosticsError !== undefined) {
+        const d = policy.onDiagnosticsError;
+        if (typeof d !== "object" || d === null) {
+            throw new Error(`"onDiagnosticsError" must be an object`);
+        }
+        if (typeof d.enabled !== "boolean") {
+            throw new Error(`"onDiagnosticsError.enabled" must be a boolean`);
+        }
+        if (d.minSeverity !== "error" && d.minSeverity !== "warning") {
+            throw new Error(`"onDiagnosticsError.minSeverity" must be "error" or "warning"`);
+        }
+        validatePromptSource("onDiagnosticsError", d);
+        expectType(d.cooldownMs, "number", "onDiagnosticsError.cooldownMs");
+        if (!Number.isFinite(d.cooldownMs)) {
+            throw new Error(`"onDiagnosticsError.cooldownMs" must be a finite number`);
+        }
+        d.cooldownMs = Math.max(d.cooldownMs, MIN_COOLDOWN_MS);
+        if (d.diagnosticTypes !== undefined) {
+            if (!Array.isArray(d.diagnosticTypes) ||
+                d.diagnosticTypes.length === 0 ||
+                !d.diagnosticTypes.every((t) => typeof t === "string")) {
+                throw new Error(`"onDiagnosticsError.diagnosticTypes" must be a non-empty array of strings`);
+            }
+        }
+        if (d.dedupeByContent !== undefined &&
+            typeof d.dedupeByContent !== "boolean") {
+            throw new Error(`"onDiagnosticsError.dedupeByContent" must be a boolean`);
+        }
+        if (d.dedupeContentCooldownMs !== undefined) {
+            if (typeof d.dedupeContentCooldownMs !== "number" ||
+                !Number.isFinite(d.dedupeContentCooldownMs)) {
+                throw new Error(`"onDiagnosticsError.dedupeContentCooldownMs" must be a number`);
+            }
+            d.dedupeContentCooldownMs = Math.max(d.dedupeContentCooldownMs, MIN_COOLDOWN_MS);
+        }
+    }
+    // Validate onFileSave (extra: patterns required)
+    if (policy.onFileSave !== undefined) {
+        const s = policy.onFileSave;
+        if (typeof s !== "object" || s === null) {
+            throw new Error(`"onFileSave" must be an object`);
+        }
+        if (typeof s.enabled !== "boolean") {
+            throw new Error(`"onFileSave.enabled" must be a boolean`);
+        }
+        if (!Array.isArray(s.patterns) ||
+            s.patterns.length > 100 ||
+            s.patterns.some((p) => typeof p !== "string" || p.length > 1024)) {
+            throw new Error("onFileSave.patterns must be an array of ≤100 strings, each ≤1024 chars");
+        }
+        validatePromptSource("onFileSave", s);
+        expectType(s.cooldownMs, "number", "onFileSave.cooldownMs");
+        if (!Number.isFinite(s.cooldownMs)) {
+            throw new Error(`"onFileSave.cooldownMs" must be a finite number`);
+        }
+        s.cooldownMs = Math.max(s.cooldownMs, MIN_COOLDOWN_MS);
+    }
+    // Validate onFileChanged (extra: patterns required)
+    if (policy.onFileChanged !== undefined) {
+        const fc = policy.onFileChanged;
+        if (typeof fc !== "object" || fc === null) {
+            throw new Error(`"onFileChanged" must be an object`);
+        }
+        if (typeof fc.enabled !== "boolean") {
+            throw new Error(`"onFileChanged.enabled" must be a boolean`);
+        }
+        if (!Array.isArray(fc.patterns) ||
+            fc.patterns.length > 100 ||
+            fc.patterns.some((p) => typeof p !== "string" || p.length > 1024)) {
+            throw new Error("onFileChanged.patterns must be an array of ≤100 strings, each ≤1024 chars");
+        }
+        validatePromptSource("onFileChanged", fc);
+        expectType(fc.cooldownMs, "number", "onFileChanged.cooldownMs");
+        if (!Number.isFinite(fc.cooldownMs)) {
+            throw new Error(`"onFileChanged.cooldownMs" must be a finite number`);
+        }
+        fc.cooldownMs = Math.max(fc.cooldownMs, MIN_COOLDOWN_MS);
+    }
+    // Validate onInstructionsLoaded (special: cooldownMs optional, min 5000)
+    if (policy.onInstructionsLoaded !== undefined) {
+        const il = policy.onInstructionsLoaded;
+        if (typeof il !== "object" || il === null) {
+            throw new Error(`"onInstructionsLoaded" must be an object`);
+        }
+        if (typeof il.enabled !== "boolean") {
+            throw new Error(`"onInstructionsLoaded.enabled" must be a boolean`);
+        }
+        if (il.cooldownMs !== undefined) {
+            if (typeof il.cooldownMs !== "number" || il.cooldownMs < 5000) {
+                throw new Error(`"onInstructionsLoaded.cooldownMs" must be a number >= 5000`);
+            }
+        }
+        validatePromptSource("onInstructionsLoaded", il);
+    }
+    // Validate onTestRun (extra: onFailureOnly required, minDuration optional)
+    if (policy.onTestRun !== undefined) {
+        const tr = policy.onTestRun;
+        if (typeof tr !== "object" || tr === null) {
+            throw new Error(`"onTestRun" must be an object`);
+        }
+        if (typeof tr.enabled !== "boolean") {
+            throw new Error(`"onTestRun.enabled" must be a boolean`);
+        }
+        // After C3 expansion, onFailureOnly is always populated (either by the
+        // filter rewrite or by user-provided legacy value). Accept missing as
+        // "failure" default for safety.
+        if (tr.onFailureOnly === undefined) {
+            tr.onFailureOnly = true;
+        }
+        else if (typeof tr.onFailureOnly !== "boolean") {
+            throw new Error(`"onTestRun.onFailureOnly" must be a boolean`);
+        }
+        validatePromptSource("onTestRun", tr);
+        expectType(tr.cooldownMs, "number", "onTestRun.cooldownMs");
+        if (!Number.isFinite(tr.cooldownMs)) {
+            throw new Error(`"onTestRun.cooldownMs" must be a finite number`);
+        }
+        tr.cooldownMs = Math.max(tr.cooldownMs, MIN_COOLDOWN_MS);
+        if (tr.minDuration !== undefined) {
+            if (typeof tr.minDuration !== "number" ||
+                !Number.isFinite(tr.minDuration) ||
+                tr.minDuration < 0) {
+                throw new Error(`"onTestRun.minDuration" must be a non-negative number`);
+            }
+        }
+    }
+    return policy;
+}
+/**
+ * CC hook events that require a settings.json entry calling a bridge notify tool.
+ * Bridge-tool-triggered hooks (onFileSave, onGitCommit, etc.) need no CC wiring.
+ */
+const CC_HOOK_TOOL_MAP = {
+    PreCompact: "notifyPreCompact",
+    PostCompact: "notifyPostCompact",
+    InstructionsLoaded: "notifyInstructionsLoaded",
+    TaskCreated: "notifyTaskCreated",
+    PermissionDenied: "notifyPermissionDenied",
+    CwdChanged: "notifyCwdChanged",
+};
+/** Policy hook names that correspond to CC hook events (need settings.json wiring). */
+const _POLICY_TO_CC_EVENT = {
+    onPreCompact: "PreCompact",
+    onPostCompact: "PostCompact",
+    onInstructionsLoaded: "InstructionsLoaded",
+    onTaskCreated: "TaskCreated",
+    onPermissionDenied: "PermissionDenied",
+    onCwdChanged: "CwdChanged",
+};
+/**
+ * Check which CC hook events have at least one settings.json entry whose
+ * command references the matching bridge notify tool. Returns a map of
+ * CC event name → wired (boolean).
+ */
+export function checkCcHookWiring() {
+    const result = {};
+    for (const ccEvent of Object.keys(CC_HOOK_TOOL_MAP)) {
+        result[ccEvent] = false;
+    }
+    try {
+        const configDir = process.env.CLAUDE_CONFIG_DIR ??
+            path.join(process.env.HOME ?? process.env.USERPROFILE ?? "~", ".claude");
+        const settingsPath = path.join(configDir, "settings.json");
+        const raw = fs.readFileSync(settingsPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const hooks = settings.hooks ?? {};
+        const commandMatches = (cmd, ccEvent, toolName) => typeof cmd === "string" &&
+            (cmd.includes(toolName) || cmd.includes(`notify ${ccEvent}`));
+        for (const [ccEvent, toolName] of Object.entries(CC_HOOK_TOOL_MAP)) {
+            const entries = hooks[ccEvent] ?? [];
+            result[ccEvent] = entries.some((e) => {
+                // New format: { matcher, hooks: [{ type, command }] }
+                if (e && Array.isArray(e.hooks)) {
+                    return e.hooks?.some((h) => commandMatches(h.command, ccEvent, toolName));
+                }
+                // Legacy flat format: { type, command }
+                return commandMatches(e.command, ccEvent, toolName);
+            });
+        }
+    }
+    catch {
+        // Settings file missing or unparseable — treat all as unwired
+    }
+    return result;
+}
+// ── AutomationHooks ───────────────────────────────────────────────────────────
+export class AutomationHooks {
+    policy;
+    log;
+    /** Compiled AST for the functional interpreter. Null if parse failed. */
+    _programAST = null;
+    /** Backend instance for the functional interpreter. */
+    _interpreterBackend = null;
+    /**
+     * Pure-value state holding cooldown timestamps, diagnostic error counts, and
+     * test outcomes.  Mutations go through the pure-function helpers from
+     * `src/fp/automationState.ts`; the class re-assigns `_automationState` on
+     * each "write" to maintain immutability semantics at the value level.
+     */
+    _automationState = EMPTY_AUTOMATION_STATE;
+    /** Accumulated skip counts keyed by hook name → reason. */
+    _skipCountsByHookAndReason = new Map();
+    /** Tracks previous error count per normalized file path for zero-transition detection. */
+    prevDiagnosticErrors = new Map();
+    /**
+     * Per-runner last outcome — used to detect fail→pass transitions for onTestPassAfterFailure.
+     * Key: runner name. Value: "pass" | "fail".
+     */
+    lastTestOutcomeByRunner = new Map();
+    _lastFiredAt = null;
+    /** Last interpreter run promise — allows tests to await completion. */
+    _lastRunPromise = Promise.resolve();
+    constructor(policy, orchestrator, log, _extensionClient, _workspace) {
+        this.policy = policy;
+        this.log = log;
+        // Phase 4: always initialise interpreter (primary path)
+        {
+            const parseResult = parsePolicy(policy);
+            if (parseResult.ok) {
+                this._programAST = parseResult.value;
+                this._interpreterBackend = new VsCodeBackend(orchestrator, {
+                    info: this.log.bind(this),
+                });
+            }
+            else {
+                this.log(`[automation] interpreter parse failed: ${parseResult.message}`);
+            }
+        }
+    }
+    async _runInterpreter(eventType, eventData) {
+        if (!this._programAST || !this._interpreterBackend)
+            return;
+        const ctx = {
+            state: this._automationState,
+            now: Date.now(),
+            eventType,
+            eventData,
+            backend: this._interpreterBackend,
+            log: this.log.bind(this),
+        };
+        const result = await executeAutomationPolicy(this._programAST, ctx);
+        if (result.ok) {
+            this._automationState = result.value.updatedState;
+            if (result.value.taskIds.length > 0) {
+                this.log(`[interpreter] ${eventType}: enqueued ${result.value.taskIds.length} task(s)`);
+            }
+            for (const s of result.value.skipped) {
+                this.log(`[interpreter] ${eventType}: skipped ${s.hook} — ${s.reason}`);
+                if (!this._skipCountsByHookAndReason.has(s.hook)) {
+                    this._skipCountsByHookAndReason.set(s.hook, new Map());
+                }
+                const byReason = this._skipCountsByHookAndReason.get(s.hook);
+                if (byReason) {
+                    byReason.set(s.reason, (byReason.get(s.reason) ?? 0) + 1);
+                }
+            }
+            for (const e of result.value.errors) {
+                this.log(`[interpreter] ${eventType}: error in ${e.hook} — ${e.message}`);
+            }
+        }
+        else {
+            this.log(`[interpreter] ${eventType}: interpreter error — ${result.message}`);
+        }
+    }
+    /**
+     * Returns a Promise that resolves once all in-flight interpreter runs finish.
+     * Useful in tests to await async side-effects before asserting on task counts.
+     */
+    async flush() {
+        await this._lastRunPromise;
+    }
+    /** Tear down the instance: nulls interpreter references. */
+    destroy() {
+        this._programAST = null;
+        this._interpreterBackend = null;
+    }
+    handleDiagnosticsChanged(file, diagnostics) {
+        const normalizedFile = path.resolve(file);
+        // Track error count for zero-transition detection (onDiagnosticsCleared)
+        const severityRankForClear = {
+            error: 2,
+            warning: 1,
+            info: 0,
+            information: 0,
+            hint: 0,
+        };
+        const currentErrorCount = diagnostics.filter((d) => (severityRankForClear[d.severity] ?? 0) >= 1).length;
+        const prevErrorCount = this.prevDiagnosticErrors.get(normalizedFile) ?? 0;
+        this.prevDiagnosticErrors.set(normalizedFile, currentErrorCount);
+        // FIFO cap to bound memory
+        if (this.prevDiagnosticErrors.size > 5_000) {
+            const oldest = this.prevDiagnosticErrors.keys().next().value;
+            if (oldest !== undefined)
+                this.prevDiagnosticErrors.delete(oldest);
+        }
+        // Feed interpreter state using severity numbers where lower = more severe
+        // (error=0, warning=1, info/hint=2+) matching automationState.ts / evaluateWhen convention.
+        const severityToNum = {
+            error: 0,
+            warning: 1,
+            info: 2,
+            information: 2,
+            hint: 3,
+        };
+        const maxSeverityNum = diagnostics.reduce((min, d) => {
+            const rank = severityToNum[d.severity] ?? 3;
+            return rank < min ? rank : min;
+        }, 4); // 4 = no diagnostics / below hint
+        this._automationState = setLatestDiagnostics(this._automationState, normalizedFile, maxSeverityNum, diagnostics.length);
+        // Build diagnostics text for {{diagnostics}} placeholder (capped at 20)
+        const diagsForPrompt = diagnostics.slice(0, 20);
+        const overflow = diagnostics.length - diagsForPrompt.length;
+        const diagnosticsText = diagsForPrompt
+            .map((d) => `[${d.severity}] ${d.message}${d.source ? ` (${d.source})` : ""}`)
+            .join("\n") + (overflow > 0 ? `\n… and ${overflow} more` : "");
+        // Collect source/code strings for diagnosticTypes filtering
+        const diagnosticSources = diagnostics
+            .flatMap((d) => [
+            d.source?.toLowerCase() ?? "",
+            String(d.code ?? "").toLowerCase(),
+        ])
+            .filter(Boolean)
+            .join(",");
+        const diagnosticSig = diagnosticSignature(diagnostics);
+        // Fire onDiagnosticsCleared if transitioning from non-zero → zero; chain
+        // the interpreter runs so flush() awaits both and state is updated correctly.
+        if (prevErrorCount > 0 && currentErrorCount === 0) {
+            this._lastRunPromise = this._runInterpreter("onDiagnosticsCleared", {
+                file: normalizedFile,
+            }).then(() => this._runInterpreter("onDiagnosticsError", {
+                file: normalizedFile,
+                diagnostics: diagnosticsText,
+                diagnosticSources,
+                diagnosticSig,
+                count: String(diagnostics.length),
+            }));
+        }
+        else {
+            this._lastRunPromise = this._runInterpreter("onDiagnosticsError", {
+                file: normalizedFile,
+                diagnostics: diagnosticsText,
+                diagnosticSources,
+                diagnosticSig,
+                count: String(diagnostics.length),
+            });
+        }
+    }
+    /**
+     * Called when Claude Code fires a CwdChanged hook (Claude Code 2.1.83+).
+     * Fires when CC's working directory changes — useful for re-snapshotting workspace context.
+     */
+    handleCwdChanged(newCwd) {
+        this._lastRunPromise = this._runInterpreter("onCwdChanged", {
+            cwd: newCwd,
+        });
+    }
+    /**
+     * Called when Claude Code fires a PreCompact hook.
+     * Fires the onPreCompact automation hook before context trimming — use to snapshot state or
+     * write a handoff note before Claude loses context.
+     */
+    handlePreCompact() {
+        this._lastRunPromise = this._runInterpreter("onPreCompact", {});
+    }
+    /**
+     * Called when Claude Code fires a PostCompact hook (Claude Code 2.1.76+).
+     * Re-enqueues the configured prompt so Claude can re-snapshot IDE state after losing context.
+     */
+    handlePostCompact() {
+        this._lastRunPromise = this._runInterpreter("onPostCompact", {});
+    }
+    /**
+     * Called when Claude Code fires an InstructionsLoaded hook (Claude Code 2.1.76+).
+     * Fires once per session; injects bridge status / tool capability summary at start.
+     */
+    handleInstructionsLoaded() {
+        this._lastRunPromise = this._runInterpreter("onInstructionsLoaded", {});
+    }
+    handleFileSaved(_id, type, file) {
+        if (type !== "save")
+            return;
+        const normalizedFile = path.resolve(file);
+        this._lastRunPromise = this._runInterpreter("onFileSave", {
+            file: normalizedFile,
+        });
+    }
+    /**
+     * Called when the VS Code extension reports a file-changed event (type === "change").
+     * Distinct from handleFileSaved — reacts to any editor buffer change, not just explicit saves.
+     * Useful for triggering tasks on unsaved edits (e.g. lint-as-you-type workflows).
+     */
+    handleFileChanged(_id, type, file) {
+        if (type !== "change")
+            return;
+        const normalizedFile = path.resolve(file);
+        this._lastRunPromise = this._runInterpreter("onFileChanged", {
+            file: normalizedFile,
+        });
+    }
+    /**
+     * Called after every runTests tool invocation completes.
+     * Triggers an automation task when tests fail (or on every run if onFailureOnly is false).
+     */
+    handleTestRun(result) {
+        const failureCount = result.summary.failed + result.summary.errored;
+        const current = failureCount === 0 ? "pass" : "fail";
+        // Update per-runner outcome state unconditionally so onTestPassAfterFailure
+        // can detect fail→pass transitions even when onTestRun is disabled/absent.
+        const passAfterFailRunners = [];
+        for (const runner of result.runners) {
+            const prev = this.lastTestOutcomeByRunner.get(runner);
+            this.lastTestOutcomeByRunner.set(runner, current);
+            // Feed interpreter state
+            this._automationState = setTestRunnerStatus(this._automationState, runner, current);
+            if (prev === "fail" && current === "pass") {
+                passAfterFailRunners.push(runner);
+            }
+        }
+        const testRunEventData = {
+            runner: result.runners.join(", ") || "",
+            failed: String(failureCount),
+            passed: String(result.summary.passed),
+            total: String(result.summary.total),
+            failures: JSON.stringify(result.failures.slice(0, 100)),
+            durationMs: String(result.summary.durationMs ?? ""),
+        };
+        // Chain interpreter runs so flush() awaits all of them and state is updated
+        // sequentially. If any runner had a fail→pass transition, run that first so
+        // its cooldown state is visible to subsequent runs within the same flush.
+        if (passAfterFailRunners.length > 0) {
+            let chain = Promise.resolve();
+            for (const runner of passAfterFailRunners) {
+                chain = chain.then(() => this._runInterpreter("onTestPassAfterFailure", { runner }));
+            }
+            this._lastRunPromise = chain.then(() => this._runInterpreter("onTestRun", testRunEventData));
+        }
+        else {
+            this._lastRunPromise = this._runInterpreter("onTestRun", testRunEventData);
+        }
+    }
+    /**
+     * Called after a successful gitCommit tool call.
+     * Fires the onGitCommit automation hook if configured.
+     */
+    async handleGitCommit(result) {
+        this._lastRunPromise = this._runInterpreter("onGitCommit", {
+            hash: result.hash,
+            branch: result.branch,
+            message: result.message,
+            count: String(result.count),
+            files: result.files.join(", "),
+        });
+    }
+    /**
+     * Called after a successful gitPush tool call.
+     * Fires the onGitPush automation hook if configured.
+     */
+    handleGitPush(result) {
+        this._lastRunPromise = this._runInterpreter("onGitPush", {
+            branch: result.branch,
+            remote: result.remote,
+            hash: result.hash,
+        });
+    }
+    /**
+     * Fires the onGitPull automation hook if configured.
+     */
+    handleGitPull(result) {
+        this._lastRunPromise = this._runInterpreter("onGitPull", {
+            branch: result.branch,
+            remote: result.remote,
+        });
+    }
+    /**
+     * Called after a successful gitCheckout tool call.
+     * Fires the onBranchCheckout automation hook if configured.
+     */
+    handleBranchCheckout(result) {
+        this._lastRunPromise = this._runInterpreter("onBranchCheckout", {
+            branch: result.branch,
+            previousBranch: result.previousBranch ?? "(detached HEAD)",
+            created: String(result.created),
+        });
+    }
+    /**
+     * Fires the onPullRequest automation hook if configured.
+     */
+    handlePullRequest(result) {
+        this._lastRunPromise = this._runInterpreter("onPullRequest", {
+            title: result.title,
+            url: result.url,
+            branch: result.branch,
+            number: result.number != null ? String(result.number) : "",
+        });
+    }
+    handleTaskCreated(result) {
+        this._lastRunPromise = this._runInterpreter("onTaskCreated", {
+            taskId: result.taskId,
+            prompt: result.prompt,
+        });
+    }
+    handlePermissionDenied(result) {
+        this._lastRunPromise = this._runInterpreter("onPermissionDenied", {
+            tool: result.tool,
+            reason: result.reason,
+        });
+    }
+    /**
+     * Fires the onDiagnosticsCleared hook when a file transitions from non-zero to zero errors.
+     * Called internally by handleDiagnosticsChanged.
+     */
+    handleDiagnosticsCleared(normalizedFile) {
+        this._lastRunPromise = this._runInterpreter("onDiagnosticsCleared", {
+            file: normalizedFile,
+            diagnosticSig: "",
+        });
+    }
+    /**
+     * Fires the onTaskSuccess hook when a Claude orchestrator task completes with status "done".
+     * Call from bridge.ts when a task transitions to done.
+     */
+    handleTaskSuccess(result) {
+        this._lastRunPromise = this._runInterpreter("onTaskSuccess", {
+            taskId: result.taskId,
+            output: result.output,
+        });
+    }
+    /**
+     * Called when a VS Code debug session ends (hasActiveSession transitions true→false).
+     * Fires the onDebugSessionEnd automation hook if configured.
+     */
+    async handleDebugSessionEnd(result) {
+        this._lastRunPromise = this._runInterpreter("onDebugSessionEnd", {
+            sessionName: result.sessionName,
+            sessionType: result.sessionType,
+        });
+    }
+    /**
+     * Called when a VS Code debug session starts (hasActiveSession transitions false→true).
+     * Fires the onDebugSessionStart automation hook if configured.
+     */
+    async handleDebugSessionStart(result) {
+        this._lastRunPromise = this._runInterpreter("onDebugSessionStart", {
+            sessionName: result.sessionName,
+            sessionType: result.sessionType,
+            breakpointCount: String(result.breakpointCount),
+            activeFile: result.activeFile,
+        });
+    }
+    /** Summary of automation policy for getBridgeStatus. */
+    getStatus() {
+        const p = this.policy;
+        const wiring = checkCcHookWiring();
+        const unwiredEnabledHooks = Object.entries(_POLICY_TO_CC_EVENT)
+            .filter(([policyKey, ccEvent]) => {
+            const hookCfg = p[policyKey];
+            return hookCfg?.enabled === true && wiring[ccEvent] === false;
+        })
+            .map(([policyKey]) => policyKey);
+        return {
+            onPreCompact: p.onPreCompact
+                ? {
+                    enabled: p.onPreCompact.enabled,
+                    cooldownMs: p.onPreCompact.cooldownMs,
+                }
+                : null,
+            onPostCompact: p.onPostCompact
+                ? {
+                    enabled: p.onPostCompact.enabled,
+                    cooldownMs: p.onPostCompact.cooldownMs,
+                }
+                : null,
+            onDiagnosticsError: p.onDiagnosticsError
+                ? { enabled: p.onDiagnosticsError.enabled }
+                : null,
+            onFileSave: p.onFileSave
+                ? {
+                    enabled: p.onFileSave.enabled,
+                    patternCount: p.onFileSave.patterns.length,
+                }
+                : null,
+            onFileChanged: p.onFileChanged
+                ? {
+                    enabled: p.onFileChanged.enabled,
+                    patternCount: p.onFileChanged.patterns.length,
+                }
+                : null,
+            onCwdChanged: p.onCwdChanged
+                ? {
+                    enabled: p.onCwdChanged.enabled,
+                    cooldownMs: p.onCwdChanged.cooldownMs,
+                }
+                : null,
+            onTestRun: p.onTestRun
+                ? {
+                    enabled: p.onTestRun.enabled,
+                    onFailureOnly: p.onTestRun.onFailureOnly ?? true,
+                    cooldownMs: p.onTestRun.cooldownMs,
+                }
+                : null,
+            onTestPassAfterFailure: p.onTestPassAfterFailure
+                ? {
+                    enabled: p.onTestPassAfterFailure.enabled,
+                    cooldownMs: p.onTestPassAfterFailure.cooldownMs,
+                }
+                : null,
+            onGitCommit: p.onGitCommit
+                ? {
+                    enabled: p.onGitCommit.enabled,
+                    cooldownMs: p.onGitCommit.cooldownMs,
+                }
+                : null,
+            onGitPush: p.onGitPush
+                ? {
+                    enabled: p.onGitPush.enabled,
+                    cooldownMs: p.onGitPush.cooldownMs,
+                }
+                : null,
+            onBranchCheckout: p.onBranchCheckout
+                ? {
+                    enabled: p.onBranchCheckout.enabled,
+                    cooldownMs: p.onBranchCheckout.cooldownMs,
+                }
+                : null,
+            onPullRequest: p.onPullRequest
+                ? {
+                    enabled: p.onPullRequest.enabled,
+                    cooldownMs: p.onPullRequest.cooldownMs,
+                }
+                : null,
+            onTaskCreated: p.onTaskCreated
+                ? {
+                    enabled: p.onTaskCreated.enabled,
+                    cooldownMs: p.onTaskCreated.cooldownMs,
+                }
+                : null,
+            onInstructionsLoaded: p.onInstructionsLoaded
+                ? {
+                    enabled: p.onInstructionsLoaded.enabled,
+                    cooldownMs: p.onInstructionsLoaded.cooldownMs ?? 60_000,
+                }
+                : null,
+            onPermissionDenied: p.onPermissionDenied
+                ? {
+                    enabled: p.onPermissionDenied.enabled,
+                    cooldownMs: p.onPermissionDenied.cooldownMs,
+                }
+                : null,
+            onDiagnosticsCleared: p.onDiagnosticsCleared
+                ? {
+                    enabled: p.onDiagnosticsCleared.enabled,
+                    cooldownMs: p.onDiagnosticsCleared.cooldownMs,
+                }
+                : null,
+            onTaskSuccess: p.onTaskSuccess
+                ? {
+                    enabled: p.onTaskSuccess.enabled,
+                    cooldownMs: p.onTaskSuccess.cooldownMs,
+                }
+                : null,
+            onGitPull: p.onGitPull
+                ? {
+                    enabled: p.onGitPull.enabled,
+                    cooldownMs: p.onGitPull.cooldownMs,
+                }
+                : null,
+            onDebugSessionEnd: p.onDebugSessionEnd
+                ? {
+                    enabled: p.onDebugSessionEnd.enabled,
+                    cooldownMs: p.onDebugSessionEnd.cooldownMs,
+                }
+                : null,
+            onDebugSessionStart: p.onDebugSessionStart
+                ? {
+                    enabled: p.onDebugSessionStart.enabled,
+                    cooldownMs: p.onDebugSessionStart.cooldownMs,
+                }
+                : null,
+            unwiredEnabledHooks,
+            defaultModel: p.defaultModel ?? "claude-haiku-4-5-20251001",
+            maxTasksPerHour: p.maxTasksPerHour ?? 20,
+            tasksThisHour: tasksInLastHour(this._automationState, Date.now()),
+            defaultEffort: p.defaultEffort ?? "low",
+            automationSystemPrompt: (p.automationSystemPrompt ?? DEFAULT_AUTOMATION_SYSTEM_PROMPT).slice(0, 80),
+        };
+    }
+    isPreCompactEnabled() {
+        return this.policy.onPreCompact?.enabled === true;
+    }
+    getStats() {
+        const hookKeys = [
+            "onFileSave",
+            "onFileChanged",
+            "onDiagnosticsError",
+            "onDiagnosticsCleared",
+            "onPreCompact",
+            "onPostCompact",
+            "onInstructionsLoaded",
+            "onBranchCheckout",
+            "onGitCommit",
+            "onGitPull",
+            "onGitPush",
+            "onPullRequest",
+            "onTestRun",
+            "onTestPassAfterFailure",
+            "onPermissionDenied",
+            "onCwdChanged",
+            "onTaskCreated",
+            "onTaskSuccess",
+            "onDebugSessionStart",
+            "onDebugSessionEnd",
+        ];
+        const hooksEnabled = hookKeys.filter((k) => {
+            const hook = this.policy[k];
+            return hook !== undefined && hook.enabled !== false;
+        }).length;
+        // Convert skipCountsByHookAndReason Map to plain object
+        const skipCountsByHookAndReason = {};
+        for (const [hook, reasons] of this._skipCountsByHookAndReason) {
+            skipCountsByHookAndReason[hook] = Object.fromEntries(reasons);
+        }
+        return {
+            hooksEnabled,
+            lastFiredAt: this._lastFiredAt,
+            skipCountsByHookAndReason: Object.keys(skipCountsByHookAndReason).length > 0
+                ? skipCountsByHookAndReason
+                : undefined,
+        };
+    }
+}
+//# sourceMappingURL=automation.js.map