eminiar 0.13.0 → 0.13.2

package/dist/hook.js

@@ -23,6 +23,7 @@ import {
   recordShown,
   renderProjectBrief,
   resolvePrice,
+  spawnType,
   subagentStart,
   swarmActivity,
   swarmAgentReturned,
@@ -32,13 +33,16 @@ import {
   swarmSessionStart,
   swarmStampCaller,
   swarmSubagentStop,
-  swarmTouch
-} from "./hook-chunk-MVOBVFQL.js";
+  swarmTouch,
+  workerLacksTool
+} from "./hook-chunk-ZLRLOPLR.js";
 import {
   GUIDE_ORDER,
   classifyAssistant,
   classifyPrompt,
   classifyToolCall,
+  claudeConfigDir,
+  claudePluginsDir,
   clip,
   ensureDirs,
   ev,
@@ -46,13 +50,14 @@ import {
   getStorage,
   init_esm_shims,
   projectDir,
+  setStorageBusyTimeout,
   withPriority
-} from "./hook-chunk-IYHVLMJ4.js";
+} from "./hook-chunk-ETYHCPPH.js";
 
 // src/hook.ts
 init_esm_shims();
 
-// src/hooks/dispatch.ts
+// src/hooks/budget.ts
 init_esm_shims();
 
 // src/hooks/cursor.ts
@@ -117,6 +122,18 @@ function toolResponseOf(v) {
     return v;
   }
 }
+function handlerEvent(parsed, argv) {
+  const forced = argv.indexOf("--event");
+  const p = forced !== -1 && argv[forced + 1] ? { ...parsed, hook_event_name: argv[forced + 1] } : parsed;
+  const event = str(p.hook_event_name);
+  const tool = str(p.tool_name);
+  if (detectClient(p, argv) !== "cursor") return { event, tool };
+  if (event === "afterFileEdit") return { event: CURSOR_EVENTS[event], tool: "Edit" };
+  return {
+    event: event === void 0 ? void 0 : CURSOR_EVENTS[event] ?? event,
+    tool: tool === void 0 ? void 0 : mapToolName(tool)
+  };
+}
 function fromCursor(raw) {
   const event = str(raw.hook_event_name) ?? "";
   const roots = Array.isArray(raw.workspace_roots) ? raw.workspace_roots.filter((r) => typeof r === "string") : [];
@@ -249,6 +266,63 @@ function toCursor(event, out, scope) {
   }
 }
 
+// src/hooks/budget.ts
+var HOOK_BUSY_TIMEOUT_MS = 250;
+var WRITE_WAIT = {
+  SessionStart: 2e3,
+  PostToolUse: 2e3,
+  SubagentStart: 2e3,
+  PreCompact: 2e3,
+  SubagentStop: 1500,
+  SessionEnd: 1500,
+  Stop: 1500
+};
+function busyTimeoutFor(event, tool) {
+  if (event && WRITE_WAIT[event]) return WRITE_WAIT[event];
+  if ((event === "PreToolUse" || event === "PostToolUseFailure") && (tool === "Agent" || tool === "Task"))
+    return 1500;
+  return HOOK_BUSY_TIMEOUT_MS;
+}
+function lockWaitFor(raw, argv) {
+  let parsed = {};
+  try {
+    const p = raw.trim() ? JSON.parse(raw) : {};
+    if (p && typeof p === "object" && !Array.isArray(p)) parsed = p;
+  } catch {
+  }
+  const { event, tool } = handlerEvent(parsed, argv);
+  return busyTimeoutFor(event, tool);
+}
+var HOOK_BUDGET_MS = 3500;
+var LONGER = {
+  SessionStart: 8e3,
+  PostToolUse: 8e3,
+  SubagentStart: 8e3,
+  PreCompact: 12e3
+};
+function budgetFor(event) {
+  return event && LONGER[event] || HOOK_BUDGET_MS;
+}
+var startedAt;
+var budgetMs = HOOK_BUDGET_MS;
+function startBudget(ms = HOOK_BUDGET_MS, now = Date.now()) {
+  startedAt = now;
+  budgetMs = ms;
+}
+function clearBudget() {
+  startedAt = void 0;
+}
+function budgetLeft(now = Date.now()) {
+  if (startedAt === void 0) return Number.POSITIVE_INFINITY;
+  return Math.max(0, budgetMs - (now - startedAt));
+}
+function hasBudget(needMs, now = Date.now()) {
+  return budgetLeft(now) >= needMs;
+}
+
+// src/hooks/dispatch.ts
+init_esm_shims();
+
 // src/hooks/index.ts
 init_esm_shims();
 
