reasonix 0.4.22 → 0.4.24

package/dist/index.js

@@ -427,6 +427,174 @@ function resolveTemperatures(budget, custom) {
   return out;
 }
 
+// src/hooks.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop"
+];
+var BLOCKING_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "UserPromptSubmit"]);
+var DEFAULT_TIMEOUTS_MS = {
+  PreToolUse: 5e3,
+  UserPromptSubmit: 5e3,
+  PostToolUse: 3e4,
+  Stop: 3e4
+};
+var HOOK_SETTINGS_FILENAME = "settings.json";
+var HOOK_SETTINGS_DIRNAME = ".reasonix";
+function globalSettingsPath(homeDirOverride) {
+  return join(homeDirOverride ?? homedir(), HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
+}
+function projectSettingsPath(projectRoot) {
+  return join(projectRoot, HOOK_SETTINGS_DIRNAME, HOOK_SETTINGS_FILENAME);
+}
+function readSettingsFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return null;
+}
+function loadHooks(opts = {}) {
+  const out = [];
+  if (opts.projectRoot) {
+    const projPath = projectSettingsPath(opts.projectRoot);
+    const settings2 = readSettingsFile(projPath);
+    if (settings2) appendResolved(out, settings2, "project", projPath);
+  }
+  const globalPath = globalSettingsPath(opts.homeDir);
+  const settings = readSettingsFile(globalPath);
+  if (settings) appendResolved(out, settings, "global", globalPath);
+  return out;
+}
+function appendResolved(out, settings, scope, source) {
+  if (!settings.hooks) return;
+  for (const event of HOOK_EVENTS) {
+    const list = settings.hooks[event];
+    if (!Array.isArray(list)) continue;
+    for (const cfg of list) {
+      if (!cfg || typeof cfg.command !== "string" || cfg.command.trim() === "") continue;
+      out.push({ ...cfg, event, scope, source });
+    }
+  }
+}
+function matchesTool(hook, toolName) {
+  if (hook.event !== "PreToolUse" && hook.event !== "PostToolUse") return true;
+  const m = hook.match;
+  if (!m || m === "*") return true;
+  try {
+    const re = new RegExp(`^(?:${m})$`);
+    return re.test(toolName);
+  } catch {
+    return false;
+  }
+}
+function defaultSpawner(input) {
+  return new Promise((resolve7) => {
+    const child = spawn(input.command, {
+      cwd: input.cwd,
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 500);
+    }, input.timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.once("error", (err) => {
+      clearTimeout(timer);
+      resolve7({
+        exitCode: null,
+        stdout,
+        stderr,
+        timedOut: false,
+        spawnError: err
+      });
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      resolve7({
+        exitCode: code,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        timedOut
+      });
+    });
+    try {
+      child.stdin.write(input.stdin);
+      child.stdin.end();
+    } catch {
+    }
+  });
+}
+function formatHookOutcomeMessage(outcome) {
+  if (outcome.decision === "pass") return "";
+  const detail = (outcome.stderr || outcome.stdout || "").trim();
+  const tag = `${outcome.hook.scope}/${outcome.hook.event}`;
+  const cmd = outcome.hook.command.length > 60 ? `${outcome.hook.command.slice(0, 60)}\u2026` : outcome.hook.command;
+  const head = `hook ${tag} \`${cmd}\` ${outcome.decision}`;
+  return detail ? `${head}: ${detail}` : head;
+}
+function decideOutcome(event, raw) {
+  if (raw.spawnError) return "error";
+  if (raw.timedOut) return BLOCKING_EVENTS.has(event) ? "block" : "warn";
+  if (raw.exitCode === 0) return "pass";
+  if (raw.exitCode === 2 && BLOCKING_EVENTS.has(event)) return "block";
+  return "warn";
+}
+async function runHooks(opts) {
+  const spawner = opts.spawner ?? defaultSpawner;
+  const event = opts.payload.event;
+  const toolName = opts.payload.toolName ?? "";
+  const matching = opts.hooks.filter((h) => h.event === event && matchesTool(h, toolName));
+  const outcomes = [];
+  let blocked = false;
+  const stdin = `${JSON.stringify(opts.payload)}
+`;
+  for (const hook of matching) {
+    const start = Date.now();
+    const timeoutMs = hook.timeout ?? DEFAULT_TIMEOUTS_MS[event];
+    const cwd = hook.cwd ?? opts.payload.cwd;
+    const raw = await spawner({ command: hook.command, cwd, stdin, timeoutMs });
+    const decision = decideOutcome(event, raw);
+    outcomes.push({
+      hook,
+      decision,
+      exitCode: raw.exitCode,
+      stdout: raw.stdout,
+      stderr: raw.stderr || (raw.spawnError ? raw.spawnError.message : "") || (raw.timedOut ? `hook timed out after ${timeoutMs}ms` : ""),
+      durationMs: Date.now() - start
+    });
+    if (decision === "block") {
+      blocked = true;
+      break;
+    }
+  }
+  return { event, outcomes, blocked };
+}
+
 // src/repair/flatten.ts
 function analyzeSchema(schema) {
   if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
@@ -1049,21 +1217,21 @@ function signature2(call) {
 import {
   appendFileSync,
   chmodSync,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readdirSync,
   statSync,
   unlinkSync,
   writeFileSync
 } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
 function sessionsDir() {
-  return join(homedir(), ".reasonix", "sessions");
+  return join2(homedir2(), ".reasonix", "sessions");
 }
 function sessionPath(name) {
-  return join(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+  return join2(sessionsDir(), `${sanitizeName(name)}.jsonl`);
 }
 function sanitizeName(name) {
   const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
@@ -1071,9 +1239,9 @@ function sanitizeName(name) {
 }
 function loadSessionMessages(name) {
   const path = sessionPath(name);
-  if (!existsSync(path)) return [];
+  if (!existsSync2(path)) return [];
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync2(path, "utf8");
     const out = [];
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -1101,11 +1269,11 @@ function appendSessionMessage(name, message) {
 }
 function listSessions() {
   const dir = sessionsDir();
-  if (!existsSync(dir)) return [];
+  if (!existsSync2(dir)) return [];
   try {
     const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
     return files.map((file) => {
-      const path = join(dir, file);
+      const path = join2(dir, file);
       const stat = statSync(path);
       const name = file.replace(/\.jsonl$/, "");
       const messageCount = countLines(path);
@@ -1137,7 +1305,7 @@ function rewriteSession(name, messages) {
 }
 function countLines(path) {
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync2(path, "utf8");
     return raw.split(/\r?\n/).filter((l) => l.trim()).length;
   } catch {
     return 0;
@@ -1251,6 +1419,14 @@ var CacheFirstLoop = class {
   branchEnabled;
   branchOptions;
   sessionName;
+  /**
+   * Hook list, mutable so `/hooks reload` can swap it without
+   * reconstructing the loop. Default empty — the filter cost on a
+   * tool call is one array length check.
+   */
+  hooks;
+  /** `cwd` reported to hook stdin. Resolved once at construction. */
+  hookCwd;
   /** Number of messages that were pre-loaded from the session file. */
   resumedMessageCount;
   _turn = 0;
@@ -1269,6 +1445,8 @@ var CacheFirstLoop = class {
     this.tools = opts.tools ?? new ToolRegistry();
     this.model = opts.model ?? "deepseek-chat";
     this.maxToolIters = opts.maxToolIters ?? 64;
+    this.hooks = opts.hooks ?? [];
+    this.hookCwd = opts.hookCwd ?? process.cwd();
     if (typeof opts.branch === "number") {
       this.branchOptions = { budget: opts.branch };
     } else if (opts.branch && typeof opts.branch === "object") {
@@ -1732,7 +1910,37 @@ var CacheFirstLoop = class {
           toolName: name,
           toolArgs: args
         };
-        const result = await this.tools.dispatch(name, args, { signal });
+        const parsedArgs = safeParseToolArgs(args);
+        const preReport = await runHooks({
+          hooks: this.hooks,
+          payload: {
+            event: "PreToolUse",
+            cwd: this.hookCwd,
+            toolName: name,
+            toolArgs: parsedArgs
+          }
+        });
+        for (const w of hookWarnings(preReport.outcomes, this._turn)) yield w;
+        let result;
+        if (preReport.blocked) {
+          const blocking = preReport.outcomes[preReport.outcomes.length - 1];
+          const reason = (blocking?.stderr || blocking?.stdout || "blocked by PreToolUse hook").trim();
+          result = `[hook block] ${blocking?.hook.command ?? "<unknown>"}
+${reason}`;
+        } else {
+          result = await this.tools.dispatch(name, args, { signal });
+          const postReport = await runHooks({
+            hooks: this.hooks,
+            payload: {
+              event: "PostToolUse",
+              cwd: this.hookCwd,
+              toolName: name,
+              toolArgs: parsedArgs,
+              toolResult: result
+            }
+          });
+          for (const w of hookWarnings(postReport.outcomes, this._turn)) yield w;
+        }
         this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
@@ -1819,6 +2027,19 @@ function stripHallucinatedToolMarkup(s) {
   out = out.replace(/<｜DSML｜[\s\S]*$/g, "");
   return out.trim();
 }
+function safeParseToolArgs(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function* hookWarnings(outcomes, turn) {
+  for (const o of outcomes) {
+    if (o.decision === "pass") continue;
+    yield { turn, role: "warning", content: formatHookOutcomeMessage(o) };
+  }
+}
 function reasonPrefixFor(reason, iterCap) {
   if (reason === "aborted") return "[aborted by user (Esc) \u2014 summarizing what I found so far]";
   if (reason === "context-guard") {
@@ -1908,16 +2129,16 @@ function formatLoopError(err) {
 }
 
 // src/project-memory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 var PROJECT_MEMORY_FILE = "REASONIX.md";
 var PROJECT_MEMORY_MAX_CHARS = 8e3;
 function readProjectMemory(rootDir) {
-  const path = join2(rootDir, PROJECT_MEMORY_FILE);
-  if (!existsSync2(path)) return null;
+  const path = join3(rootDir, PROJECT_MEMORY_FILE);
+  if (!existsSync3(path)) return null;
   let raw;
   try {
-    raw = readFileSync2(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return null;
   }
@@ -1953,20 +2174,20 @@ ${mem.content}
 // src/user-memory.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   readdirSync as readdirSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4, resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5, resolve as resolve2 } from "path";
 
 // src/skills.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3, resolve } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve } from "path";
 var SKILLS_DIRNAME = "skills";
 var SKILL_FILE = "SKILL.md";
 var SKILLS_INDEX_MAX_CHARS = 4e3;
@@ -1995,7 +2216,7 @@ var SkillStore = class {
   homeDir;
   projectRoot;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? homedir2();
+    this.homeDir = opts.homeDir ?? homedir3();
     this.projectRoot = opts.projectRoot ? resolve(opts.projectRoot) : void 0;
   }
   /** True iff this store was configured with a project root. */
@@ -2011,11 +2232,11 @@ var SkillStore = class {
     const out = [];
     if (this.projectRoot) {
       out.push({
-        dir: join3(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
+        dir: join4(this.projectRoot, ".reasonix", SKILLS_DIRNAME),
         scope: "project"
       });
     }
-    out.push({ dir: join3(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
+    out.push({ dir: join4(this.homeDir, ".reasonix", SKILLS_DIRNAME), scope: "global" });
     return out;
   }
   /**
@@ -2026,7 +2247,7 @@ var SkillStore = class {
   list() {
     const byName = /* @__PURE__ */ new Map();
     for (const { dir, scope } of this.roots()) {
-      if (!existsSync3(dir)) continue;
+      if (!existsSync4(dir)) continue;
       let entries;
       try {
         entries = readdirSync2(dir, { withFileTypes: true });
@@ -2045,13 +2266,13 @@ var SkillStore = class {
   read(name) {
     if (!isValidSkillName(name)) return null;
     for (const { dir, scope } of this.roots()) {
-      if (!existsSync3(dir)) continue;
-      const dirCandidate = join3(dir, name, SKILL_FILE);
-      if (existsSync3(dirCandidate) && statSync2(dirCandidate).isFile()) {
+      if (!existsSync4(dir)) continue;
+      const dirCandidate = join4(dir, name, SKILL_FILE);
+      if (existsSync4(dirCandidate) && statSync2(dirCandidate).isFile()) {
         return this.parse(dirCandidate, name, scope);
       }
-      const flatCandidate = join3(dir, `${name}.md`);
-      if (existsSync3(flatCandidate) && statSync2(flatCandidate).isFile()) {
+      const flatCandidate = join4(dir, `${name}.md`);
+      if (existsSync4(flatCandidate) && statSync2(flatCandidate).isFile()) {
         return this.parse(flatCandidate, name, scope);
       }
     }
@@ -2060,21 +2281,21 @@ var SkillStore = class {
   readEntry(dir, scope, entry) {
     if (entry.isDirectory()) {
       if (!isValidSkillName(entry.name)) return null;
-      const file = join3(dir, entry.name, SKILL_FILE);
-      if (!existsSync3(file)) return null;
+      const file = join4(dir, entry.name, SKILL_FILE);
+      if (!existsSync4(file)) return null;
       return this.parse(file, entry.name, scope);
     }
     if (entry.isFile() && entry.name.endsWith(".md")) {
       const stem = entry.name.slice(0, -3);
       if (!isValidSkillName(stem)) return null;
-      return this.parse(join3(dir, entry.name), stem, scope);
+      return this.parse(join4(dir, entry.name), stem, scope);
     }
     return null;
   }
   parse(path, stem, scope) {
     let raw;
     try {
-      raw = readFileSync3(path, "utf8");
+      raw = readFileSync4(path, "utf8");
     } catch {
       return null;
     }
@@ -2137,15 +2358,15 @@ function projectHash(rootDir) {
 }
 function scopeDir(opts) {
   if (opts.scope === "global") {
-    return join4(opts.homeDir, USER_MEMORY_DIR, "global");
+    return join5(opts.homeDir, USER_MEMORY_DIR, "global");
   }
   if (!opts.projectRoot) {
     throw new Error("scope=project requires a projectRoot on MemoryStore");
   }
-  return join4(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
+  return join5(opts.homeDir, USER_MEMORY_DIR, projectHash(opts.projectRoot));
 }
 function ensureDir(p) {
-  if (!existsSync4(p)) mkdirSync2(p, { recursive: true });
+  if (!existsSync5(p)) mkdirSync2(p, { recursive: true });
 }
 function parseFrontmatter2(raw) {
   const lines = raw.split(/\r?\n/);
@@ -2190,7 +2411,7 @@ var MemoryStore = class {
   homeDir;
   projectRoot;
   constructor(opts = {}) {
-    this.homeDir = opts.homeDir ?? join4(homedir3(), ".reasonix");
+    this.homeDir = opts.homeDir ?? join5(homedir4(), ".reasonix");
     this.projectRoot = opts.projectRoot ? resolve2(opts.projectRoot) : void 0;
   }
   /** Directory this store writes `scope` files into, creating it if needed. */
@@ -2201,7 +2422,7 @@ var MemoryStore = class {
   }
   /** Absolute path to a memory file (no existence check). */
   pathFor(scope, name) {
-    return join4(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
+    return join5(this.dir(scope), `${sanitizeMemoryName(name)}.md`);
   }
   /** True iff this store is configured with a project scope available. */
   hasProjectScope() {
@@ -2213,14 +2434,14 @@ var MemoryStore = class {
    */
   loadIndex(scope) {
     if (scope === "project" && !this.projectRoot) return null;
-    const file = join4(
+    const file = join5(
       scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot }),
       MEMORY_INDEX_FILE
     );
-    if (!existsSync4(file)) return null;
+    if (!existsSync5(file)) return null;
     let raw;
     try {
-      raw = readFileSync4(file, "utf8");
+      raw = readFileSync5(file, "utf8");
     } catch {
       return null;
     }
@@ -2235,10 +2456,10 @@ var MemoryStore = class {
   /** Read one memory file's body (frontmatter stripped). Throws if missing. */
   read(scope, name) {
     const file = this.pathFor(scope, name);
-    if (!existsSync4(file)) {
+    if (!existsSync5(file)) {
       throw new Error(`memory not found: scope=${scope} name=${name}`);
     }
-    const raw = readFileSync4(file, "utf8");
+    const raw = readFileSync5(file, "utf8");
     const { data, body } = parseFrontmatter2(raw);
     return {
       name: data.name ?? name,
@@ -2259,7 +2480,7 @@ var MemoryStore = class {
     const scopes = this.projectRoot ? ["global", "project"] : ["global"];
     for (const scope of scopes) {
       const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
-      if (!existsSync4(dir)) continue;
+      if (!existsSync5(dir)) continue;
       let entries;
       try {
         entries = readdirSync3(dir);
@@ -2300,7 +2521,7 @@ var MemoryStore = class {
       createdAt: todayIso()
     };
     const dir = this.dir(input.scope);
-    const file = join4(dir, `${name}.md`);
+    const file = join5(dir, `${name}.md`);
     const content = `${formatFrontmatter(entry)}${body}
 `;
     writeFileSync2(file, content, "utf8");
@@ -2313,7 +2534,7 @@ var MemoryStore = class {
       throw new Error("cannot delete project-scoped memory: no projectRoot configured");
     }
     const file = this.pathFor(scope, rawName);
-    if (!existsSync4(file)) return false;
+    if (!existsSync5(file)) return false;
     unlinkSync2(file);
     this.regenerateIndex(scope);
     return true;
@@ -2326,7 +2547,7 @@ var MemoryStore = class {
    */
   regenerateIndex(scope) {
     const dir = scopeDir({ homeDir: this.homeDir, scope, projectRoot: this.projectRoot });
-    if (!existsSync4(dir)) return;
+    if (!existsSync5(dir)) return;
     let files;
     try {
       files = readdirSync3(dir);
@@ -2334,9 +2555,9 @@ var MemoryStore = class {
       return;
     }
     const mdFiles = files.filter((f) => f !== MEMORY_INDEX_FILE && f.endsWith(".md")).sort((a, b) => a.localeCompare(b));
-    const indexPath = join4(dir, MEMORY_INDEX_FILE);
+    const indexPath = join5(dir, MEMORY_INDEX_FILE);
     if (mdFiles.length === 0) {
-      if (existsSync4(indexPath)) unlinkSync2(indexPath);
+      if (existsSync5(indexPath)) unlinkSync2(indexPath);
       return;
     }
     const lines = [];
@@ -2899,8 +3120,8 @@ function registerPlanTool(registry, opts = {}) {
 }
 
 // src/tools/shell.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync6, statSync as statSync3 } from "fs";
 import * as pathMod2 from "path";
 var DEFAULT_TIMEOUT_SEC = 60;
 var DEFAULT_MAX_OUTPUT_CHARS = 32e3;
@@ -3023,7 +3244,7 @@ async function runCommand(cmd, opts) {
   return await new Promise((resolve7, reject) => {
     let child;
     try {
-      child = spawn(bin, args, effectiveSpawnOpts);
+      child = spawn2(bin, args, effectiveSpawnOpts);
     } catch (err) {
       reject(err);
       return;
@@ -3078,7 +3299,7 @@ function resolveExecutable(cmd, opts = {}) {
 }
 function defaultIsFile(full) {
   try {
-    return existsSync5(full) && statSync3(full).isFile();
+    return existsSync6(full) && statSync3(full).isFile();
   } catch {
     return false;
   }
@@ -3381,12 +3602,12 @@ ${i + 1}. ${r.title}`);
 }
 
 // src/env.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve5 } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync5(resolve5(process.cwd(), path), "utf8");
+    raw = readFileSync6(resolve5(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -3405,7 +3626,7 @@ function loadDotenv(path = ".env") {
 }
 
 // src/transcript.ts
-import { createWriteStream, readFileSync as readFileSync6 } from "fs";
+import { createWriteStream, readFileSync as readFileSync7 } from "fs";
 function recordFromLoopEvent(ev, extra) {
   const rec = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3456,7 +3677,7 @@ function openTranscriptFile(path, meta) {
   return stream;
 }
 function readTranscript(path) {
-  const raw = readFileSync6(path, "utf8");
+  const raw = readFileSync7(path, "utf8");
   return parseTranscript(raw);
 }
 function isPlanStateEmptyShape(s) {
@@ -4159,7 +4380,7 @@ var McpClient = class {
 };
 
 // src/mcp/stdio.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 var StdioTransport = class {
   child;
   queue = [];
@@ -4174,14 +4395,14 @@ var StdioTransport = class {
         opts.command,
         ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32"))
       ].join(" ");
-      this.child = spawn2(line, [], {
+      this.child = spawn3(line, [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"],
         shell: true
       });
     } else {
-      this.child = spawn2(opts.command, opts.args ?? [], {
+      this.child = spawn3(opts.command, opts.args ?? [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"]
@@ -4511,7 +4732,7 @@ async function trySection(load) {
 }
 
 // src/code/edit-blocks.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, resolve as resolve6 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
@@ -4540,7 +4761,7 @@ function applyEditBlock(block, rootDir) {
     };
   }
   const searchEmpty = block.search.length === 0;
-  const exists = existsSync6(absTarget);
+  const exists = existsSync7(absTarget);
   try {
     if (!exists) {
       if (!searchEmpty) {
@@ -4554,7 +4775,7 @@ function applyEditBlock(block, rootDir) {
       writeFileSync3(absTarget, block.replace, "utf8");
       return { path: block.path, status: "created" };
     }
-    const content = readFileSync7(absTarget, "utf8");
+    const content = readFileSync8(absTarget, "utf8");
     if (searchEmpty) {
       return {
         path: block.path,
@@ -4588,12 +4809,12 @@ function snapshotBeforeEdits(blocks, rootDir) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
     const abs = resolve6(absRoot, b.path);
-    if (!existsSync6(abs)) {
+    if (!existsSync7(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
     }
     try {
-      snapshots.push({ path: b.path, prevContent: readFileSync7(abs, "utf8") });
+      snapshots.push({ path: b.path, prevContent: readFileSync8(abs, "utf8") });
     } catch {
       snapshots.push({ path: b.path, prevContent: null });
     }
@@ -4613,7 +4834,7 @@ function restoreSnapshots(snapshots, rootDir) {
     }
     try {
       if (snap.prevContent === null) {
-        if (existsSync6(abs)) unlinkSync3(abs);
+        if (existsSync7(abs)) unlinkSync3(abs);
         return {
           path: snap.path,
           status: "applied",
@@ -4636,8 +4857,8 @@ function sep() {
 }
 
 // src/code/prompt.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { join as join7 } from "path";
 var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
 
 # When to propose a plan (submit_plan)
@@ -4712,11 +4933,11 @@ Before exploring the filesystem to answer a factual question, check whether the
 `;
 function codeSystemPrompt(rootDir) {
   const withMemory = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
-  const gitignorePath = join6(rootDir, ".gitignore");
-  if (!existsSync7(gitignorePath)) return withMemory;
+  const gitignorePath = join7(rootDir, ".gitignore");
+  if (!existsSync8(gitignorePath)) return withMemory;
   let content;
   try {
-    content = readFileSync8(gitignorePath, "utf8");
+    content = readFileSync9(gitignorePath, "utf8");
   } catch {
     return withMemory;
   }
@@ -4736,15 +4957,15 @@ ${truncated}
 }
 
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join7 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname4, join as join8 } from "path";
 function defaultConfigPath() {
-  return join7(homedir4(), ".reasonix", "config.json");
+  return join8(homedir5(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync9(path, "utf8");
+    const raw = readFileSync10(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -4779,9 +5000,9 @@ function redactKey(key) {
 }
 
 // src/version.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname5, join as join9 } from "path";
 import { fileURLToPath } from "url";
 var REGISTRY_URL = "https://registry.npmjs.org/reasonix/latest";
 var LATEST_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -4790,9 +5011,9 @@ function readPackageVersion() {
   try {
     let dir = dirname5(fileURLToPath(import.meta.url));
     for (let i = 0; i < 6; i++) {
-      const p = join8(dir, "package.json");
-      if (existsSync8(p)) {
-        const pkg = JSON.parse(readFileSync10(p, "utf8"));
+      const p = join9(dir, "package.json");
+      if (existsSync9(p)) {
+        const pkg = JSON.parse(readFileSync11(p, "utf8"));
         if (pkg?.name === "reasonix" && typeof pkg.version === "string") {
           return pkg.version;
         }
@@ -4807,11 +5028,11 @@ function readPackageVersion() {
 }
 var VERSION = readPackageVersion();
 function cachePath(homeDirOverride) {
-  return join8(homeDirOverride ?? homedir5(), ".reasonix", "version-cache.json");
+  return join9(homeDirOverride ?? homedir6(), ".reasonix", "version-cache.json");
 }
 function readCache(homeDirOverride) {
   try {
-    const raw = readFileSync10(cachePath(homeDirOverride), "utf8");
+    const raw = readFileSync11(cachePath(homeDirOverride), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.version === "string" && typeof parsed.checkedAt === "number") {
       return parsed;
@@ -4878,12 +5099,141 @@ function isNpxInstall() {
   if (ua.includes("npx/")) return true;
   return false;
 }
+
+// src/usage.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync12, statSync as statSync4 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname6, join as join10 } from "path";
+function defaultUsageLogPath(homeDirOverride) {
+  return join10(homeDirOverride ?? homedir7(), ".reasonix", "usage.jsonl");
+}
+function appendUsage(input) {
+  const record = {
+    ts: input.now ?? Date.now(),
+    session: input.session,
+    model: input.model,
+    promptTokens: input.usage.promptTokens,
+    completionTokens: input.usage.completionTokens,
+    cacheHitTokens: input.usage.promptCacheHitTokens,
+    cacheMissTokens: input.usage.promptCacheMissTokens,
+    costUsd: costUsd(input.model, input.usage),
+    claudeEquivUsd: claudeEquivalentCost(input.usage)
+  };
+  const path = input.path ?? defaultUsageLogPath();
+  try {
+    mkdirSync6(dirname6(path), { recursive: true });
+    appendFileSync2(path, `${JSON.stringify(record)}
+`, "utf8");
+  } catch {
+  }
+  return record;
+}
+function readUsageLog(path = defaultUsageLogPath()) {
+  if (!existsSync10(path)) return [];
+  let raw;
+  try {
+    raw = readFileSync12(path, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (isValidRecord(rec)) out.push(rec);
+    } catch {
+    }
+  }
+  return out;
+}
+function isValidRecord(rec) {
+  if (!rec || typeof rec !== "object") return false;
+  const r = rec;
+  return typeof r.ts === "number" && typeof r.model === "string" && typeof r.promptTokens === "number" && typeof r.completionTokens === "number" && typeof r.cacheHitTokens === "number" && typeof r.cacheMissTokens === "number" && typeof r.costUsd === "number" && typeof r.claudeEquivUsd === "number";
+}
+function bucketCacheHitRatio(b) {
+  const denom = b.cacheHitTokens + b.cacheMissTokens;
+  return denom > 0 ? b.cacheHitTokens / denom : 0;
+}
+function bucketSavingsFraction(b) {
+  return b.claudeEquivUsd > 0 ? 1 - b.costUsd / b.claudeEquivUsd : 0;
+}
+function emptyBucket(label, since) {
+  return {
+    label,
+    since,
+    turns: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    cacheHitTokens: 0,
+    cacheMissTokens: 0,
+    costUsd: 0,
+    claudeEquivUsd: 0
+  };
+}
+function addToBucket(b, r) {
+  b.turns += 1;
+  b.promptTokens += r.promptTokens;
+  b.completionTokens += r.completionTokens;
+  b.cacheHitTokens += r.cacheHitTokens;
+  b.cacheMissTokens += r.cacheMissTokens;
+  b.costUsd += r.costUsd;
+  b.claudeEquivUsd += r.claudeEquivUsd;
+}
+function aggregateUsage(records, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const day = 24 * 60 * 60 * 1e3;
+  const today = emptyBucket("today", now - day);
+  const week = emptyBucket("week", now - 7 * day);
+  const month = emptyBucket("month", now - 30 * day);
+  const all = emptyBucket("all-time", 0);
+  const modelCounts = /* @__PURE__ */ new Map();
+  const sessionCounts = /* @__PURE__ */ new Map();
+  let firstSeen = null;
+  let lastSeen = null;
+  for (const r of records) {
+    addToBucket(all, r);
+    if (r.ts >= today.since) addToBucket(today, r);
+    if (r.ts >= week.since) addToBucket(week, r);
+    if (r.ts >= month.since) addToBucket(month, r);
+    modelCounts.set(r.model, (modelCounts.get(r.model) ?? 0) + 1);
+    const sessKey = r.session ?? "(ephemeral)";
+    sessionCounts.set(sessKey, (sessionCounts.get(sessKey) ?? 0) + 1);
+    if (firstSeen === null || r.ts < firstSeen) firstSeen = r.ts;
+    if (lastSeen === null || r.ts > lastSeen) lastSeen = r.ts;
+  }
+  const byModel = Array.from(modelCounts.entries()).map(([model, turns]) => ({ model, turns })).sort((a, b) => b.turns - a.turns);
+  const bySession = Array.from(sessionCounts.entries()).map(([session, turns]) => ({ session, turns })).sort((a, b) => b.turns - a.turns);
+  return {
+    buckets: [today, week, month, all],
+    byModel,
+    bySession,
+    firstSeen,
+    lastSeen
+  };
+}
+function formatLogSize(path = defaultUsageLogPath()) {
+  if (!existsSync10(path)) return "";
+  try {
+    const s = statSync4(path);
+    const bytes = s.size;
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  } catch {
+    return "";
+  }
+}
 export {
   AppendOnlyLog,
   CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
   DEFAULT_MAX_RESULT_CHARS,
   DeepSeekClient,
+  HOOK_EVENTS,
+  HOOK_SETTINGS_DIRNAME,
+  HOOK_SETTINGS_FILENAME,
   ImmutablePrefix,
   LATEST_CACHE_TTL_MS,
   LATEST_FETCH_TIMEOUT_MS,
@@ -4907,21 +5257,27 @@ export {
   VERSION,
   VolatileScratch,
   aggregateBranchUsage,
+  aggregateUsage,
   analyzeSchema,
   appendSessionMessage,
+  appendUsage,
   applyEditBlock,
   applyEditBlocks,
   applyMemoryStack,
   applyProjectMemory,
   applyUserMemory,
   bridgeMcpTools,
+  bucketCacheHitRatio,
+  bucketSavingsFraction,
   claudeEquivalentCost,
   codeSystemPrompt,
   compareVersions,
   computeReplayStats,
   costUsd,
+  decideOutcome,
   defaultConfigPath,
   defaultSelector,
+  defaultUsageLogPath,
   deleteSession,
   diffTranscripts,
   emptyPlanState,
@@ -4929,9 +5285,12 @@ export {
   flattenMcpResult,
   flattenSchema,
   formatCommandResult,
+  formatHookOutcomeMessage,
+  formatLogSize,
   formatLoopError,
   formatSearchResults,
   getLatestVersion,
+  globalSettingsPath,
   harvest,
   healLoadedMessages,
   htmlToText,
@@ -4945,7 +5304,9 @@ export {
   listSessions,
   loadApiKey,
   loadDotenv,
+  loadHooks,
   loadSessionMessages,
+  matchesTool,
   memoryEnabled,
   nestArguments,
   openTranscriptFile,
@@ -4956,10 +5317,12 @@ export {
   parseTranscript,
   prepareSpawn,
   projectHash,
+  projectSettingsPath,
   quoteForCmdExe,
   readConfig,
   readProjectMemory,
   readTranscript,
+  readUsageLog,
   recordFromLoopEvent,
   redactKey,
   registerFilesystemTools,
@@ -4975,6 +5338,7 @@ export {
   restoreSnapshots,
   runBranches,
   runCommand,
+  runHooks,
   sanitizeMemoryName,
   sanitizeName as sanitizeSessionName,
   saveApiKey,