@mauribadnights/clooks 0.2.0 → 0.3.0

package/dist/deps.js

@@ -0,0 +1,83 @@
+"use strict";
+// clooks dependency resolution — topological ordering of handler execution
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExecutionOrder = resolveExecutionOrder;
+/**
+ * Build a directed acyclic graph from handler dependencies.
+ * Returns handlers grouped into "waves" — each wave contains handlers
+ * that can execute in parallel (all their deps are in previous waves).
+ *
+ * Wave 0: handlers with no deps
+ * Wave 1: handlers whose deps are all in wave 0
+ * etc.
+ *
+ * Uses Kahn's algorithm. Throws on cycles.
+ */
+function resolveExecutionOrder(handlers) {
+    if (handlers.length === 0)
+        return [];
+    // Build lookup and adjacency
+    const handlerMap = new Map();
+    const inDegree = new Map();
+    const dependents = new Map(); // depId → [handlers that depend on it]
+    for (const h of handlers) {
+        handlerMap.set(h.id, h);
+        inDegree.set(h.id, 0);
+        if (!dependents.has(h.id)) {
+            dependents.set(h.id, []);
+        }
+    }
+    // Only consider deps that reference handlers in this set
+    const handlerIds = new Set(handlers.map(h => h.id));
+    for (const h of handlers) {
+        if (!h.depends || h.depends.length === 0)
+            continue;
+        for (const dep of h.depends) {
+            if (!handlerIds.has(dep)) {
+                // Dependency references a handler not in this event's set — skip silently
+                // (cross-event deps are not supported within a single executeHandlers call)
+                continue;
+            }
+            inDegree.set(h.id, (inDegree.get(h.id) ?? 0) + 1);
+            const existing = dependents.get(dep) ?? [];
+            existing.push(h.id);
+            dependents.set(dep, existing);
+        }
+    }
+    // BFS — Kahn's algorithm, collecting waves
+    const waves = [];
+    let queue = [];
+    // Wave 0: all handlers with in-degree 0
+    for (const [id, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(id);
+        }
+    }
+    let processedCount = 0;
+    while (queue.length > 0) {
+        const wave = [];
+        const nextQueue = [];
+        for (const id of queue) {
+            wave.push(handlerMap.get(id));
+            processedCount++;
+            // Decrement in-degree of dependents
+            for (const depId of dependents.get(id) ?? []) {
+                const newDegree = (inDegree.get(depId) ?? 1) - 1;
+                inDegree.set(depId, newDegree);
+                if (newDegree === 0) {
+                    nextQueue.push(depId);
+                }
+            }
+        }
+        waves.push(wave);
+        queue = nextQueue;
+    }
+    // Cycle detection: if not all handlers were processed, there's a cycle
+    if (processedCount < handlers.length) {
+        const cycleIds = handlers
+            .filter(h => (inDegree.get(h.id) ?? 0) > 0)
+            .map(h => h.id);
+        throw new Error(`Dependency cycle detected among handlers: ${cycleIds.join(', ')}`);
+    }
+    return waves;
+}

package/dist/doctor.js

@@ -10,6 +10,8 @@ const os_1 = require("os");
 const constants_js_1 = require("./constants.js");
 const manifest_js_1 = require("./manifest.js");
 const server_js_1 = require("./server.js");
+const plugin_js_1 = require("./plugin.js");
+const yaml_1 = require("yaml");
 /**
  * Run all diagnostic checks and return results.
  */
@@ -29,6 +31,10 @@ async function runDoctor() {
     results.push(checkSettingsHooks());
     // 7. No stale PID file
     results.push(checkStalePid());
+    // 8. Auth token consistency (if configured)
+    results.push(checkAuthToken());
+    // 9. Plugin health checks
+    results.push(...checkPluginHealth());
     return results;
 }
 function checkConfigDir() {
@@ -166,3 +172,107 @@ function checkStalePid() {
         return { check: 'Stale PID', status: 'error', message: `Stale PID file: process ${pid} is dead. Remove ${constants_js_1.PID_FILE} or run "clooks start".` };
     }
 }