@@ -1246,7 +1320,6 @@ function budgetWarnings(db, ctx, sessionId, now = Date.now()) {
 init_esm_shims();
 import { createHash } from "crypto";
 import { closeSync, existsSync as existsSync2, openSync, readdirSync, readSync, statSync } from "fs";
-import { homedir as homedir2 } from "os";
 import { basename, dirname, join as join2, resolve, sep } from "path";
 
 // src/usage/transcript.ts
@@ -1475,7 +1548,7 @@ function isValidSessionId(id) {
   return SESSION_ID_RE.test(id);
 }
 function claudeDir() {
-  return process.env.EMINIAR_CLAUDE_DIR || join2(homedir2(), ".claude");
+  return process.env.EMINIAR_CLAUDE_DIR || claudeConfigDir();
 }
 function insideDir(path, dir) {
   const d = resolve(dir);
@@ -1727,6 +1800,9 @@ function ingestSession(db, root, sessionId, transcriptPath, opts = {}) {
 }
 
 // src/hooks/capture.ts
+var RECALL_NEEDS_MS = 600;
+var ADJUDICATOR_NEEDS_MS = 1500;
+var BEST_EFFORT_NEEDS_MS = 1e3;
 var INDEXED = /* @__PURE__ */ new Set([
   "decision",
   "constraint",
@@ -1788,13 +1864,23 @@ function ingestUsage(db, input, sessionId) {
 }
 var userPromptSubmit = async (input) => {
   if (!input.prompt?.trim()) return void 0;
-  const { db, sessionId } = open(input);
-  db.sessionUpsert({ id: sessionId, last_prompt: clip(input.prompt, 600) });
-  persist(db, sessionId, withPriority(sessionId, classifyPrompt(input.prompt)));
   const ctx = getContext(input.cwd);
+  const db = getStorage(ctx, { vectors: false });
+  const sessionId = input.session_id || "unknown";
+  try {
+    db.sessionUpsert({
+      id: sessionId,
+      project_root: ctx.root,
+      transcript_path: input.transcript_path,
+      last_prompt: clip(input.prompt, 600)
+    });
+    persist(db, sessionId, withPriority(sessionId, classifyPrompt(input.prompt)));
+  } catch (err) {
+    hookLog("info", `UserPromptSubmit: prompt not recorded: ${err.message}`);
+  }
   const { recall } = ctx.config;
   const parts = [];
-  if (recall.onPrompt) {
+  if (recall.onPrompt && hasBudget(RECALL_NEEDS_MS)) {
     try {
       const r = await recallForText(db, input.prompt, {
         maxMemories: recall.maxMemories,
@@ -1804,15 +1890,18 @@ var userPromptSubmit = async (input) => {
         trace: true,
         path: "prompt"
       });
-      recordShown(db, sessionId, r.keys, { path: "prompt", trace: r.trace });
       if (r.text) parts.push(r.text);
+      try {
+        recordShown(db, sessionId, r.keys, { path: "prompt", trace: r.trace });
+      } catch {
+      }
     } catch {
     }
   }
   let systemMessage;
-  if (ctx.config.adjudicator.enabled && input.client !== "cursor") {
+  if (ctx.config.adjudicator.enabled && input.client !== "cursor" && hasBudget(ADJUDICATOR_NEEDS_MS)) {
     try {
-      const { onPrompt } = await import("./hook-hooks-U6GDOQSY.js");
+      const { onPrompt } = await import("./hook-hooks-5U2AI6W7.js");
       const a = await onPrompt(ctx, db, input, sessionId);
       if (a?.context) parts.push(a.context);
       systemMessage = a?.systemMessage;
@@ -1870,7 +1959,7 @@ var postToolUse = async (input) => {
     const ctx = getContext(input.cwd);
     if (ctx.config.adjudicator.enabled) {
       try {
-        const { onPostAgent } = await import("./hook-hooks-U6GDOQSY.js");
+        const { onPostAgent } = await import("./hook-hooks-5U2AI6W7.js");
         onPostAgent(ctx, db, input);
       } catch {
       }
@@ -1878,14 +1967,43 @@ var postToolUse = async (input) => {
   }
   return void 0;
 };
+function bestEffortWrites(db) {
+  let done = false;
+  return (what, fn) => {
+    if (done) return;
+    if (!hasBudget(BEST_EFFORT_NEEDS_MS)) {
+      done = true;
+      hookLog("info", `PostToolUseFailure: ${what} skipped: out of time`);
+      return;
+    }
+    try {
+      const short = db.adjudicator.withLockWait?.bind(db.adjudicator);
+      if (short) short(HOOK_BUSY_TIMEOUT_MS, fn);
+      else fn();
+    } catch (err) {
+      done = true;
+      hookLog("info", `PostToolUseFailure: ${what} not recorded: ${err.message}`);
+    }
+  };
+}
 var postToolUseFailure = async (input) => {
   if (!input.tool_name) return void 0;
-  if (input.agent_id) swarmActivity(getContext(input.cwd), input, true);
-  if (input.tool_name === "Agent" || input.tool_name === "Task")
-    swarmAgentReturned(getContext(input.cwd), input);
-  const { db, root, sessionId } = open(input);
+  const ctx = getContext(input.cwd);
+  if (input.tool_name === "Agent" || input.tool_name === "Task") swarmAgentReturned(ctx, input);
+  const db = getStorage(ctx, { vectors: false });
+  const sessionId = input.session_id || "unknown";
+  const write = bestEffortWrites(db);
+  if (input.agent_id) write("swarm activity", () => swarmActivity(ctx, input, true));
+  write(
+    "session",
+    () => db.sessionUpsert({
+      id: sessionId,
+      project_root: ctx.root,
+      transcript_path: input.transcript_path
+    })
+  );
   let recalled;
-  const { recall } = getContext(input.cwd).config;
+  const { recall } = ctx.config;
   if (recall.onError && input.error) {
     try {
       const r = await recallForError(db, input.error, {
@@ -1895,7 +2013,7 @@ var postToolUseFailure = async (input) => {
       });
       if (r.text) {
         recalled = r.text;
-        recordShown(db, sessionId, r.keys, { path: "error" });
+        write("recall", () => recordShown(db, sessionId, r.keys, { path: "error" }));
       }
     } catch {
     }
@@ -1904,9 +2022,9 @@ var postToolUseFailure = async (input) => {
     toolName: input.tool_name,
     toolInput: input.tool_input ?? {},
     error: input.error ?? "tool failed",
-    root
+    root: ctx.root
   }).filter((d) => d.category !== "tool_call");
-  persist(db, sessionId, withPriority(sessionId, drafts));
+  write("failure", () => persist(db, sessionId, withPriority(sessionId, drafts)));
   return recalled ? { hookSpecificOutput: { hookEventName: "PostToolUseFailure", additionalContext: recalled } } : void 0;
 };
 var subagentStop = (input) => {
@@ -1946,7 +2064,7 @@ var sessionEnd = async (input) => {
   ingestUsage(db, input, sessionId);
   if (ctx.config.adjudicator.enabled && input.client !== "cursor") {
     try {
-      const { onSessionEnd } = await import("./hook-hooks-U6GDOQSY.js");
+      const { onSessionEnd } = await import("./hook-hooks-5U2AI6W7.js");
       onSessionEnd(ctx, db, input);
     } catch {
     }
@@ -2080,17 +2198,17 @@ var preCompact = (input) => {
 // src/hooks/routing.ts
 init_esm_shims();
 import { realpathSync as realpathSync2, statSync as statSync3 } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir2 } from "os";
 import { extname, join as join7, relative, resolve as resolve2 } from "path";
 
 // src/permissions/settings.ts
 init_esm_shims();
 import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
 import { join as join3 } from "path";
 
 // src/permissions/rules.ts
 init_esm_shims();
+import { posix } from "path";
 function parseRule(raw) {
   const m = /^([A-Za-z][\w-]*)(?:\((.*)\))?$/s.exec(raw.trim());
   if (!m) return void 0;
@@ -2099,24 +2217,83 @@ function parseRule(raw) {
 function escapeRe(s) {
   return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
 }
+function globSource(glob) {
+  return glob.split("/**/").map(
+    (part) => part.split("**").map(
+      (seg) => seg.split("*").map((s) => s.split("?").map(escapeRe).join("[^/]")).join("[^/]*")
+    ).join(".*")
+  ).join("/(?:.*/)?");
+}
+function anchored(prefix, rest) {
+  const full = posix.normalize(`${prefix}${rest}`);
+  if (prefix && (full === prefix || full.startsWith(`${prefix}/`))) {
+    return literal(prefix) + globSource(full.slice(prefix.length));
+  }
+  return globSource(full);
+}
+function literal(s) {
+  return escapeRe(s).replace(/\*/g, "\\*");
+}
+function readSource(pattern, root, home) {
+  const dir = pattern.endsWith("/") && pattern.length > 1;
+  const p = dir ? pattern.slice(0, -1) : pattern;
+  let body;
+  if (p.startsWith("**")) body = globSource(p);
+  else if (p.startsWith("//")) body = anchored("", p.slice(1));
+  else if (p === "~" || p.startsWith("~/")) body = anchored(home, p.slice(1));
+  else if (p.startsWith("/")) body = `(?:${anchored(root, p)}|${globSource(posix.normalize(p))})`;
+  else if (p.startsWith("./")) body = anchored(root, p.slice(1));
+  else if (p.includes("/")) body = anchored(root, `/${p}`);
+  else body = `${literal(root)}/(?:.*/)?${globSource(p)}`;
+  return `^${body}(?:/.*)?$`;
+}
 var readRegexCache = /* @__PURE__ */ new Map();
-function readRegex(pattern) {
-  let re = readRegexCache.get(pattern);
+function readRegex(pattern, root, home) {
+  const key = `${root}\0${home}\0${pattern}`;
+  let re = readRegexCache.get(key);
   if (!re) {
-    if (readRegexCache.size >= 1024) readRegexCache.clear();
-    re = new RegExp(
-      `^${pattern.split("**").map((seg) => seg.split("*").map(escapeRe).join("[^/]*")).join(".*")}$`
-    );
-    readRegexCache.set(pattern, re);
+    if (readRegexCache.size >= 4096) readRegexCache.clear();
+    re = new RegExp(readSource(pattern, root, home));
+    readRegexCache.set(key, re);
   }
   return re;
 }
-function matchRead(rule, absPath) {
-  if (rule.tool !== "Read") return false;
-  if (rule.pattern === void 0) return true;
-  let p = rule.pattern;
-  if (p.startsWith("~")) p = (process.env.HOME ?? "") + p.slice(1);
-  return readRegex(p).test(absPath);
+function defaultRoot() {
+  return process.cwd();
+}
+function needleOf(pattern) {
+  const p = pattern.endsWith("/") && pattern.length > 1 ? pattern.slice(0, -1) : pattern;
+  if (p.includes("..")) return "";
+  let tail;
+  if (p.startsWith("**") || !p.includes("/")) tail = p;
+  else if (p.startsWith("//")) tail = posix.normalize(p.slice(1));
+  else if (p === "~" || p.startsWith("~/")) tail = posix.normalize(p.slice(1) || "/");
+  else if (p.startsWith("./")) tail = posix.normalize(p.slice(1));
+  else tail = posix.normalize(p.startsWith("/") ? p : `/${p}`);
+  let best = "";
+  for (const piece of tail.split(/[*?]/)) if (piece.length > best.length) best = piece;
+  return best;
+}
+var listCache = /* @__PURE__ */ new WeakMap();
+function readMatcher(rules, root) {
+  const r = root ?? defaultRoot();
+  const home = process.env.HOME ?? "";
+  const key = `${r}\0${home}\0${rules.length}`;
+  const hit = listCache.get(rules);
+  if (hit && hit.key === key) return hit.matcher;
+  const compiled = rules.filter((x) => x.tool === "Read").map(
+    (rule) => rule.pattern === void 0 ? { rule, needle: "", re: /^/ } : { rule, needle: needleOf(rule.pattern), re: readRegex(rule.pattern, r, home) }
+  );
+  const which = (p) => {
+    for (const c of compiled) {
+      if (c.needle && !p.includes(c.needle)) continue;
+      if (c.re.test(p)) return c.rule;
+    }
+    return void 0;
+  };
+  const matcher = { test: (p) => which(p) !== void 0, which };
+  listCache.set(rules, { key, matcher });
+  return matcher;
 }
 
 // src/permissions/split.ts
@@ -2142,15 +2319,15 @@ function stamp(file2) {
 var cache = /* @__PURE__ */ new Map();
 function loadPermissionRules(root, extraDeny = []) {
   const files = [
-    join3(homedir3(), ".claude", "settings.json"),
+    join3(claudeConfigDir(), "settings.json"),
     join3(root, ".claude", "settings.json"),
     join3(root, ".claude", "settings.local.json")
   ];
-  const key = `${root}\0${extraDeny.join("\0")}`;
+  const key = [...files, ...extraDeny].join("\0");
   const stamps = files.map(stamp);
   const hit = cache.get(key);
   if (hit?.stamps.every((s, i) => s === stamps[i])) return hit.rules;
-  const out = { allow: [], deny: [], ask: [] };
+  const out = { allow: [], deny: [], ask: [], root };
   const push = (list, raws) => {
     for (const raw of raws ?? []) {
       const r = parseRule(raw);
@@ -2170,14 +2347,21 @@ function loadPermissionRules(root, extraDeny = []) {
 }
 function checkRead(rules, absPaths) {
   for (const kind of ["deny", "ask"]) {
-    for (const r of rules[kind]) {
-      if (absPaths.some((p) => matchRead(r, p))) return { allowed: false, rule: r.raw, kind };
+    const m = readMatcher(rules[kind], rules.root);
+    for (const p of absPaths) {
+      const r = m.which(p);
+      if (r) return { allowed: false, rule: r.raw, kind };
     }
   }
   return { allowed: true };
 }
 function checkReadPath(rules, abs) {
-  return checkRead(rules, [.../* @__PURE__ */ new Set([abs, realpathSync(abs), realpathSync.native(abs)])]);
+  const asWritten = checkRead(rules, [abs]);
+  if (!asWritten.allowed) return asWritten;
+  const real = realpathSync(abs);
+  const native = realpathSync.native(abs);
+  const more = [real, native].filter((p, i, a) => p !== abs && a.indexOf(p) === i);
+  return more.length ? checkRead(rules, more) : asWritten;
 }
 
 // src/session/routing-stats.ts
@@ -2246,10 +2430,8 @@ import {
   readFileSync as readFileSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir4 } from "os";
 import { dirname as dirname2, join as join5 } from "path";
-var claudeDir2 = () => process.env.CLAUDE_CONFIG_DIR || join5(homedir4(), ".claude");
-var pluginsDir = () => join5(claudeDir2(), "plugins");
+var pluginsDir = () => claudePluginsDir();
 
 // src/hooks/coexist.ts
 var cached;
@@ -2488,7 +2670,7 @@ function fileOperands(stage, cwd) {
   for (let f of files) {
     if (/[*?[\]{}$`\\]/.test(f)) return void 0;
     f = f.replace(/^['"]|['"]$/g, "");
-    if (f.startsWith("~/")) f = join7(homedir5(), f.slice(2));
+    if (f.startsWith("~/")) f = join7(homedir2(), f.slice(2));
     out.push(resolve2(cwd, f));
   }
   return out;
@@ -2639,12 +2821,18 @@ function suggest(toolName, input, root, extra = {}) {
       return {
         tool: "em_*",
         reason: "subagents should prefer em_execute / em_batch_execute / em_search over Bash, Read and Grep",
-        prefixPrompt: 'Use the eminiar tools (em_execute, em_batch_execute, em_execute_file, em_fetch_and_index, em_search, em_symbols, em_history) instead of Bash/Read/Grep/WebFetch whenever output may be large; return only derived answers. Check em_recall {query} for project decisions and constraints before proposing changes, em_history {action:"file", path} before editing a file, em_symbols / em_search {source:"code"} before grepping for an identifier, and em_docs {action:"lookup", query} before WebFetch/WebSearch for anything the project depends on.\n\n'
+        prefixPrompt: subagentPrefix(true)
       };
     default:
       return void 0;
   }
 }
+function subagentPrefix(shell) {
+  const runners = shell ? "em_execute, em_batch_execute, em_execute_file, " : "";
+  return `Use the eminiar tools (${runners}em_fetch_and_index, em_search, em_symbols, em_history) instead of ${shell ? "Bash/" : ""}Read/Grep/WebFetch whenever output may be large; return only derived answers. Check em_recall {query} for project decisions and constraints before proposing changes, em_history {action:"file", path} before editing a file, em_symbols / em_search {source:"code"} before grepping for an identifier, and em_docs {action:"lookup", query} before WebFetch/WebSearch for anything the project depends on.
+
+`;
+}
 function projectRel(ctx, fp) {
   if (!fp) return void 0;
   let abs = resolve2(ctx.root, fp);
@@ -2773,7 +2961,7 @@ var preToolUse = async (input) => {
   const out = await route(ctx, input, spawn?.kind === "worker");
   if (!ctx.config.adjudicator.enabled || input.client === "cursor") return out;
   try {
-    const { afterRouting } = await import("./hook-hooks-U6GDOQSY.js");
+    const { afterRouting } = await import("./hook-hooks-5U2AI6W7.js");
     return await afterRouting(ctx, input, spawn, out);
   } catch {
     return out;
@@ -2805,15 +2993,16 @@ async function route(ctx, input, swarmWorker) {
   }
   if (mode === "enforce") {
     if (s.prefixPrompt) {
+      const prefix = swarmWorker && workerLacksTool(input, spawnType(input), "em_execute") ? subagentPrefix(false) : s.prefixPrompt;
       const prompt = String(input.tool_input.prompt ?? "");
-      if (prompt.startsWith(s.prefixPrompt)) return void 0;
+      if (prompt.startsWith(prefix)) return void 0;
       return {
         hookSpecificOutput: {
           hookEventName: "PreToolUse",
           permissionDecision: "allow",
           updatedInput: {
             ...input.tool_input,
-            prompt: s.prefixPrompt + (swarmWorker ? "" : await briefFor(ctx, prompt)) + prompt
+            prompt: prefix + (swarmWorker ? "" : await briefFor(ctx, prompt)) + prompt
           }
         }
       };
@@ -2832,6 +3021,10 @@ async function route(ctx, input, swarmWorker) {
         hint
       );
     }
+    if (input.agent_id && workerLacksTool(input, input.agent_type, s.tool)) {
+      record("allow", "no-shell");
+      return withContext(void 0, hint);
+    }
     record("deny");
     hookLog("info", `deny ${input.tool_name} \u2192 ${s.tool} [${s.rule ?? "?"}]: ${callHead(input)}`);
     return {
@@ -2954,18 +3147,22 @@ var sessionStart = async (input) => {
   const sessionId = input.session_id || "unknown";
   setCurrentSession(ctx, sessionId);
   const db = getStorage(ctx, { vectors: false });
-  db.sessionUpsert({
-    id: sessionId,
-    project_root: ctx.root,
-    source: input.source,
-    transcript_path: input.transcript_path
-  });
-  db.eventInsert({
-    sessionId,
-    category: "session_start",
-    priority: 4,
-    payload: { source: input.source }
-  });
+  try {
+    db.sessionUpsert({
+      id: sessionId,
+      project_root: ctx.root,
+      source: input.source,
+      transcript_path: input.transcript_path
+    });
+    db.eventInsert({
+      sessionId,
+      category: "session_start",
+      priority: 4,
+      payload: { source: input.source }
+    });
+  } catch (err) {
+    hookLog("info", `SessionStart: session not recorded: ${err.message}`);
+  }
   if (process.env.CLAUDE_ENV_FILE) {
     try {
       appendFileSync(
@@ -2984,7 +3181,11 @@ export EMINIAR_PROJECT_ROOT=${JSON.stringify(ctx.root)}
     if (snap) {
       parts.push(`## Session Guide (eminiar)
 ${snap.body}`);
-      db.snapshotMarkConsumed(snap.id);
+      try {
+        db.snapshotMarkConsumed(snap.id);
+      } catch (err) {
+        hookLog("info", `SessionStart: snapshot not marked consumed: ${err.message}`);
+      }
     } else {
       const prev = input.source === "resume" ? db.sessionLatest() : void 0;
       const guide = renderGuide(db, prev && prev.id !== sessionId ? prev.id : sessionId, 2048);
@@ -2997,7 +3198,7 @@ ${guide}`);
   if (swarm) parts.push(swarm);
   if (ctx.config.adjudicator.enabled && input.client !== "cursor") {
     try {
-      const { onSessionStart } = await import("./hook-hooks-U6GDOQSY.js");
+      const { onSessionStart } = await import("./hook-hooks-5U2AI6W7.js");
       const line2 = onSessionStart(ctx, db, input);
       if (line2) parts.push(line2);
     } catch {
@@ -3072,7 +3273,29 @@ var handlers = {
 };
 
 // src/hooks/dispatch.ts
-async function dispatch(raw, argv) {
+var late = false;
+function ranLate() {
+  return late;
+}
+async function runWithin(handler, input, ms) {
+  let timer;
+  const deadline = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3("late"), ms);
+  });
+  try {
+    const r = await Promise.race([handler(input), deadline]);
+    if (r === "late") {
+      late = true;
+      return { out: void 0, timedOut: true };
+    }
+    return { out: r, timedOut: false };
+  } finally {
+    clearTimeout(timer);
+    if (!late) clearBudget();
+  }
+}
+async function dispatch(raw, argv, opts = {}) {
+  late = false;
   let parsed;
   try {
     parsed = raw.trim() ? JSON.parse(raw) : {};
@@ -3083,13 +3306,20 @@ async function dispatch(raw, argv) {
   const forced = argv.indexOf("--event");
   if (forced !== -1 && argv[forced + 1]) parsed.hook_event_name = argv[forced + 1];
   if (argv.includes("--selftest")) return JSON.stringify({ systemMessage: "eminiar hook ok" });
-  if (detectClient(parsed, argv) === "cursor") return runCursor(parsed);
+  if (detectClient(parsed, argv) === "cursor") return runCursor(parsed, opts.budgetMs);
   const input = parsed;
   const handler = handlers[input.hook_event_name];
   if (!handler) return "{}";
+  const ms = opts.budgetMs ?? budgetFor(input.hook_event_name);
+  startBudget(ms);
   try {
-    const out = await handler(input);
-    return JSON.stringify(out ?? {});
+    const r = await runWithin(handler, input, ms);
+    if (r.timedOut) {
+      const err = new Error(`hook budget of ${ms} ms exceeded`);
+      hookLog("error", `${input.hook_event_name}: ${err.message}; answered without it`);
+      return failClosed(input, err) ?? "{}";
+    }
+    return JSON.stringify(r.out ?? {});
   } catch (err) {
     hookLog("error", `${input.hook_event_name}: ${err.stack ?? String(err)}`);
     return failClosed(input, err) ?? "{}";
@@ -3104,6 +3334,10 @@ function failClosed(input, err) {
   try {
     if (input.hook_event_name !== "PreToolUse" || input.client === "cursor" || input.tool_name !== "Agent" && input.tool_name !== "Task" || !rawEnforced({ cwd: input.cwd }))
       return void 0;
+    try {
+      swarmAgentReturned(getContext(input.cwd), input);
+    } catch {
+    }
     return JSON.stringify({
       hookSpecificOutput: {
         hookEventName: "PreToolUse",
@@ -3115,14 +3349,18 @@ function failClosed(input, err) {
     return void 0;
   }
 }
-async function runCursor(parsed) {
+async function runCursor(parsed, budgetMs2) {
   const input = fromCursor(parsed);
   const event = input.hook_event_name;
   let out;
   const handler = handlers[event];
   if (handler) {
+    const ms = budgetMs2 ?? budgetFor(event);
+    startBudget(ms);
     try {
-      out = await handler(input);
+      const r = await runWithin(handler, input, ms);
+      if (r.timedOut) hookLog("error", `cursor ${event}: hook budget of ${ms} ms exceeded`);
+      out = r.out;
     } catch (err) {
       hookLog("error", `cursor ${event}: ${err.stack ?? String(err)}`);
     }
@@ -3153,12 +3391,18 @@ async function main() {
     return;
   }
   if (process.argv.includes("--adjudicate")) {
-    const { ASYNC_JOB_MAX_MS, runAsyncJob } = await import("./hook-async-4MIP3VHX.js");
+    const { ASYNC_JOB_MAX_MS, runAsyncJob } = await import("./hook-async-3TLK23ZY.js");
     setTimeout(() => process.exit(0), ASYNC_JOB_MAX_MS).unref();
     await runAsyncJob(raw, { log: (line2) => hookLog("info", line2) });
     return;
   }
-  process.stdout.write(await dispatch(raw, process.argv.slice(2)));
+  setStorageBusyTimeout(lockWaitFor(raw, process.argv.slice(2)));
+  const out = await dispatch(raw, process.argv.slice(2));
+  if (!ranLate()) {
+    process.stdout.write(out);
+    return;
+  }
+  process.stdout.write(out, () => process.exit(0));
 }
 main().catch((err) => {
   hookLog("error", `fatal: ${err.stack ?? String(err)}`);