+function checkAuthToken() {
+    try {
+        const manifest = (0, manifest_js_1.loadManifest)();
+        const authToken = manifest.settings?.authToken;
+        if (!authToken) {
+            return { check: 'Auth token', status: 'ok', message: 'No auth token configured (open access)' };
+        }
+        // Check that settings.json hooks include matching Authorization header
+        const candidates = [
+            (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.local.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json'),
+        ];
+        for (const path of candidates) {
+            if (!(0, fs_1.existsSync)(path))
+                continue;
+            try {
+                const raw = (0, fs_1.readFileSync)(path, 'utf-8');
+                const settings = JSON.parse(raw);
+                if (!settings.hooks)
+                    continue;
+                const expectedHeader = `Bearer ${authToken}`;
+                const httpHooks = [];
+                for (const ruleGroups of Object.values(settings.hooks)) {
+                    for (const rule of ruleGroups) {
+                        if (!Array.isArray(rule.hooks))
+                            continue;
+                        for (const hook of rule.hooks) {
+                            if (hook.type === 'http' && hook.url?.includes(`localhost:${constants_js_1.DEFAULT_PORT}`)) {
+                                httpHooks.push(hook);
+                            }
+                        }
+                    }
+                }
+                if (httpHooks.length === 0) {
+                    return { check: 'Auth token', status: 'warn', message: 'Auth token set but no HTTP hooks found in settings.json' };
+                }
+                const missingAuth = httpHooks.filter(h => h.headers?.['Authorization'] !== expectedHeader);
+                if (missingAuth.length > 0) {
+                    return { check: 'Auth token', status: 'error', message: `Auth token set but ${missingAuth.length} HTTP hook(s) missing matching Authorization header. Run "clooks migrate".` };
+                }
+                return { check: 'Auth token', status: 'ok', message: 'Auth token matches settings.json hook headers' };
+            }
+            catch {
+                continue;
+            }
+        }
+        return { check: 'Auth token', status: 'warn', message: 'Auth token set but could not verify settings.json headers' };
+    }
+    catch {
+        return { check: 'Auth token', status: 'ok', message: 'Could not load manifest for auth check' };
+    }
+}
+function checkPluginHealth() {
+    const results = [];
+    try {
+        const registry = (0, plugin_js_1.loadRegistry)();
+        if (registry.plugins.length === 0) {
+            results.push({ check: 'Plugins', status: 'ok', message: 'No plugins installed' });
+            return results;
+        }
+        for (const plugin of registry.plugins) {
+            // Check directory exists
+            if (!(0, fs_1.existsSync)(plugin.path)) {
+                results.push({
+                    check: `Plugin "${plugin.name}"`,
+                    status: 'error',
+                    message: `Plugin directory missing: ${plugin.path}`,
+                });
+                continue;
+            }
+            // Check manifest exists and is valid
+            const manifestPath = (0, path_1.join)(plugin.path, constants_js_1.PLUGIN_MANIFEST_NAME);
+            if (!(0, fs_1.existsSync)(manifestPath)) {
+                results.push({
+                    check: `Plugin "${plugin.name}"`,
+                    status: 'error',
+                    message: `Plugin manifest missing: ${manifestPath}`,
+                });
+                continue;
+            }
+            try {
+                const raw = (0, fs_1.readFileSync)(manifestPath, 'utf-8');
+                const parsed = (0, yaml_1.parse)(raw);
+                (0, plugin_js_1.validatePluginManifest)(parsed);
+                results.push({
+                    check: `Plugin "${plugin.name}"`,
+                    status: 'ok',
+                    message: `v${plugin.version} — manifest valid`,
+                });
+            }
+            catch (err) {
+                results.push({
+                    check: `Plugin "${plugin.name}"`,
+                    status: 'error',
+                    message: `Invalid manifest: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        }
+    }
+    catch {
+        results.push({ check: 'Plugins', status: 'ok', message: 'Could not load plugin registry' });
+    }
+    return results;
+}

package/dist/handlers.d.ts

@@ -3,10 +3,18 @@ import type { HandlerConfig, HandlerResult, HandlerState, HookEvent, HookInput,
 export declare function resetHandlerStates(): void;
 /** Get a copy of the handler states map */
 export declare function getHandlerStates(): Map<string, HandlerState>;
+/** Clean up state for a specific handler ID (used during manifest reload diffs). */
+export declare function cleanupHandlerState(handlerId: string): void;
 /**
- * Execute all handlers for an event in parallel.
- * Returns merged results array.
- * Optionally accepts pre-fetched context for LLM prompt rendering.
+ * Reset handler states for handlers that have sessionIsolation: true.
+ * Called on SessionStart events.
+ */
+export declare function resetSessionIsolatedHandlers(handlers: HandlerConfig[]): void;
+/**
+ * Execute all handlers for an event, respecting dependency order.
+ * Handlers are grouped into "waves" via topological sort.
+ * Within each wave, handlers run in parallel.
+ * Outputs from previous waves are available to dependent handlers via _handlerOutputs.
  */
 export declare function executeHandlers(_event: HookEvent, input: HookInput, handlers: HandlerConfig[], context?: PrefetchContext): Promise<HandlerResult[]>;
 /**

package/dist/handlers.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetHandlerStates = resetHandlerStates;
 exports.getHandlerStates = getHandlerStates;
+exports.cleanupHandlerState = cleanupHandlerState;
+exports.resetSessionIsolatedHandlers = resetSessionIsolatedHandlers;
 exports.executeHandlers = executeHandlers;
 exports.executeScriptHandler = executeScriptHandler;
 exports.executeInlineHandler = executeInlineHandler;
@@ -12,6 +14,7 @@ const path_1 = require("path");
 const constants_js_1 = require("./constants.js");
 const filter_js_1 = require("./filter.js");
 const llm_js_1 = require("./llm.js");
+const deps_js_1 = require("./deps.js");
 /** Runtime state per handler ID */
 const handlerStates = new Map();
 function getState(id) {
@@ -30,18 +33,38 @@ function resetHandlerStates() {
 function getHandlerStates() {
     return new Map(handlerStates);
 }
+/** Clean up state for a specific handler ID (used during manifest reload diffs). */
+function cleanupHandlerState(handlerId) {
+    handlerStates.delete(handlerId);
+}
+/**
+ * Reset handler states for handlers that have sessionIsolation: true.
+ * Called on SessionStart events.
+ */
+function resetSessionIsolatedHandlers(handlers) {
+    for (const handler of handlers) {
+        if (handler.sessionIsolation) {
+            const state = handlerStates.get(handler.id);
+            if (state) {
+                state.consecutiveFailures = 0;
+                state.disabled = false;
+                state.totalFires = 0;
+                state.totalErrors = 0;
+            }
+        }
+    }
+}
 /**
- * Execute all handlers for an event in parallel.
- * Returns merged results array.
- * Optionally accepts pre-fetched context for LLM prompt rendering.
+ * Execute all handlers for an event, respecting dependency order.
+ * Handlers are grouped into "waves" via topological sort.
+ * Within each wave, handlers run in parallel.
+ * Outputs from previous waves are available to dependent handlers via _handlerOutputs.
  */
 async function executeHandlers(_event, input, handlers, context) {
-    // Separate LLM handlers from script/inline, applying shared pre-checks
-    const llmHandlers = [];
-    const otherPromises = [];
+    // Pre-check: filter out disabled/auto-disabled/filtered handlers before dep resolution
+    const eligible = [];
     const skippedResults = [];
     for (const handler of handlers) {
-        // Skip disabled handlers (both manifest-disabled and auto-disabled)
         if (handler.enabled === false) {
             skippedResults.push({ id: handler.id, ok: true, output: undefined, duration_ms: 0 });
             continue;
@@ -56,7 +79,6 @@ async function executeHandlers(_event, input, handlers, context) {
             });
             continue;
         }
-        // Evaluate keyword filter before execution
         if (handler.filter) {
             const inputStr = JSON.stringify(input);
             if (!(0, filter_js_1.evaluateFilter)(handler.filter, inputStr)) {
@@ -70,51 +92,82 @@ async function executeHandlers(_event, input, handlers, context) {
                 continue;
             }
         }
-        state.totalFires++;
-        if (handler.type === 'llm') {
-            llmHandlers.push(handler);
-        }
-        else {
-            // Execute script/inline handlers in parallel
-            otherPromises.push(executeOtherHandler(handler, input));
-        }
+        eligible.push(handler);
+    }
+    if (eligible.length === 0) {
+        return skippedResults;
+    }
+    // Resolve execution order into waves
+    let waves;
+    try {
+        waves = (0, deps_js_1.resolveExecutionOrder)(eligible);
     }
-    // Execute script/inline handlers in parallel
-    const otherResults = otherPromises.length > 0
-        ? await Promise.all(otherPromises)
-        : [];
-    // Execute LLM handlers with batching (graceful — never crashes)
-    let llmResults = [];
-    if (llmHandlers.length > 0) {
-        try {
-            llmResults = await (0, llm_js_1.executeLLMHandlersBatched)(llmHandlers, input, context ?? {});
+    catch {
+        // If dep resolution fails, fall back to flat parallel execution
+        waves = [eligible];
+    }
+    const allResults = [...skippedResults];
+    const handlerOutputs = {};
+    for (const wave of waves) {
+        // Mark totalFires for all handlers in this wave
+        for (const handler of wave) {
+            getState(handler.id).totalFires++;
         }
-        catch (err) {
-            // Graceful degradation: if LLM execution entirely fails, return error results
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            llmResults = llmHandlers.map(h => ({
-                id: h.id,
-                ok: false,
-                error: `LLM execution failed: ${errorMsg}`,
-                duration_ms: 0,
-            }));
+        // Build input with _handlerOutputs from previous waves
+        const waveInput = Object.keys(handlerOutputs).length > 0
+            ? { ...input, _handlerOutputs: handlerOutputs }
+            : input;
+        // Separate LLM from script/inline within this wave
+        const llmHandlers = [];
+        const otherPromises = [];
+        for (const handler of wave) {
+            if (handler.type === 'llm') {
+                llmHandlers.push(handler);
+            }
+            else {
+                otherPromises.push(executeOtherHandler(handler, waveInput));
+            }
         }
-    }
-    // Update failure tracking for all executed results
-    for (const result of [...otherResults, ...llmResults]) {
-        const state = getState(result.id);
-        if (result.ok) {
-            state.consecutiveFailures = 0;
+        // Execute script/inline handlers in parallel
+        const otherResults = otherPromises.length > 0
+            ? await Promise.all(otherPromises)
+            : [];
+        // Execute LLM handlers with batching (scoped to this wave)
+        let llmResults = [];
+        if (llmHandlers.length > 0) {
+            try {
+                llmResults = await (0, llm_js_1.executeLLMHandlersBatched)(llmHandlers, waveInput, context ?? {}, input.session_id);
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                llmResults = llmHandlers.map(h => ({
+                    id: h.id,
+                    ok: false,
+                    error: `LLM execution failed: ${errorMsg}`,
+                    duration_ms: 0,
+                }));
+            }
         }
-        else {
-            state.consecutiveFailures++;
-            state.totalErrors++;
-            if (state.consecutiveFailures >= constants_js_1.MAX_CONSECUTIVE_FAILURES) {
-                state.disabled = true;
+        const waveResults = [...otherResults, ...llmResults];
+        // Update failure tracking and collect outputs for dependents
+        for (const result of waveResults) {
+            const state = getState(result.id);
+            if (result.ok) {
+                state.consecutiveFailures = 0;
+            }
+            else {
+                state.consecutiveFailures++;
+                state.totalErrors++;
+                if (state.consecutiveFailures >= constants_js_1.MAX_CONSECUTIVE_FAILURES) {
+                    state.disabled = true;
+                }
             }
+            // Store output for downstream handlers
+            handlerOutputs[result.id] = result.output;
         }
+        allResults.push(...waveResults);
     }
-    return [...skippedResults, ...otherResults, ...llmResults];
+    return allResults;
 }
 /**
  * Execute a single script or inline handler with error handling.

package/dist/index.d.ts

@@ -1,12 +1,19 @@
 export { createServer, startDaemon, stopDaemon, isDaemonRunning } from './server.js';
-export { loadManifest, validateManifest, createDefaultManifest } from './manifest.js';
+export { loadManifest, loadCompositeManifest, validateManifest, createDefaultManifest } from './manifest.js';
+export { loadPlugins, mergeManifests, validatePluginManifest, loadRegistry, saveRegistry, installPlugin, uninstallPlugin, listPlugins } from './plugin.js';
 export { MetricsCollector } from './metrics.js';
 export { migrate, restore, getSettingsPath } from './migrate.js';
 export type { MigratePathOptions } from './migrate.js';
 export { runDoctor } from './doctor.js';
-export { executeHandlers } from './handlers.js';
+export { executeHandlers, resetSessionIsolatedHandlers, cleanupHandlerState } from './handlers.js';
+export { resolveExecutionOrder } from './deps.js';
+export { DenyCache } from './shortcircuit.js';
+export { RateLimiter } from './ratelimit.js';
+export { startWatcher, stopWatcher } from './watcher.js';
+export { generateAuthToken, validateAuth, rotateToken } from './auth.js';
+export type { RotateTokenOptions } from './auth.js';
 export { evaluateFilter } from './filter.js';
 export { executeLLMHandler, executeLLMHandlersBatched, calculateCost, resetClient } from './llm.js';
 export { prefetchContext, renderPromptTemplate } from './prefetch.js';
-export { DEFAULT_PORT, CONFIG_DIR, MANIFEST_PATH, PID_FILE, METRICS_FILE, LOG_FILE, COSTS_FILE, DEFAULT_LLM_TIMEOUT, DEFAULT_LLM_MAX_TOKENS, LLM_PRICING } from './constants.js';
-export type { HookEvent, HookInput, HandlerType, HandlerConfig, ScriptHandlerConfig, InlineHandlerConfig, LLMHandlerConfig, LLMModel, Manifest, HandlerResult, MetricEntry, HandlerState, DiagnosticResult, PrefetchKey, PrefetchContext, TokenUsage, CostEntry, } from './types.js';
+export { DEFAULT_PORT, CONFIG_DIR, MANIFEST_PATH, PID_FILE, METRICS_FILE, LOG_FILE, COSTS_FILE, DEFAULT_LLM_TIMEOUT, DEFAULT_LLM_MAX_TOKENS, LLM_PRICING, PLUGINS_DIR, PLUGIN_REGISTRY, PLUGIN_MANIFEST_NAME } from './constants.js';
+export type { HookEvent, HookInput, HandlerType, HandlerConfig, ScriptHandlerConfig, InlineHandlerConfig, LLMHandlerConfig, LLMModel, Manifest, HandlerResult, MetricEntry, HandlerState, DiagnosticResult, PrefetchKey, PrefetchContext, TokenUsage, CostEntry, PluginManifest, InstalledPlugin, PluginRegistry, } from './types.js';

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 // clooks — public API exports
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLM_PRICING = exports.DEFAULT_LLM_MAX_TOKENS = exports.DEFAULT_LLM_TIMEOUT = exports.COSTS_FILE = exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = exports.renderPromptTemplate = exports.prefetchContext = exports.resetClient = exports.calculateCost = exports.executeLLMHandlersBatched = exports.executeLLMHandler = exports.evaluateFilter = exports.executeHandlers = exports.runDoctor = exports.getSettingsPath = exports.restore = exports.migrate = exports.MetricsCollector = exports.createDefaultManifest = exports.validateManifest = exports.loadManifest = exports.isDaemonRunning = exports.stopDaemon = exports.startDaemon = exports.createServer = void 0;
+exports.PLUGINS_DIR = exports.LLM_PRICING = exports.DEFAULT_LLM_MAX_TOKENS = exports.DEFAULT_LLM_TIMEOUT = exports.COSTS_FILE = exports.LOG_FILE = exports.METRICS_FILE = exports.PID_FILE = exports.MANIFEST_PATH = exports.CONFIG_DIR = exports.DEFAULT_PORT = exports.renderPromptTemplate = exports.prefetchContext = exports.resetClient = exports.calculateCost = exports.executeLLMHandlersBatched = exports.executeLLMHandler = exports.evaluateFilter = exports.rotateToken = exports.validateAuth = exports.generateAuthToken = exports.stopWatcher = exports.startWatcher = exports.RateLimiter = exports.DenyCache = exports.resolveExecutionOrder = exports.cleanupHandlerState = exports.resetSessionIsolatedHandlers = exports.executeHandlers = exports.runDoctor = exports.getSettingsPath = exports.restore = exports.migrate = exports.MetricsCollector = exports.listPlugins = exports.uninstallPlugin = exports.installPlugin = exports.saveRegistry = exports.loadRegistry = exports.validatePluginManifest = exports.mergeManifests = exports.loadPlugins = exports.createDefaultManifest = exports.validateManifest = exports.loadCompositeManifest = exports.loadManifest = exports.isDaemonRunning = exports.stopDaemon = exports.startDaemon = exports.createServer = void 0;
+exports.PLUGIN_MANIFEST_NAME = exports.PLUGIN_REGISTRY = void 0;
 var server_js_1 = require("./server.js");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_js_1.createServer; } });
 Object.defineProperty(exports, "startDaemon", { enumerable: true, get: function () { return server_js_1.startDaemon; } });
@@ -9,8 +10,18 @@ Object.defineProperty(exports, "stopDaemon", { enumerable: true, get: function (
 Object.defineProperty(exports, "isDaemonRunning", { enumerable: true, get: function () { return server_js_1.isDaemonRunning; } });
 var manifest_js_1 = require("./manifest.js");
 Object.defineProperty(exports, "loadManifest", { enumerable: true, get: function () { return manifest_js_1.loadManifest; } });
+Object.defineProperty(exports, "loadCompositeManifest", { enumerable: true, get: function () { return manifest_js_1.loadCompositeManifest; } });
 Object.defineProperty(exports, "validateManifest", { enumerable: true, get: function () { return manifest_js_1.validateManifest; } });
 Object.defineProperty(exports, "createDefaultManifest", { enumerable: true, get: function () { return manifest_js_1.createDefaultManifest; } });
+var plugin_js_1 = require("./plugin.js");
+Object.defineProperty(exports, "loadPlugins", { enumerable: true, get: function () { return plugin_js_1.loadPlugins; } });
+Object.defineProperty(exports, "mergeManifests", { enumerable: true, get: function () { return plugin_js_1.mergeManifests; } });
+Object.defineProperty(exports, "validatePluginManifest", { enumerable: true, get: function () { return plugin_js_1.validatePluginManifest; } });
+Object.defineProperty(exports, "loadRegistry", { enumerable: true, get: function () { return plugin_js_1.loadRegistry; } });
+Object.defineProperty(exports, "saveRegistry", { enumerable: true, get: function () { return plugin_js_1.saveRegistry; } });
+Object.defineProperty(exports, "installPlugin", { enumerable: true, get: function () { return plugin_js_1.installPlugin; } });
+Object.defineProperty(exports, "uninstallPlugin", { enumerable: true, get: function () { return plugin_js_1.uninstallPlugin; } });
+Object.defineProperty(exports, "listPlugins", { enumerable: true, get: function () { return plugin_js_1.listPlugins; } });
 var metrics_js_1 = require("./metrics.js");
 Object.defineProperty(exports, "MetricsCollector", { enumerable: true, get: function () { return metrics_js_1.MetricsCollector; } });
 var migrate_js_1 = require("./migrate.js");
@@ -21,6 +32,21 @@ var doctor_js_1 = require("./doctor.js");
 Object.defineProperty(exports, "runDoctor", { enumerable: true, get: function () { return doctor_js_1.runDoctor; } });
 var handlers_js_1 = require("./handlers.js");
 Object.defineProperty(exports, "executeHandlers", { enumerable: true, get: function () { return handlers_js_1.executeHandlers; } });
+Object.defineProperty(exports, "resetSessionIsolatedHandlers", { enumerable: true, get: function () { return handlers_js_1.resetSessionIsolatedHandlers; } });
+Object.defineProperty(exports, "cleanupHandlerState", { enumerable: true, get: function () { return handlers_js_1.cleanupHandlerState; } });
+var deps_js_1 = require("./deps.js");
+Object.defineProperty(exports, "resolveExecutionOrder", { enumerable: true, get: function () { return deps_js_1.resolveExecutionOrder; } });
+var shortcircuit_js_1 = require("./shortcircuit.js");
+Object.defineProperty(exports, "DenyCache", { enumerable: true, get: function () { return shortcircuit_js_1.DenyCache; } });
+var ratelimit_js_1 = require("./ratelimit.js");
+Object.defineProperty(exports, "RateLimiter", { enumerable: true, get: function () { return ratelimit_js_1.RateLimiter; } });
+var watcher_js_1 = require("./watcher.js");
+Object.defineProperty(exports, "startWatcher", { enumerable: true, get: function () { return watcher_js_1.startWatcher; } });
+Object.defineProperty(exports, "stopWatcher", { enumerable: true, get: function () { return watcher_js_1.stopWatcher; } });
+var auth_js_1 = require("./auth.js");
+Object.defineProperty(exports, "generateAuthToken", { enumerable: true, get: function () { return auth_js_1.generateAuthToken; } });
+Object.defineProperty(exports, "validateAuth", { enumerable: true, get: function () { return auth_js_1.validateAuth; } });
+Object.defineProperty(exports, "rotateToken", { enumerable: true, get: function () { return auth_js_1.rotateToken; } });
 var filter_js_1 = require("./filter.js");
 Object.defineProperty(exports, "evaluateFilter", { enumerable: true, get: function () { return filter_js_1.evaluateFilter; } });
 var llm_js_1 = require("./llm.js");
@@ -42,3 +68,6 @@ Object.defineProperty(exports, "COSTS_FILE", { enumerable: true, get: function (
 Object.defineProperty(exports, "DEFAULT_LLM_TIMEOUT", { enumerable: true, get: function () { return constants_js_1.DEFAULT_LLM_TIMEOUT; } });
 Object.defineProperty(exports, "DEFAULT_LLM_MAX_TOKENS", { enumerable: true, get: function () { return constants_js_1.DEFAULT_LLM_MAX_TOKENS; } });
 Object.defineProperty(exports, "LLM_PRICING", { enumerable: true, get: function () { return constants_js_1.LLM_PRICING; } });
+Object.defineProperty(exports, "PLUGINS_DIR", { enumerable: true, get: function () { return constants_js_1.PLUGINS_DIR; } });
+Object.defineProperty(exports, "PLUGIN_REGISTRY", { enumerable: true, get: function () { return constants_js_1.PLUGIN_REGISTRY; } });
+Object.defineProperty(exports, "PLUGIN_MANIFEST_NAME", { enumerable: true, get: function () { return constants_js_1.PLUGIN_MANIFEST_NAME; } });

package/dist/llm.d.ts

@@ -16,4 +16,4 @@ export declare function executeLLMHandler(handler: LLMHandlerConfig, input: Hook
  * a single API call with a structured multi-task prompt. Handlers without a
  * batchGroup are executed individually.
  */
-export declare function executeLLMHandlersBatched(handlers: LLMHandlerConfig[], input: HookInput, context: PrefetchContext): Promise<HandlerResult[]>;
+export declare function executeLLMHandlersBatched(handlers: LLMHandlerConfig[], input: HookInput, context: PrefetchContext, sessionId?: string): Promise<HandlerResult[]>;

package/dist/llm.js

@@ -190,15 +190,19 @@ function splitUsage(total, count) {
  * a single API call with a structured multi-task prompt. Handlers without a
  * batchGroup are executed individually.
  */
-async function executeLLMHandlersBatched(handlers, input, context) {
-    // Group by batchGroup
+async function executeLLMHandlersBatched(handlers, input, context, sessionId) {
+    // Group by batchGroup, scoped by sessionId to prevent cross-session batching
     const grouped = new Map();
     const ungrouped = [];
     for (const handler of handlers) {
         if (handler.batchGroup) {
-            const existing = grouped.get(handler.batchGroup) ?? [];
+            // Scope the batch key by sessionId so different sessions never batch together
+            const batchKey = sessionId
+                ? `${handler.batchGroup}:${sessionId}`
+                : handler.batchGroup;
+            const existing = grouped.get(batchKey) ?? [];
             existing.push(handler);
-            grouped.set(handler.batchGroup, existing);
+            grouped.set(batchKey, existing);
         }
         else {
             ungrouped.push(handler);

package/dist/manifest.d.ts

@@ -9,7 +9,11 @@ export declare function loadManifest(): Manifest;
  * Throws on invalid structure.
  */
 export declare function validateManifest(manifest: Manifest): void;
+/**
+ * Load the composite manifest: user manifest + all installed plugins.
+ */
+export declare function loadCompositeManifest(): Manifest;
 /**
  * Create a default commented example manifest.yaml in CONFIG_DIR.
  */
-export declare function createDefaultManifest(): string;
+export declare function createDefaultManifest(authToken?: string): string;

package/dist/manifest.js

@@ -3,10 +3,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadManifest = loadManifest;
 exports.validateManifest = validateManifest;
+exports.loadCompositeManifest = loadCompositeManifest;
 exports.createDefaultManifest = createDefaultManifest;
 const fs_1 = require("fs");
+const path_1 = require("path");
 const yaml_1 = require("yaml");
 const constants_js_1 = require("./constants.js");
+const plugin_js_1 = require("./plugin.js");
+const builtin_hooks_js_1 = require("./builtin-hooks.js");
 /**
  * Load and validate the manifest from disk.
  * Returns a Manifest with empty handlers if the file doesn't exist.
@@ -99,15 +103,42 @@ function validateManifest(manifest) {
         }
     }
 }
+/**
+ * Load the composite manifest: user manifest + all installed plugins.
+ */
+function loadCompositeManifest() {
+    const userManifest = loadManifest();
+    const plugins = (0, plugin_js_1.loadPlugins)();
+    return (0, plugin_js_1.mergeManifests)(userManifest, plugins);
+}
 /**
  * Create a default commented example manifest.yaml in CONFIG_DIR.
  */
-function createDefaultManifest() {
+function createDefaultManifest(authToken) {
     if (!(0, fs_1.existsSync)(constants_js_1.CONFIG_DIR)) {
         (0, fs_1.mkdirSync)(constants_js_1.CONFIG_DIR, { recursive: true });
     }
+    const settings = {
+        port: 7890,
+        logLevel: 'info',
+    };
+    if (authToken) {
+        settings.authToken = authToken;
+    }
+    // Install built-in hook scripts to CONFIG_DIR/hooks/
+    (0, builtin_hooks_js_1.installBuiltinHooks)();
+    const checkUpdatePath = (0, path_1.join)(constants_js_1.HOOKS_DIR, 'check-update.js');
     const example = {
         handlers: {
+            SessionStart: [
+                {
+                    id: 'clooks-check-update',
+                    type: 'script',
+                    command: `node ${checkUpdatePath}`,
+                    timeout: 6000,
+                    enabled: true,
+                },
+            ],
             PreToolUse: [
                 {
                     id: 'example-guard',
@@ -118,10 +149,7 @@ function createDefaultManifest() {
                 },
             ],
         },
-        settings: {
-            port: 7890,
-            logLevel: 'info',
-        },
+        settings,
     };
     const yamlStr = '# clooks manifest — define your hook handlers here\n' +
         '# Docs: https://github.com/mauribadnights/clooks\n' +

package/dist/metrics.d.ts

@@ -8,8 +8,15 @@ interface AggregatedStats {
     maxDuration: number;
 }
 export declare class MetricsCollector {
+    private static readonly MAX_ENTRIES;
     private entries;
-    /** Record a metric entry in memory and append to disk. */
+    private ringIndex;
+    private totalRecorded;
+    private static readonly METRICS_MAX_BYTES;
+    private static readonly COSTS_MAX_BYTES;
+    /** Rotate a log file if it exceeds maxBytes. Keeps one backup (.1). */
+    private rotateIfNeeded;
+    /** Record a metric entry in memory (ring buffer) and append to disk. */
     record(entry: MetricEntry): void;
     /** Get aggregated stats per event type. */
     getStats(): AggregatedStats[];