@moikapy/lich 0.7.1 → 0.9.0

package/dist/{chunk-WNFBIX4E.js → chunk-KOEZQUIX.js}

@@ -1,3 +1,39 @@
+import {
+  open_session,
+  safe_json_parse,
+  safe_stringify,
+  truncate_text
+} from "./chunk-TYRKVBWQ.js";
+
+// src/util/log.ts
+var level_order = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var current_level = "info";
+function set_log_level(level) {
+  current_level = level;
+}
+function log(level, message, data) {
+  if (level_order[level] < level_order[current_level]) {
+    return;
+  }
+  const line = `[lich:${level}] ${message}`;
+  if (data === void 0) {
+    console.error(line);
+    return;
+  }
+  console.error(line, data);
+}
+var logger = {
+  debug: (message, data) => log("debug", message, data),
+  info: (message, data) => log("info", message, data),
+  warn: (message, data) => log("warn", message, data),
+  error: (message, data) => log("error", message, data)
+};
+
 // src/tools/builtin/disk_usage.ts
 import { execFile } from "child_process";
 import { readdir } from "fs/promises";
@@ -6,32 +42,6 @@ import path2 from "path";
 // src/tools/guard.ts
 import fs from "fs";
 import path from "path";
-
-// src/util/json.ts
-function safe_json_parse(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-}
-function safe_stringify(value, space) {
-  try {
-    return JSON.stringify(value, null, space) ?? String(value);
-  } catch {
-    return String(value);
-  }
-}
-function truncate_text(text, max_chars) {
-  if (text.length <= max_chars) {
-    return text;
-  }
-  const omitted = text.length - max_chars;
-  return `${text.slice(0, max_chars)}
-[... truncated, ${omitted} chars omitted ...]`;
-}
-
-// src/tools/guard.ts
 var DEFAULT_MAX_OUTPUT_CHARS = 2e4;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e4;
 function is_inside(base, candidate) {
@@ -176,6 +186,38 @@ async function capture_errors(run) {
   }
 }
 
+// src/tools/read_clamped.ts
+async function read_clamped_text(response, max_bytes) {
+  if (response.body === null) {
+    const text = await response.text();
+    const bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > max_bytes) {
+      return { text: text.slice(0, max_bytes), bytes_read: max_bytes, truncated: true };
+    }
+    return { text, bytes_read: bytes, truncated: false };
+  }
+  return read_stream(response.body.getReader(), max_bytes);
+}
+async function read_stream(reader, max_bytes) {
+  const chunks = [];
+  let bytes_read = 0;
+  let truncated = false;
+  while (bytes_read < max_bytes) {
+    const { done, value } = await reader.read();
+    if (done === true || value === void 0) break;
+    const room = max_bytes - bytes_read;
+    const take = value.byteLength > room ? value.subarray(0, room) : value;
+    chunks.push(Buffer.from(take));
+    bytes_read += take.byteLength;
+    if (value.byteLength > room) {
+      truncated = true;
+      await reader.cancel().catch(() => void 0);
+      break;
+    }
+  }
+  return { text: Buffer.concat(chunks).toString("utf8"), bytes_read, truncated };
+}
+
 // src/tools/url_guard.ts
 import dns from "dns/promises";
 import http from "http";
@@ -408,6 +450,7 @@ var DEFAULT_MAX_CHARS = 2e4;
 var MAX_MAX_CHARS = 1e5;
 var DEFAULT_TIMEOUT_MS = 2e4;
 var MAX_TIMEOUT_MS = 6e4;
+var MAX_BODY_BYTES = MAX_MAX_CHARS * 4;
 var USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36";
 var parameters = {
   type: "object",
@@ -445,16 +488,17 @@ async function run_fetch_url(args, external) {
   if (content_type.startsWith("image/") === true || content_type.startsWith("application/octet-stream") === true) {
     return { ok: false, output: "", error: `unsupported_content_type: ${content_type}` };
   }
-  const text = await response.text();
+  const byte_budget = Math.min(MAX_BODY_BYTES, max_chars * 4);
+  const clamped = await read_clamped_text(response, byte_budget);
   const marker = content_type.toLowerCase().includes("text/html") === true ? "[html content]\n" : "";
-  const body = clamp_output(`${marker}${text}`, max_chars);
-  return { ok: true, output: `${header_line(response, text)}
+  const body = clamp_output(`${marker}${clamped.text}`, max_chars);
+  return { ok: true, output: `${header_line(response, clamped.bytes_read)}
 ${body}` };
 }
-function header_line(response, text) {
+function header_line(response, bytes_read) {
   const content_type = response.headers.get("content-type") ?? "unknown";
   const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
-  const bytes = Number.isFinite(declared) === true ? declared : Buffer.byteLength(text, "utf8");
+  const bytes = Number.isFinite(declared) === true ? declared : bytes_read;
   return `# ${response.status} ${content_type} (${bytes} bytes)`;
 }
 var fetch_url_tool = {
@@ -1013,17 +1057,21 @@ var env_get_tool = {
 // src/tools/builtin/grep_files.ts
 import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
 import path5 from "path";
+import vm from "vm";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".lich", ".cursor"]);
 var MAX_FILE_BYTES = 1e6;
 var SNIFF_BYTES = 1e3;
 var DEFAULT_MAX_RESULTS2 = 200;
+var MAX_MAX_RESULTS = 2e3;
+var MAX_LINE_CHARS = 4e3;
+var REGEX_TIMEOUT_MS = 50;
 var parameters7 = {
   type: "object",
   properties: {
     pattern: { type: "string", description: "Regular expression source to match against each line" },
     path: { type: "string", description: "Directory or file to search, relative to the working directory (default .)" },
     glob: { type: "string", description: "Simple filename filter like *.ts (suffix match only)" },
-    max_results: { type: "number", description: "Stop after this many matches (default 200)" }
+    max_results: { type: "number", description: "Stop after this many matches (default 200, max 2000)" }
   },
   required: ["pattern"],
   additionalProperties: false
@@ -1060,12 +1108,46 @@ async function read_if_text(file_path, size) {
     return void 0;
   }
 }
-function match_lines(lines, regex) {
+var regex_sandbox = {
+  re: /$^/,
+  line: "",
+  matched: false
+};
+vm.createContext(regex_sandbox);
+var regex_script = new vm.Script("matched = re.test(line)");
+function safe_regex_test(regex, line) {
+  regex_sandbox.re = regex;
+  regex_sandbox.line = line;
+  try {
+    regex_script.runInContext(regex_sandbox, { timeout: REGEX_TIMEOUT_MS });
+  } catch {
+    return false;
+  }
+  return Boolean(regex_sandbox.matched);
+}
+function has_nested_quantifiers(pattern) {
+  return /(\([^)]*[+*][^)]*\)[+*])/.test(pattern) === true;
+}
+function is_literal_pattern(pattern) {
+  return /^[A-Za-z0-9_./:@-]+$/.test(pattern) === true;
+}
+function line_matches(regex, pattern, line) {
+  const capped = line.length > MAX_LINE_CHARS ? line.slice(0, MAX_LINE_CHARS) : line;
+  if (is_literal_pattern(pattern) === true) {
+    return capped.includes(pattern);
+  }
+  return safe_regex_test(regex, capped);
+}
+function match_lines(lines, regex, pattern) {
   const hits = [];
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index];
-    if (line !== void 0 && regex.test(line) === true) {
-      hits.push({ line_no: index + 1, text: line.trim() });
+    if (line === void 0) {
+      continue;
+    }
+    const capped = line.length > MAX_LINE_CHARS ? line.slice(0, MAX_LINE_CHARS) : line;
+    if (line_matches(regex, pattern, capped) === true) {
+      hits.push({ line_no: index + 1, text: capped.trim() });
     }
   }
   return hits;
@@ -1073,7 +1155,6 @@ function match_lines(lines, regex) {
 async function safe_readdir(dir) {
   try {
     return await readdir2(dir, { withFileTypes: true });
-    abort_marker: ;
   } catch {
     return void 0;
   }
@@ -1112,7 +1193,13 @@ function guard_grep_target(work_dir, absolute) {
   assert_file_tool_access(work_dir, safe, "read");
   return safe;
 }
-async function search_file(frame, work_dir, relative_root, regex, collected, max_results) {
+function throw_if_aborted(signal) {
+  if (signal?.aborted === true) {
+    throw new Error("cancelled");
+  }
+}
+async function search_file(frame, work_dir, relative_root, regex, pattern, collected, max_results, signal) {
+  throw_if_aborted(signal);
   let safe;
   try {
     safe = guard_grep_target(work_dir, frame.dir);
@@ -1125,7 +1212,7 @@ async function search_file(frame, work_dir, relative_root, regex, collected, max
     return false;
   }
   const relative = path5.relative(relative_root, safe);
-  for (const hit of match_lines(lines, regex)) {
+  for (const hit of match_lines(lines, regex, pattern)) {
     collected.push(`${relative}:${hit.line_no}: ${hit.text}`);
     if (collected.length >= max_results) {
       return true;
@@ -1133,17 +1220,18 @@ async function search_file(frame, work_dir, relative_root, regex, collected, max
   }
   return false;
 }
-async function search_tree(root, work_dir, regex, matcher, max_results) {
+async function search_tree(root, work_dir, regex, pattern, matcher, max_results, signal) {
   const collected = [];
   const stack = [{ dir: root, name: root }];
   while (stack.length > 0 && collected.length < max_results) {
+    throw_if_aborted(signal);
     const frame = stack.pop();
     if (frame === void 0) {
       break;
     }
     const found = await scan_dir(frame, matcher);
     for (const file of found.files) {
-      const hit_cap = await search_file(file, work_dir, root, regex, collected, max_results);
+      const hit_cap = await search_file(file, work_dir, root, regex, pattern, collected, max_results, signal);
       if (hit_cap === true) {
         break;
       }
@@ -1163,27 +1251,32 @@ function finalize_output(matches, max_results) {
   }
   return matches.join("\n");
 }
-function search_file_direct(file_path, work_dir, regex, collected, max_results) {
+function search_file_direct(file_path, work_dir, regex, pattern, collected, max_results, signal) {
   return search_file(
     { dir: file_path, name: path5.basename(file_path) },
     work_dir,
     path5.dirname(file_path),
     regex,
+    pattern,
     collected,
-    max_results
+    max_results,
+    signal
   );
 }
-async function collect_file_matches(root, work_dir, regex, matcher, max_results) {
+async function collect_file_matches(root, work_dir, regex, pattern, matcher, max_results, signal) {
   const collected = [];
   if (matcher(path5.basename(root)) === true) {
-    await search_file_direct(root, work_dir, regex, collected, max_results);
+    await search_file_direct(root, work_dir, regex, pattern, collected, max_results, signal);
   }
   return collected;
 }
-async function run_grep(args, work_dir) {
+function clamp_max_results(raw) {
+  return Math.min(MAX_MAX_RESULTS, Math.max(1, Math.floor(raw)));
+}
+async function run_grep(args, work_dir, signal) {
   const pattern = require_string_arg(args, "pattern");
   const target = optional_string_arg(args, "path", ".");
-  const max_results = Math.max(1, Math.floor(optional_number_arg(args, "max_results", DEFAULT_MAX_RESULTS2)));
+  const max_results = clamp_max_results(optional_number_arg(args, "max_results", DEFAULT_MAX_RESULTS2));
   const glob = optional_string_arg(args, "glob", "");
   let regex;
   try {
@@ -1191,12 +1284,15 @@ async function run_grep(args, work_dir) {
   } catch {
     throw new Error(`invalid_regex: ${pattern}`);
   }
+  if (has_nested_quantifiers(pattern) === true) {
+    throw new Error(`unsafe_regex: nested quantifiers are not supported (${pattern})`);
+  }
   const matcher = glob.length > 0 ? glob_matcher(glob) : () => true;
   const root = resolve_safe_path(work_dir, target);
   assert_file_tool_access(work_dir, root, "read");
   const root_stat = await stat(root);
   const cap = max_results + 1;
-  const matches = root_stat.isDirectory() === true ? await search_tree(root, work_dir, regex, matcher, cap) : await collect_file_matches(root, work_dir, regex, matcher, cap);
+  const matches = root_stat.isDirectory() === true ? await search_tree(root, work_dir, regex, pattern, matcher, cap, signal) : await collect_file_matches(root, work_dir, regex, pattern, matcher, cap, signal);
   return finalize_output(matches, max_results);
 }
 var grep_files_tool = {
@@ -1204,7 +1300,7 @@ var grep_files_tool = {
   description: "Search files line-by-line with a regex, skipping node_modules/.git/dist and binary files.",
   parameters: parameters7,
   execute: async (args, context) => capture_errors(async () => {
-    const output = await run_grep(args, context.work_dir);
+    const output = await run_grep(args, context.work_dir, context.signal);
     return { ok: true, output };
   })
 };
@@ -1214,6 +1310,7 @@ var DEFAULT_TIMEOUT_MS2 = 3e4;
 var MAX_TIMEOUT_MS2 = 12e4;
 var DEFAULT_MAX_CHARS2 = 2e4;
 var MAX_MAX_CHARS2 = 1e5;
+var MAX_BODY_BYTES2 = MAX_MAX_CHARS2 * 4;
 var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REPORTED_HEADERS = ["content-length", "ratelimit-remaining", "retry-after"];
 var parameters8 = {
@@ -1278,13 +1375,14 @@ async function run_http(args, external) {
   }
   const response = await safe_fetch(url, init);
   const content_type = response.headers.get("content-type") ?? "unknown";
-  const text = await response.text();
+  const byte_budget = Math.min(MAX_BODY_BYTES2, max_chars * 4);
+  const clamped = await read_clamped_text(response, byte_budget);
   const sections = [
     `# status ${response.status}`,
     `# content-type ${content_type}`,
     ...header_lines(response),
     "",
-    clamp_output(text, max_chars)
+    clamp_output(clamped.text, max_chars)
   ];
   return { ok: true, output: sections.join("\n") };
 }
@@ -1390,7 +1488,7 @@ var list_dir_tool = {
 // src/tools/builtin/process_list.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
 var DEFAULT_MAX_RESULTS3 = 50;
-var MAX_MAX_RESULTS = 500;
+var MAX_MAX_RESULTS2 = 500;
 var CMDLINE_MAX_CHARS = 200;
 var PROC_DIR = "/proc";
 var PID_PATTERN = /^[0-9]+$/;
@@ -1445,7 +1543,7 @@ function collect_lines2(filter, max_results) {
 }
 function run_process_list(args) {
   const filter = optional_string_arg(args, "filter", "").toLowerCase();
-  const max_results = clamp_int_arg(args, "max_results", DEFAULT_MAX_RESULTS3, MAX_MAX_RESULTS);
+  const max_results = clamp_int_arg(args, "max_results", DEFAULT_MAX_RESULTS3, MAX_MAX_RESULTS2);
   let listing;
   try {
     listing = collect_lines2(filter, max_results);
@@ -1515,6 +1613,46 @@ var read_file_tool = {
 // src/tools/builtin/run_tests.ts
 import { spawn as spawn2 } from "child_process";
 
+// src/tools/process_group.ts
+var live_children = /* @__PURE__ */ new Set();
+var exit_handlers_installed = false;
+function kill_all_live_children() {
+  for (const child of live_children) {
+    kill_process_group(child, "SIGKILL");
+  }
+  live_children.clear();
+}
+function install_exit_handlers() {
+  if (exit_handlers_installed === true) {
+    return;
+  }
+  exit_handlers_installed = true;
+  process.on("exit", kill_all_live_children);
+}
+function track_detached_child(child) {
+  install_exit_handlers();
+  live_children.add(child);
+  const drop = () => {
+    live_children.delete(child);
+  };
+  child.on("exit", drop);
+  child.on("error", drop);
+}
+function kill_process_group(child, signal = "SIGKILL") {
+  const pid = child.pid;
+  if (pid === void 0) {
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  }
+}
+
 // src/tools/builtin/terminal.ts
 import { spawn } from "child_process";
 
@@ -1590,12 +1728,13 @@ function scrub_spawn_env(process_env, context_env) {
   return scrubbed;
 }
 function wire_kill(child, timeout_signal, external) {
-  timeout_signal.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
-  external?.addEventListener("abort", () => child.kill("SIGKILL"), { once: true });
+  const kill = () => kill_process_group(child, "SIGKILL");
+  timeout_signal.addEventListener("abort", kill, { once: true });
+  external?.addEventListener("abort", kill, { once: true });
 }
-function wait_close(child) {
+function wait_exit(child) {
   return new Promise((resolve) => {
-    child.on("close", (code) => resolve(code ?? -1));
+    child.on("exit", (code) => resolve(code ?? -1));
     child.on("error", () => resolve(-1));
   });
 }
@@ -1604,22 +1743,26 @@ async function run_command(command, work_dir, env, timeout_ms, external) {
   const stderr = { text: "" };
   const child = spawn("bash", ["-lc", command], {
     cwd: work_dir,
-    env: scrub_spawn_env(process.env, env)
+    env: scrub_spawn_env(process.env, env),
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
   });
-  child.stdout.on("data", (chunk) => stream_chunk(stdout, chunk));
-  child.stderr.on("data", (chunk) => stream_chunk(stderr, chunk));
-  const close_promise = wait_close(child);
+  track_detached_child(child);
+  child.stdout?.on("data", (chunk) => stream_chunk(stdout, chunk));
+  child.stderr?.on("data", (chunk) => stream_chunk(stderr, chunk));
+  const exit_promise = wait_exit(child);
   let timed_out = false;
   let exit_code;
   try {
     exit_code = await with_timeout((timeout_signal) => {
       wire_kill(child, timeout_signal, external);
-      return close_promise;
+      return exit_promise;
     }, timeout_ms, "terminal");
   } catch (err) {
     if (err instanceof ToolTimeoutError === true) {
       timed_out = true;
-      exit_code = await close_promise;
+      kill_process_group(child, "SIGKILL");
+      exit_code = await exit_promise;
     } else {
       throw err;
     }
@@ -1630,7 +1773,7 @@ async function run_command(command, work_dir, env, timeout_ms, external) {
 }
 function terminal_result(outcome) {
   const result = {
-    ok: outcome.exit_code === 0 && outcome.cancelled === false,
+    ok: outcome.exit_code === 0 && outcome.cancelled === false && outcome.timed_out === false,
     output: clamp_output(outcome.output)
   };
   if (outcome.cancelled === true) {
@@ -1656,28 +1799,43 @@ var terminal_tool = {
 // src/tools/builtin/run_tests.ts
 var MAX_OUTPUT_CHARS = 2e3;
 var DEFAULT_TEST_COMMAND = "node node_modules/vitest/vitest.mjs run";
+var DEFAULT_TIMEOUT_MS4 = 6e5;
+var MAX_TIMEOUT_MS4 = 6e5;
 var parameters13 = {
   type: "object",
   properties: {
     filter: {
       type: "string",
       description: "Optional test-file filter appended to the test command (e.g. a vitest file filter)"
+    },
+    timeout_ms: {
+      type: "number",
+      description: "Kill the suite after this many ms (default 600000, max 600000)"
     }
   },
   additionalProperties: false
 };
 var busy = false;
 var run_test_command = default_runner;
-function default_runner(command, cwd, on_chunk) {
+function wire_kill2(child, signal) {
+  if (signal === void 0) {
+    return;
+  }
+  signal.addEventListener("abort", () => kill_process_group(child, "SIGKILL"), { once: true });
+}
+function default_runner(command, cwd, on_chunk, signal) {
   const child = spawn2("bash", ["-lc", command], {
     cwd,
     env: scrub_spawn_env(process.env, {}),
+    detached: true,
     stdio: ["ignore", "pipe", "pipe"]
   });
+  track_detached_child(child);
   child.stdout?.on("data", (chunk) => on_chunk("stdout", chunk));
   child.stderr?.on("data", (chunk) => on_chunk("stderr", chunk));
+  wire_kill2(child, signal);
   return new Promise((resolve) => {
-    child.on("close", (code) => resolve({ exit_code: code ?? -1 }));
+    child.on("exit", (code) => resolve({ exit_code: code ?? -1 }));
     child.on("error", () => resolve({ exit_code: -1 }));
   });
 }
@@ -1688,11 +1846,21 @@ function build_command(filter, env) {
   const base = optional_string_arg(env, "LICH_TEST_COMMAND", DEFAULT_TEST_COMMAND);
   return filter === void 0 ? base : `${base} ${shell_quote(filter)}`;
 }
+function clamp_timeout2(raw) {
+  return Math.min(MAX_TIMEOUT_MS4, Math.max(1, Math.floor(raw)));
+}
+function append_clamped(current, chunk, budget) {
+  if (current.length >= budget) {
+    return current;
+  }
+  const next = current + chunk.toString("utf8");
+  return next.length > budget ? next.slice(0, budget) : next;
+}
 var run_tests_tool = {
   name: "run_tests",
   description: "Run the project's test suite via LICH_TEST_COMMAND (default: vitest) in work_dir and report a structured pass/fail result with clamped output.",
   parameters: parameters13,
-  timeout_ms: 6e5,
+  timeout_ms: MAX_TIMEOUT_MS4,
   execute: async (args, context) => capture_errors(async () => {
     if (busy === true) {
       return { ok: false, output: "", error: "run_tests_busy" };
@@ -1703,17 +1871,44 @@ var run_tests_tool = {
       if (filter.startsWith("-") === true) {
         return { ok: false, output: "", error: "invalid_filter: must not start with -" };
       }
+      const timeout_ms = clamp_timeout2(optional_number_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS4));
       const command = build_command(filter === "" ? void 0 : filter, context.env);
       const streams = { stdout: "", stderr: "" };
       const on_chunk = (stream, chunk) => {
-        streams[stream] = streams[stream] + chunk.toString("utf8");
+        streams[stream] = append_clamped(streams[stream], chunk, MAX_OUTPUT_CHARS);
       };
-      const outcome = await run_test_command(command, context.work_dir, on_chunk);
-      const ok = outcome.exit_code === 0;
+      let timed_out = false;
+      let exit_code;
+      try {
+        const outcome = await with_timeout((timeout_signal) => {
+          const signals = [timeout_signal];
+          if (context.signal !== void 0) {
+            signals.push(context.signal);
+          }
+          return run_test_command(command, context.work_dir, on_chunk, AbortSignal.any(signals));
+        }, timeout_ms, "run_tests");
+        exit_code = outcome.exit_code;
+      } catch (err) {
+        if (err instanceof ToolTimeoutError === true) {
+          timed_out = true;
+          exit_code = -1;
+        } else {
+          throw err;
+        }
+      }
+      if (timed_out === true || context.signal?.aborted === true) {
+        return {
+          ok: false,
+          output: clamp_output(`${streams.stdout}${streams.stderr}
+[exit ${exit_code}]`, MAX_OUTPUT_CHARS),
+          error: timed_out === true ? "timeout" : "cancelled"
+        };
+      }
+      const ok = exit_code === 0;
       return {
         ok,
         output: clamp_output(`${streams.stdout}${streams.stderr}
-[exit ${outcome.exit_code}]`, MAX_OUTPUT_CHARS),
+[exit ${exit_code}]`, MAX_OUTPUT_CHARS),
         ...ok ? {} : { error: "tests_failed" }
       };
     } finally {
@@ -1725,8 +1920,9 @@ var run_tests_tool = {
 // src/tools/builtin/web_search.ts
 var DEFAULT_MAX_RESULTS4 = 8;
 var MAX_RESULTS = 20;
-var DEFAULT_TIMEOUT_MS4 = 2e4;
-var MAX_TIMEOUT_MS4 = 6e4;
+var DEFAULT_TIMEOUT_MS5 = 2e4;
+var MAX_TIMEOUT_MS5 = 6e4;
+var MAX_SEARCH_BODY_BYTES = 512e3;
 var SEARCH_ENDPOINT = "https://html.duckduckgo.com/html/?q=";
 var REDIRECT_PREFIXES = ["//duckduckgo.com/l/?", "/l/?"];
 var RESULT_PATTERN = /<a[^>]+class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
@@ -1805,7 +2001,7 @@ function format_results(hits) {
 async function run_search(args, external) {
   const query = require_string_arg(args, "query");
   const max_results = clamp_int_arg(args, "max_results", DEFAULT_MAX_RESULTS4, MAX_RESULTS);
-  const timeout_ms = clamp_int_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS4, MAX_TIMEOUT_MS4);
+  const timeout_ms = clamp_int_arg(args, "timeout_ms", DEFAULT_TIMEOUT_MS5, MAX_TIMEOUT_MS5);
   try {
     const response = await fetch(`${SEARCH_ENDPOINT}${encodeURIComponent(query)}`, {
       headers: { "user-agent": USER_AGENT, "accept-language": "en" },
@@ -1814,7 +2010,8 @@ async function run_search(args, external) {
     if (response.ok === false) {
       return { ok: false, output: "", error: `search_failed: http_${response.status}` };
     }
-    const hits = parse_results(await response.text(), max_results);
+    const clamped = await read_clamped_text(response, MAX_SEARCH_BODY_BYTES);
+    const hits = parse_results(clamped.text, max_results);
     return { ok: true, output: hits.length === 0 ? "no results" : format_results(hits) };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1866,35 +2063,6 @@ var write_file_tool = {
   })
 };
 
-// src/util/log.ts
-var level_order = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40
-};
-var current_level = "info";
-function set_log_level(level) {
-  current_level = level;
-}
-function log(level, message, data) {
-  if (level_order[level] < level_order[current_level]) {
-    return;
-  }
-  const line = `[lich:${level}] ${message}`;
-  if (data === void 0) {
-    console.error(line);
-    return;
-  }
-  console.error(line, data);
-}
-var logger = {
-  debug: (message, data) => log("debug", message, data),
-  info: (message, data) => log("info", message, data),
-  warn: (message, data) => log("warn", message, data),
-  error: (message, data) => log("error", message, data)
-};
-
 // src/tools/builtin/index.ts
 var core_tools = [
   read_file_tool,
@@ -2030,9 +2198,23 @@ var ToolExecutor = class {
 };
 
 // src/plugins/hooks.ts
+import { AsyncLocalStorage } from "async_hooks";
 var SUMMARY_MAX_CHARS = 300;
+var run_als = new AsyncLocalStorage();
 var plugin_state = /* @__PURE__ */ new WeakMap();
+function bags_for_run() {
+  return run_als.getStore();
+}
 function hook_state_for(plugin) {
+  const bags = bags_for_run();
+  if (bags !== void 0) {
+    let state2 = bags.get(plugin);
+    if (state2 === void 0) {
+      state2 = /* @__PURE__ */ new Map();
+      bags.set(plugin, state2);
+    }
+    return state2;
+  }
   let state = plugin_state.get(plugin);
   if (state === void 0) {
     state = /* @__PURE__ */ new Map();
@@ -2040,6 +2222,16 @@ function hook_state_for(plugin) {
   }
   return state;
 }
+function reset_plugin_bag(plugin) {
+  const fresh = /* @__PURE__ */ new Map();
+  const bags = bags_for_run();
+  if (bags !== void 0) {
+    bags.set(plugin, fresh);
+  } else {
+    plugin_state.set(plugin, fresh);
+  }
+  return fresh;
+}
 function with_hook_state(base, plugin) {
   return { ...base, state: hook_state_for(plugin) };
 }
@@ -2053,6 +2245,17 @@ var HookedToolRunner = class {
     this.wrapped = wrapped;
     this.hooked_plugins = plugins.filter((plugin) => plugin.hooks !== void 0);
   }
+  /**
+   * Isolate plugin state for one Agent.run so concurrent runs on the same
+   * Agent cannot reset each other's bags (M-6).
+   */
+  run_scope(fn) {
+    const bags = /* @__PURE__ */ new Map();
+    for (const plugin of this.hooked_plugins) {
+      bags.set(plugin, /* @__PURE__ */ new Map());
+    }
+    return run_als.run(bags, fn);
+  }
   /** Run before hooks in order; the first {block: true} verdict wins. */
   async run_before_hooks(info, base) {
     for (const plugin of this.hooked_plugins) {
@@ -2107,7 +2310,7 @@ var HookedToolRunner = class {
   /** Best-effort on_run_start fan-out used by Agent.run; never throws. Swaps in a fresh state sub-map per hooked plugin first. */
   async call_run_start(info, base) {
     for (const plugin of this.hooked_plugins) {
-      plugin_state.set(plugin, /* @__PURE__ */ new Map());
+      reset_plugin_bag(plugin);
     }
     for (const plugin of this.hooked_plugins) {
       const hook = plugin.hooks?.on_run_start;
@@ -2238,116 +2441,549 @@ var ProviderError = class extends Error {
   }
 };
 
-// src/agent/config.ts
-import { z } from "zod";
-
-// src/gateway/access.ts
-var PUBLIC_PLATFORMS = /* @__PURE__ */ new Set(["telegram", "discord", "twitch"]);
-var DEFAULT_GATEWAY_TOOLS_ENABLED = [
-  "read_file",
-  "list_dir",
-  "grep_files",
-  "fetch_url",
-  "web_search",
-  "docs_read",
-  "docs_search"
-];
-function gateway_tools_enabled(config) {
-  return config.gateway?.tools_enabled ?? DEFAULT_GATEWAY_TOOLS_ENABLED;
+// src/context/tokens.ts
+var TOOL_MESSAGE_OVERHEAD_TOKENS = 8;
+function estimate_text_tokens(text) {
+  return Math.ceil(text.length / 4);
 }
-function is_gateway_sender_allowed(config, platform, chat_id, user_id) {
-  if (PUBLIC_PLATFORMS.has(platform) === false) {
-    return true;
+function estimate_message_tokens(message) {
+  const content_tokens = estimate_text_tokens(message.content);
+  if (message.role === "assistant" && message.tool_calls !== void 0) {
+    return content_tokens + estimate_text_tokens(safe_stringify(message.tool_calls));
   }
-  const users = config.gateway?.allowed_users?.[platform] ?? [];
-  const chats = config.gateway?.allowed_chats?.[platform] ?? [];
-  if (users.length === 0 && chats.length === 0) {
-    return false;
+  if (message.role === "tool") {
+    return content_tokens + TOOL_MESSAGE_OVERHEAD_TOKENS;
   }
-  const user_ok = users.length === 0 || users.includes(user_id);
-  const chat_ok = chats.length === 0 || chats.includes(chat_id);
-  return user_ok && chat_ok;
+  return content_tokens;
 }
-function check_gateway_sender(config, platform, chat_id, user_id) {
-  if (is_gateway_sender_allowed(config, platform, chat_id, user_id) === true) {
-    return true;
-  }
-  logger.warn(`gateway denied ${platform} chat=${chat_id} user=${user_id}`);
-  return false;
+function estimate_messages_tokens(messages) {
+  return messages.reduce((total, message) => total + estimate_message_tokens(message), 0);
 }
 
-// src/mcp/mcp_pin.ts
-import path11 from "path";
-
-// src/mcp/mcp_catalog.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
-import path9 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var cached;
-function catalog_dir() {
-  let dir = path9.dirname(fileURLToPath2(import.meta.url));
-  for (let hop = 0; hop < 6; hop += 1) {
-    const candidate = path9.join(dir, "optional-mcps");
-    if (existsSync2(path9.join(candidate, "redot", "manifest.json")) === true) {
-      return candidate;
-    }
-    dir = path9.dirname(dir);
-  }
-  throw new Error("mcp catalog not found");
+// src/context/compressor.ts
+var COMPRESSION_SYSTEM_PROMPT = "You compress agent conversation history into terse factual summaries. Preserve: goals, decisions, file paths, commands run, errors, open questions. Output plain text only.";
+var MIN_TRANSCRIPT_CHARS = 8e3;
+var MAX_TRANSCRIPT_CHARS = 96e3;
+var CHARS_PER_BUDGET_TOKEN = 0.24;
+var MIN_PER_MESSAGE_CHARS = 256;
+function should_compress(messages, budget_tokens, threshold) {
+  return estimate_messages_tokens(messages) >= budget_tokens * threshold;
 }
-function read_manifest(file) {
-  const parsed = safe_json_parse(readFileSync4(file, "utf8"));
-  if (parsed === void 0 || typeof parsed.name !== "string") {
-    throw new Error("mcp catalog manifest rejected");
-  }
-  return parsed;
+function transcript_char_budget(budget_tokens) {
+  const scaled = Math.floor(Math.max(0, budget_tokens) * CHARS_PER_BUDGET_TOKEN);
+  return Math.min(MAX_TRANSCRIPT_CHARS, Math.max(MIN_TRANSCRIPT_CHARS, scaled));
 }
-function load_catalog() {
-  if (cached !== void 0) {
-    return cached;
+function truncate_head_tail(text, max_chars) {
+  if (max_chars <= 0) {
+    return "";
   }
-  const manifests = [];
-  for (const name of readdirSync3(catalog_dir())) {
-    const file = path9.join(catalog_dir(), name, "manifest.json");
-    if (existsSync2(file) === true) {
-      manifests.push(read_manifest(file));
-    }
+  if (text.length <= max_chars) {
+    return text;
   }
-  cached = manifests;
-  return cached;
+  if (max_chars < 40) {
+    return text.slice(0, max_chars);
+  }
+  const marker_budget = 28;
+  const half = Math.floor((max_chars - marker_budget) / 2);
+  const omitted = text.length - half * 2;
+  return `${text.slice(0, half)}
+[...${omitted} chars...]
+${text.slice(-half)}`;
 }
-function catalog_by_name(name) {
-  return load_catalog().find((entry) => entry.name === name);
+function format_history_line(message) {
+  const rendered_calls = message.role === "assistant" && message.tool_calls !== void 0 ? ` tool_calls=${safe_stringify(message.tool_calls)}` : "";
+  return `[${message.role}] ${message.content}${rendered_calls}`;
 }
-
-// src/mcp/mcp_refuse.ts
-import path10 from "path";
-var SHELL = /[;&|`$<>]/;
-var DOWNLOADERS = /* @__PURE__ */ new Set(["npx", "npm", "bunx", "uvx", "curl", "wget"]);
-function refuse_stdio_command(command) {
-  if (command.includes("://") === true) {
-    return "refused url; only a local binary is allowed";
-  }
-  if (SHELL.test(command) === true) {
-    return "refused shell metacharacters in mcp command";
-  }
-  if (command.length === 0 || command.trim() !== command || /\s/.test(command) === true) {
-    return "refused mcp command";
+function format_capped_transcript(older, max_chars) {
+  if (older.length === 0) {
+    return "";
   }
-  const base = path10.basename(command);
-  if (DOWNLOADERS.has(base) === true) {
-    return `refused download command '${base}'`;
+  const per_message = Math.max(MIN_PER_MESSAGE_CHARS, Math.floor(max_chars / older.length));
+  const lines = older.map((message) => truncate_head_tail(format_history_line(message), per_message));
+  const joined = lines.join("\n");
+  if (joined.length <= max_chars) {
+    return joined;
   }
-  return void 0;
+  return truncate_head_tail(joined, max_chars);
 }
-function refuse_stdio_arg(arg) {
-  if (arg.includes("://") === true) {
-    return "refused url in mcp args";
-  }
-  if (SHELL.test(arg) === true) {
-    return "refused shell metacharacters in mcp args";
-  }
-  return void 0;
+function build_summary_request(older, model_hint, budget_tokens) {
+  const max_chars = transcript_char_budget(budget_tokens);
+  const transcript = format_capped_transcript(older, max_chars);
+  const hint = model_hint === void 0 ? "" : `
+(Continuing agent run as model: ${model_hint})`;
+  return {
+    role: "user",
+    content: "Summarize the following earlier conversation so the agent can continue the task from the summary alone.\n\n" + transcript + hint
+  };
+}
+function log_compression_failure(error) {
+  if (error instanceof ProviderError) {
+    logger.warn(`context compression failed kind=${error.kind} provider=${error.provider_name}`, error);
+    return;
+  }
+  logger.warn("context compression failed", error);
+}
+function split_keep_recent(non_system, keep_recent) {
+  let cut = Math.max(0, non_system.length - keep_recent);
+  while (cut > 0 && non_system[cut]?.role === "tool") {
+    cut -= 1;
+  }
+  return { recent: non_system.slice(cut), older: non_system.slice(0, cut) };
+}
+async function compress_messages(deps, messages, params) {
+  const system_messages = messages.filter((message) => message.role === "system");
+  const non_system = messages.filter((message) => message.role !== "system");
+  const keep_recent = Math.max(0, params.keep_recent);
+  const { recent, older } = split_keep_recent(non_system, keep_recent);
+  if (older.length === 0) {
+    return { messages: [...messages], summary_chars: 0 };
+  }
+  try {
+    const result = await deps.chat(
+      [
+        { role: "system", content: COMPRESSION_SYSTEM_PROMPT },
+        build_summary_request(older, params.model_hint, params.budget_tokens)
+      ],
+      [],
+      { signal: params.signal }
+    );
+    const summary = result.message.content;
+    const summary_message = {
+      role: "user",
+      content: `[context summary of earlier turns]
+${summary}
+[end summary]`
+    };
+    return { messages: [...system_messages, summary_message, ...recent], summary_chars: summary.length };
+  } catch (error) {
+    log_compression_failure(error);
+    return { messages: [...messages], summary_chars: 0 };
+  }
+}
+
+// src/agent/loop.ts
+var DEFAULT_COMPRESS_THRESHOLD = 0.8;
+var KEEP_RECENT_TURNS = 8;
+var COMPRESS_BACKOFF_TURNS = 3;
+function turn_range(max_turns) {
+  return Array.from({ length: Math.max(0, max_turns) }, (_unused, index) => index + 1);
+}
+function seed_system_prompt(messages, system_prompt) {
+  const history = [...messages];
+  if (system_prompt === void 0) {
+    return history;
+  }
+  const system_index = history.findIndex((message) => message.role === "system");
+  if (system_index === -1) {
+    const seeded = { role: "system", content: system_prompt };
+    return [seeded, ...history];
+  }
+  const existing = history[system_index];
+  if (existing !== void 0 && existing.content === system_prompt) {
+    return history;
+  }
+  const replaced = { role: "system", content: system_prompt };
+  return [...history.slice(0, system_index), replaced, ...history.slice(system_index + 1)];
+}
+function format_tool_result_content(result) {
+  if (result.error !== void 0) {
+    return JSON.stringify({ ok: false, output: result.output, error: result.error });
+  }
+  return result.output;
+}
+function tool_message_from_result(call, result) {
+  const tool_message = {
+    role: "tool",
+    tool_call_id: call.id,
+    name: call.name,
+    content: format_tool_result_content(result)
+  };
+  if (result.ok !== true) {
+    tool_message.is_error = true;
+  }
+  return tool_message;
+}
+async function run_tool_calls(deps, history, turn, calls, emitter, signal) {
+  for (const call of calls) {
+    if (signal_aborted(signal) === true) {
+      const cancelled = { ok: false, output: "", error: "cancelled" };
+      history.push(tool_message_from_result(call, cancelled));
+      emitter?.emit({ type: "tool_call_end", turn, call, result: cancelled, cancelled: true });
+      continue;
+    }
+    emitter?.emit({ type: "tool_call_start", turn, call });
+    const result = await deps.tools.execute(call.name, call.args, deps.tool_context);
+    history.push(tool_message_from_result(call, result));
+    emitter?.emit({ type: "tool_call_end", turn, call, result });
+  }
+  return signal_aborted(signal) === true ? "aborted" : "continued";
+}
+async function call_chat(deps, history, params, emitter) {
+  try {
+    return await deps.chat(history, deps.definitions(), {
+      temperature: params.temperature,
+      max_tokens: params.max_tokens,
+      signal: params.signal
+    });
+  } catch (error) {
+    if (signal_aborted(params.signal) === true) {
+      throw error;
+    }
+    if (error instanceof ProviderError) {
+      logger.error(`provider error kind=${error.kind} provider=${error.provider_name}`, error);
+    } else {
+      logger.error("agent chat call failed", error);
+    }
+    emitter?.emit({ type: "error", error });
+    throw error;
+  }
+}
+function replace_history(history, next) {
+  history.length = 0;
+  for (const message of next) {
+    history.push(message);
+  }
+}
+function kept_tail_over_budget(history, budget_tokens, threshold) {
+  const system_messages = history.filter((message) => message.role === "system");
+  const non_system = history.filter((message) => message.role !== "system");
+  const { recent } = split_keep_recent(non_system, KEEP_RECENT_TURNS);
+  return should_compress([...system_messages, ...recent], budget_tokens, threshold);
+}
+function schedule_compress_backoff(backoff, turn) {
+  backoff.skip_until_turn = turn + COMPRESS_BACKOFF_TURNS + 1;
+}
+async function compress_if_needed(deps, history, params, emitter, turn, backoff) {
+  const budget_tokens = params.context_budget_tokens;
+  if (budget_tokens === void 0) {
+    return;
+  }
+  if (turn < backoff.skip_until_turn) {
+    return;
+  }
+  const threshold = params.compress_threshold ?? DEFAULT_COMPRESS_THRESHOLD;
+  if (!should_compress(history, budget_tokens, threshold)) {
+    return;
+  }
+  const non_system_count = history.filter((message) => message.role !== "system").length;
+  if (non_system_count <= KEEP_RECENT_TURNS) {
+    schedule_compress_backoff(backoff, turn);
+    return;
+  }
+  emitter?.emit({ type: "compress_start", estimated_tokens: estimate_messages_tokens(history) });
+  let summarizer_usage;
+  const counting_chat = async (messages, tools, options) => {
+    const result = await deps.chat(messages, tools, options);
+    summarizer_usage = result.usage;
+    return result;
+  };
+  const outcome = await compress_messages(
+    { chat: counting_chat },
+    history,
+    { budget_tokens, keep_recent: KEEP_RECENT_TURNS, signal: params.signal }
+  );
+  replace_history(history, outcome.messages);
+  emitter?.emit({
+    type: "compress_end",
+    summary_chars: outcome.summary_chars,
+    usage: summarizer_usage
+  });
+  if (outcome.summary_chars === 0) {
+    schedule_compress_backoff(backoff, turn);
+    return;
+  }
+  if (should_compress(history, budget_tokens, threshold) !== true) {
+    return;
+  }
+  if (kept_tail_over_budget(history, budget_tokens, threshold) === true) {
+    schedule_compress_backoff(backoff, turn);
+    return;
+  }
+  schedule_compress_backoff(backoff, turn);
+}
+function find_last_assistant(messages) {
+  return [...messages].reverse().find((message) => message.role === "assistant");
+}
+function signal_aborted(signal) {
+  return signal?.aborted === true;
+}
+function aborted_outcome(history, turns_used, emitter) {
+  emitter?.emit({ type: "error", error: new DOMException("agent loop aborted", "AbortError") });
+  return {
+    messages: history,
+    final: find_last_assistant(history),
+    result: void 0,
+    turns_used,
+    stopped_reason: "aborted"
+  };
+}
+async function run_conversation(deps, messages, params) {
+  const history = seed_system_prompt(messages, params.system_prompt);
+  const emitter = deps.emitter;
+  const compress_backoff = { skip_until_turn: 0 };
+  for (const turn of turn_range(params.max_turns)) {
+    if (signal_aborted(params.signal) === true) {
+      return aborted_outcome(history, turn - 1, emitter);
+    }
+    emitter?.emit({ type: "turn_start", turn });
+    await compress_if_needed(deps, history, params, emitter, turn, compress_backoff);
+    emitter?.emit({ type: "llm_start", turn });
+    let result;
+    try {
+      result = await call_chat(deps, history, params, emitter);
+    } catch (error) {
+      if (signal_aborted(params.signal) === true) {
+        return aborted_outcome(history, turn - 1, emitter);
+      }
+      throw error;
+    }
+    emitter?.emit({ type: "llm_end", turn, result });
+    history.push(result.message);
+    const calls = result.message.tool_calls ?? [];
+    if (calls.length === 0) {
+      emitter?.emit({ type: "final", message: result.message, result });
+      emitter?.emit({ type: "turn_end", turn });
+      return { messages: history, final: result.message, result, turns_used: turn, stopped_reason: "final" };
+    }
+    const tool_status = await run_tool_calls(deps, history, turn, calls, emitter, params.signal);
+    if (tool_status === "aborted") {
+      return aborted_outcome(history, turn, emitter);
+    }
+    if (turn < params.max_turns) {
+      emitter?.emit({ type: "turn_end", turn });
+    }
+  }
+  emitter?.emit({ type: "budget_exhausted", turns_used: params.max_turns });
+  emitter?.emit({ type: "turn_end", turn: params.max_turns });
+  return {
+    messages: history,
+    final: find_last_assistant(history),
+    result: void 0,
+    turns_used: params.max_turns,
+    stopped_reason: "budget"
+  };
+}
+
+// src/agent/config.ts
+import { z } from "zod";
+
+// src/gateway/access.ts
+var PUBLIC_PLATFORMS = /* @__PURE__ */ new Set(["telegram", "discord", "twitch"]);
+var DEFAULT_GATEWAY_TOOLS_ENABLED = [
+  "read_file",
+  "list_dir",
+  "grep_files",
+  "fetch_url",
+  "web_search",
+  "docs_read",
+  "docs_search"
+];
+function gateway_tools_enabled(config) {
+  return config.gateway?.tools_enabled ?? DEFAULT_GATEWAY_TOOLS_ENABLED;
+}
+function is_gateway_sender_allowed(config, platform, chat_id, user_id) {
+  if (PUBLIC_PLATFORMS.has(platform) === false) {
+    return true;
+  }
+  const users = config.gateway?.allowed_users?.[platform] ?? [];
+  const chats = config.gateway?.allowed_chats?.[platform] ?? [];
+  if (users.length === 0 && chats.length === 0) {
+    return false;
+  }
+  const user_ok = users.length === 0 || users.includes(user_id);
+  const chat_ok = chats.length === 0 || chats.includes(chat_id);
+  return user_ok && chat_ok;
+}
+function check_gateway_sender(config, platform, chat_id, user_id) {
+  if (is_gateway_sender_allowed(config, platform, chat_id, user_id) === true) {
+    return true;
+  }
+  logger.warn(`gateway denied ${platform} chat=${chat_id} user=${user_id}`);
+  return false;
+}
+
+// src/mcp/mcp_pin.ts
+import path11 from "path";
+
+// src/mcp/mcp_catalog.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cached;
+function catalog_dir() {
+  let dir = path9.dirname(fileURLToPath2(import.meta.url));
+  for (let hop = 0; hop < 6; hop += 1) {
+    const candidate = path9.join(dir, "optional-mcps");
+    if (existsSync2(path9.join(candidate, "redot", "manifest.json")) === true) {
+      return candidate;
+    }
+    dir = path9.dirname(dir);
+  }
+  throw new Error("mcp catalog not found");
+}
+function read_manifest(file) {
+  const parsed = safe_json_parse(readFileSync4(file, "utf8"));
+  if (parsed === void 0 || typeof parsed.name !== "string") {
+    throw new Error("mcp catalog manifest rejected");
+  }
+  return parsed;
+}
+function load_catalog() {
+  if (cached !== void 0) {
+    return cached;
+  }
+  const manifests = [];
+  for (const name of readdirSync3(catalog_dir())) {
+    const file = path9.join(catalog_dir(), name, "manifest.json");
+    if (existsSync2(file) === true) {
+      manifests.push(read_manifest(file));
+    }
+  }
+  cached = manifests;
+  return cached;
+}
+function catalog_by_name(name) {
+  return load_catalog().find((entry) => entry.name === name);
+}
+function catalog_by_basename(command_basename) {
+  const base = command_basename.toLowerCase();
+  return load_catalog().find((entry) => entry.command_basename?.toLowerCase() === base);
+}
+
+// src/mcp/mcp_refuse.ts
+import path10 from "path";
+var SHELL_META = /[;&|`$<>]/;
+var DOWNLOADERS = /* @__PURE__ */ new Set([
+  "npx",
+  "npm",
+  "bunx",
+  "uvx",
+  "curl",
+  "wget",
+  "pnpm",
+  "yarn",
+  "deno"
+]);
+var SHELLS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "dash",
+  "csh",
+  "tcsh",
+  "ksh",
+  "cmd",
+  "cmd.exe",
+  "powershell",
+  "pwsh"
+]);
+var INTERPRETERS = /* @__PURE__ */ new Set(["node", "nodejs", "python", "python3", "python2", "ruby", "perl", "php"]);
+var EVAL_FLAGS = /* @__PURE__ */ new Set(["-c", "-e", "--eval", "-Command", "-EncodedCommand"]);
+function base_of(command) {
+  return path10.basename(command).toLowerCase();
+}
+function flag_name(arg) {
+  return arg.split("=")[0] ?? arg;
+}
+function refuse_eval_args(base, args) {
+  if (INTERPRETERS.has(base) === false && base !== "bun") {
+    return void 0;
+  }
+  for (const arg of args) {
+    const name = flag_name(arg);
+    if (EVAL_FLAGS.has(name) === true) {
+      return `refused ${base} eval flag '${arg}'`;
+    }
+  }
+  return void 0;
+}
+function refuse_bun_x(base, args) {
+  if (base !== "bun") {
+    return void 0;
+  }
+  const first = args[0];
+  if (first === "x" || first === "exec") {
+    return "refused bun x / bun exec";
+  }
+  return void 0;
+}
+function refuse_pkg_dlx(base, args) {
+  if (base !== "pnpm" && base !== "yarn" && base !== "npm") {
+    return void 0;
+  }
+  const first = args[0];
+  if (first === "dlx" || first === "exec" || first === "create") {
+    return `refused ${base} ${first}`;
+  }
+  return void 0;
+}
+function refuse_env_chain(args) {
+  for (const arg of args) {
+    if (arg.startsWith("-") === true) {
+      if (arg === "-S" || arg.startsWith("-S") === true || arg === "--split-string" || arg.startsWith("--split-string=") === true) {
+        return "refused env -S / --split-string";
+      }
+      continue;
+    }
+    if (arg.includes("=") === true) {
+      continue;
+    }
+    const base = base_of(arg);
+    if (DOWNLOADERS.has(base) === true || SHELLS.has(base) === true) {
+      return `refused env \u2192 '${base}'`;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function refuse_arg_downloaders(args) {
+  const limit = Math.min(args.length, 3);
+  for (let index = 0; index < limit; index += 1) {
+    const arg = args[index];
+    if (arg === void 0 || arg.startsWith("-") === true || arg.includes("=") === true) {
+      continue;
+    }
+    const base = base_of(arg);
+    if (DOWNLOADERS.has(base) === true) {
+      return `refused download command '${base}' in args`;
+    }
+    if (SHELLS.has(base) === true) {
+      return `refused shell '${base}' in args`;
+    }
+  }
+  return void 0;
+}
+function refuse_stdio_command(command, args = []) {
+  if (command.includes("://") === true) {
+    return "refused url; only a local binary is allowed";
+  }
+  if (SHELL_META.test(command) === true) {
+    return "refused shell metacharacters in mcp command";
+  }
+  if (command.length === 0 || command.trim() !== command || /\s/.test(command) === true) {
+    return "refused mcp command";
+  }
+  const base = base_of(command);
+  if (DOWNLOADERS.has(base) === true) {
+    return `refused download command '${base}'`;
+  }
+  if (SHELLS.has(base) === true) {
+    return `refused shell '${base}'`;
+  }
+  if (base === "env") {
+    return refuse_env_chain(args) ?? refuse_arg_downloaders(args);
+  }
+  return refuse_bun_x(base, args) ?? refuse_pkg_dlx(base, args) ?? refuse_eval_args(base, args) ?? refuse_arg_downloaders(args);
+}
+function refuse_stdio_arg(arg) {
+  if (arg.includes("://") === true) {
+    return "refused url in mcp args";
+  }
+  if (SHELL_META.test(arg) === true) {
+    return "refused shell metacharacters in mcp args";
+  }
+  return void 0;
 }
 
 // src/mcp/mcp_url.ts
@@ -2372,8 +3008,18 @@ function refuse_http_url(url) {
 }
 
 // src/mcp/mcp_pin.ts
+function pin_for(name, command) {
+  const by_name = catalog_by_name(name);
+  if (by_name?.command_basename !== void 0) {
+    return by_name;
+  }
+  if (command === void 0) {
+    return by_name;
+  }
+  return catalog_by_basename(path11.basename(command)) ?? by_name;
+}
 function refuse_catalog_stdio(name, command, args) {
-  const pin = catalog_by_name(name);
+  const pin = pin_for(name, command);
   if (pin?.command_basename === void 0) {
     return void 0;
   }
@@ -2382,11 +3028,11 @@ function refuse_catalog_stdio(name, command, args) {
   }
   const prefix = pin.args_prefix ?? [];
   if (args.length !== prefix.length + 1) {
-    return `refused ${name} args; expected ${prefix.join(" ")} <project>`;
+    return `refused ${pin.name} args; expected ${prefix.join(" ")} <project>`;
   }
   for (let index = 0; index < prefix.length; index += 1) {
     if (args[index] !== prefix[index]) {
-      return `refused ${name} args; expected ${prefix.join(" ")} <project>`;
+      return `refused ${pin.name} args; expected ${prefix.join(" ")} <project>`;
     }
   }
   const project = args[prefix.length];
@@ -2412,7 +3058,7 @@ function refuse_mcp_entry(name, entry) {
     return "refused mcp entry";
   }
   const args = entry.args ?? [];
-  return refuse_stdio_command(entry.command) ?? refuse_catalog_stdio(name, entry.command, args) ?? refuse_arg_list(args);
+  return refuse_stdio_command(entry.command, args) ?? refuse_catalog_stdio(name, entry.command, args) ?? refuse_arg_list(args);
 }
 
 // src/agent/config.ts
@@ -2466,12 +3112,26 @@ var provider_schema = z.object({
   /** Injectable fetch, mainly for tests; passes through untouched. */
   fetch_fn: z.custom(() => true).optional()
 }).passthrough();
+var providers_schema = z.array(provider_schema).min(1).superRefine((providers, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, provider] of providers.entries()) {
+    if (seen.has(provider.name) === true) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [index, "name"],
+        message: `duplicate provider name "${provider.name}"`
+      });
+      continue;
+    }
+    seen.add(provider.name);
+  }
+});
 var agent_config_schema = z.object({
   /** Wizard label. The TUI banner uses the active theme welcome string. */
   agent_name: z.string().min(1).default("lich"),
   system_prompt: z.string().optional(),
   max_turns: z.number().int().min(1).default(25),
-  providers: z.array(provider_schema).min(1),
+  providers: providers_schema,
   work_dir: z.string().optional(),
   tools_enabled: z.union([z.literal("all"), z.array(z.string())]).default("all"),
   temperature: z.number().min(0).max(2).optional(),
@@ -2502,6 +3162,13 @@ function freeze_config(config) {
   for (const provider of config.providers) {
     Object.freeze(provider);
   }
+  Object.freeze(config.plugins);
+  for (const plugin of config.plugins) {
+    Object.freeze(plugin);
+  }
+  if (Array.isArray(config.tools_enabled) === true) {
+    Object.freeze(config.tools_enabled);
+  }
   if (config.gateway !== void 0) {
     Object.freeze(config.gateway.platforms);
     Object.freeze(config.gateway.token_envs);
@@ -2557,12 +3224,19 @@ var AgentEmitter = class {
 };
 
 // src/mcp/mcp_http.ts
-async function post_rpc(url, fetch_fn, body) {
+function aborted(signal) {
+  return signal?.aborted === true;
+}
+async function post_rpc(url, fetch_fn, body, signal) {
+  if (aborted(signal) === true) {
+    throw new Error("cancelled");
+  }
   const response = await fetch_fn(url, {
     method: "POST",
     redirect: "error",
     headers: { "content-type": "application/json", accept: "application/json" },
-    body: JSON.stringify(body)
+    body: JSON.stringify(body),
+    signal
   });
   const parsed = await response.json();
   if (parsed.error !== void 0) {
@@ -2574,10 +3248,10 @@ async function post_rpc(url, fetch_fn, body) {
 function http_pipe(url, fetch_fn) {
   let next_id = 1;
   return {
-    request(method, params) {
+    request(method, params, signal) {
       const id = next_id;
       next_id += 1;
-      return post_rpc(url, fetch_fn, { jsonrpc: "2.0", id, method, params });
+      return post_rpc(url, fetch_fn, { jsonrpc: "2.0", id, method, params }, signal);
     },
     notify(method) {
       void fetch_fn(url, {
@@ -2630,7 +3304,6 @@ function plan_stdio(name, command, args, env_path) {
 }
 
 // src/mcp/mcp_pipe.ts
-var SKIP_LIMIT = 32;
 function parse_rpc_line(line) {
   const parsed = safe_json_parse(line);
   if (typeof parsed !== "object" || parsed === null) {
@@ -2638,41 +3311,112 @@ function parse_rpc_line(line) {
   }
   return parsed;
 }
-async function read_id(child, id) {
-  for (let skipped = 0; skipped < SKIP_LIMIT; skipped += 1) {
-    const line = await child.read_line();
-    const failure = child.failed();
-    if (failure !== void 0) {
-      throw new Error(failure);
-    }
-    if (line === void 0) {
-      throw new Error("mcp closed the pipe");
-    }
-    const parsed = parse_rpc_line(line);
-    if (parsed === void 0 || parsed.id !== id) {
-      continue;
-    }
-    if (parsed.error !== void 0) {
-      const detail = parsed.error.message;
-      throw new Error(typeof detail === "string" && detail.length > 0 ? detail : "mcp error");
+function error_message(error) {
+  const detail = error?.message;
+  return typeof detail === "string" && detail.length > 0 ? detail : "mcp error";
+}
+function reject_all(pending, message) {
+  for (const waiter of pending.values()) {
+    waiter.reject(new Error(message));
+  }
+  pending.clear();
+}
+function settle_response(pending, parsed) {
+  if (typeof parsed.id !== "number") {
+    return;
+  }
+  const waiter = pending.get(parsed.id);
+  if (waiter === void 0) {
+    return;
+  }
+  pending.delete(parsed.id);
+  if (parsed.error !== void 0) {
+    waiter.reject(new Error(error_message(parsed.error)));
+    return;
+  }
+  waiter.resolve(parsed.result);
+}
+function start_pump(child, pending, mark_dead) {
+  return (async () => {
+    for (; ; ) {
+      const line = await child.read_line();
+      const failure = child.failed();
+      if (failure !== void 0) {
+        mark_dead(failure);
+        reject_all(pending, failure);
+        return;
+      }
+      if (line === void 0) {
+        mark_dead("mcp closed the pipe");
+        reject_all(pending, "mcp closed the pipe");
+        return;
+      }
+      const parsed = parse_rpc_line(line);
+      if (parsed === void 0 || typeof parsed.method === "string") {
+        continue;
+      }
+      settle_response(pending, parsed);
     }
-    return parsed.result;
+  })();
+}
+function aborted2(signal) {
+  return signal?.aborted === true;
+}
+function with_signal(promise, signal) {
+  if (signal === void 0) {
+    return promise;
+  }
+  if (aborted2(signal) === true) {
+    return Promise.reject(new Error("cancelled"));
   }
-  throw new Error("mcp sent no matching response");
+  return new Promise((resolve, reject) => {
+    const on_abort = () => {
+      reject(new Error("cancelled"));
+    };
+    signal.addEventListener("abort", on_abort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", on_abort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", on_abort);
+        reject(error);
+      }
+    );
+  });
 }
 function stdio_pipe(child) {
   let next_id = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let pump;
+  let dead;
+  const mark_dead = (message) => {
+    dead = message;
+  };
   return {
-    request(method, params) {
+    request(method, params, signal) {
+      if (aborted2(signal) === true) {
+        return Promise.reject(new Error("cancelled"));
+      }
+      if (dead !== void 0) {
+        return Promise.reject(new Error(dead));
+      }
       const id = next_id;
       next_id += 1;
+      const wait = new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+      });
       child.write_line(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
-      return read_id(child, id);
+      pump ??= start_pump(child, pending, mark_dead);
+      return with_signal(wait, signal);
     },
     notify(method) {
       child.write_line(JSON.stringify({ jsonrpc: "2.0", method }));
     },
     close() {
+      mark_dead("mcp closed the pipe");
+      reject_all(pending, "mcp closed the pipe");
       child.stop();
     }
   };
@@ -2698,7 +3442,7 @@ function run_call(session, wire_name, args, context) {
     if (context.signal?.aborted === true) {
       throw new Error("cancelled");
     }
-    return { ok: true, output: await session.call_tool(wire_name, args) };
+    return { ok: true, output: await session.call_tool(wire_name, args, context.signal) };
   });
 }
 function tool_for(registered, wire_name, spec, session) {
@@ -2710,8 +3454,8 @@ function tool_for(registered, wire_name, spec, session) {
     execute: (args, context) => run_call(session, wire_name, args, context)
   };
 }
-function register_listed(registry, server, listed, enabled, session) {
-  const excluded = new Set(catalog_by_name(server)?.exclude_tools ?? []);
+function register_listed(registry, server, listed, enabled, session, command) {
+  const excluded = new Set(pin_for(server, command)?.exclude_tools ?? []);
   for (const spec of listed) {
     if (excluded.has(spec.name) === true) {
       continue;
@@ -2747,6 +3491,7 @@ function assert_handshake(result) {
 }
 
 // src/mcp/mcp_content.ts
+var MCP_ERROR_MAX = 4e3;
 function content_text(result) {
   if (typeof result !== "object" || result === null) {
     return "";
@@ -2767,16 +3512,30 @@ function content_text(result) {
       }
     }
   }
-  const text = parts.join("\n");
+  const text = clamp_output(parts.join("\n"));
   if (body.isError === true) {
-    throw new Error(text.length > 0 ? text : "mcp tool failed");
+    const detail = text.length > 0 ? text : "mcp tool failed";
+    throw new Error(detail.length > MCP_ERROR_MAX ? detail.slice(0, MCP_ERROR_MAX) : detail);
   }
   return text;
 }
 
 // src/mcp/mcp_result.ts
+var MCP_NAME_MAX = 64;
+var MCP_DESC_MAX = 2e3;
+var MCP_SCHEMA_JSON_MAX = 16e3;
+function clamp_text(value, max) {
+  return value.length > max ? value.slice(0, max) : value;
+}
+function schema_within_budget(raw) {
+  try {
+    return JSON.stringify(raw).length <= MCP_SCHEMA_JSON_MAX;
+  } catch {
+    return false;
+  }
+}
 function tool_schema(raw) {
-  if (typeof raw !== "object" || raw === null) {
+  if (typeof raw !== "object" || raw === null || schema_within_budget(raw) === false) {
     return { type: "object" };
   }
   const body = raw;
@@ -2802,12 +3561,13 @@ function parse_tools(result) {
       continue;
     }
     const tool = item;
-    if (typeof tool.name !== "string" || tool.name.length === 0) {
+    if (typeof tool.name !== "string" || tool.name.length === 0 || tool.name.length > MCP_NAME_MAX) {
       continue;
     }
+    const description = typeof tool.description === "string" ? clamp_text(tool.description, MCP_DESC_MAX) : tool.name;
     tools.push({
       name: tool.name,
-      description: typeof tool.description === "string" ? tool.description : tool.name,
+      description,
       parameters: tool_schema(tool.inputSchema)
     });
   }
@@ -2829,20 +3589,20 @@ var McpSession = class {
     this.closed = true;
     this.pipe.close();
   }
-  async list_tools() {
-    await this.ensure_ready();
-    return parse_tools(await this.pipe.request("tools/list", {}));
+  async list_tools(signal) {
+    await this.ensure_ready(signal);
+    return parse_tools(await this.pipe.request("tools/list", {}, signal));
   }
-  async call_tool(name, args) {
-    await this.ensure_ready();
-    return content_text(await this.pipe.request("tools/call", { name, arguments: args }));
+  async call_tool(name, args, signal) {
+    await this.ensure_ready(signal);
+    return content_text(await this.pipe.request("tools/call", { name, arguments: args }, signal));
   }
-  async ensure_ready() {
+  async ensure_ready(signal) {
     if (this.ready_done === true) {
       return;
     }
     try {
-      assert_handshake(await this.pipe.request("initialize", init_params()));
+      assert_handshake(await this.pipe.request("initialize", init_params(), signal));
       this.pipe.notify("notifications/initialized");
       this.ready_done = true;
     } catch (error) {
@@ -2939,11 +3699,27 @@ async function drain_stderr(stream) {
     continue;
   }
 }
+function bun_child_env(extra) {
+  if (extra === void 0) {
+    return void 0;
+  }
+  const merged = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") {
+      merged[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    merged[key] = value;
+  }
+  return merged;
+}
 function bun_line_child(command, args, env) {
   const queue = create_line_queue();
   try {
     const options = { stdin: "pipe", stdout: "pipe", stderr: "pipe" };
-    const child = env === void 0 ? Bun.spawn([command, ...args], options) : Bun.spawn([command, ...args], { ...options, env });
+    const merged = bun_child_env(env);
+    const child = merged === void 0 ? Bun.spawn([command, ...args], options) : Bun.spawn([command, ...args], { ...options, env: merged });
     void pump_stdout(child.stdout, queue);
     void drain_stderr(child.stderr);
     return {
@@ -2999,6 +3775,10 @@ function node_line_child(command, args, env) {
     queue.close();
   });
   child.stderr?.resume();
+  child.stdin?.on("error", () => {
+    failure ??= "mcp closed the pipe";
+    queue.close();
+  });
   child.on("error", (error) => {
     failure = spawn_failure(error.code);
     queue.close();
@@ -3032,9 +3812,28 @@ function default_line_spawner(command, args, env) {
 }
 
 // src/mcp/mcp_attach.ts
-async function open_and_register(registry, name, enabled, session) {
+var ATTACH_TIMEOUT_MS = 15e3;
+function with_timeout2(promise, label) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${ATTACH_TIMEOUT_MS}ms`));
+    }, ATTACH_TIMEOUT_MS);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+async function open_and_register(registry, name, enabled, session, command) {
   try {
-    register_listed(registry, name, await session.list_tools(), enabled, session);
+    const listed = await with_timeout2(session.list_tools(), `mcp ${name} attach`);
+    register_listed(registry, name, listed, enabled, session, command);
     return session;
   } catch (error) {
     session.close();
@@ -3051,7 +3850,7 @@ async function attach_stdio(registry, name, entry, config, runtime) {
   }
   const spawn5 = runtime?.spawn ?? default_line_spawner;
   const session = new McpSession(stdio_pipe(spawn5(planned.command, planned.args, entry.env)));
-  return open_and_register(registry, name, config.tools_enabled, session);
+  return open_and_register(registry, name, config.tools_enabled, session, planned.command);
 }
 async function attach_http(registry, name, url, config, runtime) {
   const session = new McpSession(http_pipe(url, runtime?.fetch_fn ?? fetch));
@@ -3247,11 +4046,30 @@ function git_commit_tool() {
     }
   };
 }
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "list_dir",
+  "grep_files",
+  "docs_read",
+  "docs_search",
+  "env_get",
+  "fetch_url",
+  "http_request",
+  "web_search",
+  "process_list",
+  "disk_usage"
+]);
 function seed_state(ctx) {
   ctx.state?.set("tests_ok", false);
   ctx.state?.set("dirty", true);
   ctx.state?.set("commits", 0);
 }
+function mark_dirty_if_writer(tool_name, ctx) {
+  if (READ_ONLY_TOOLS.has(tool_name) === true || tool_name === "run_tests" || tool_name === "git_commit") {
+    return;
+  }
+  ctx.state?.set("dirty", true);
+}
 function gatekeeper_hooks(allow_self_commit) {
   return {
     on_run_start: (_info, ctx) => {
@@ -3286,19 +4104,20 @@ function gatekeeper_hooks(allow_self_commit) {
       return {};
     },
     after_tool_call: (info, ctx) => {
-      if (info.ok !== true) {
-        return;
-      }
-      if (info.tool_name === "write_file" || info.tool_name === "edit_file") {
-        ctx.state?.set("dirty", true);
-      } else if (info.tool_name === "run_tests") {
+      mark_dirty_if_writer(info.tool_name, ctx);
+      if (info.tool_name === "run_tests") {
+        if (info.ok !== true) {
+          return;
+        }
         const filter = info.args["filter"];
         const filtered = typeof filter === "string" && filter.length > 0;
         if (filtered === false) {
           ctx.state?.set("tests_ok", true);
           ctx.state?.set("dirty", false);
         }
-      } else if (info.tool_name === "git_commit") {
+        return;
+      }
+      if (info.tool_name === "git_commit" && info.ok === true) {
         ctx.state?.set("commits", state_count(ctx, "commits") + 1);
       }
     }
@@ -3334,6 +4153,7 @@ function sleep(ms, signal) {
 // src/providers/failover.ts
 var DEFAULT_BACKOFF_BASE_MS = 500;
 var DEFAULT_BACKOFF_MAX_MS = 8e3;
+var MAX_RETRY_AFTER_MS = 3e4;
 function classify_error(error) {
   if (error instanceof ProviderError) {
     return error.kind;
@@ -3366,7 +4186,7 @@ async function execute_retry_loop(fn, params) {
       return { ok: false, error: make_abort_error(outcome.error) };
     }
     const kind = classify_error(outcome.error);
-    if (is_retryable_kind(kind) === false || attempt >= params.max_attempts) {
+    if (is_retryable_kind(kind) === false || attempt >= params.max_attempts || retry_after_too_long(outcome.error) === true) {
       return outcome;
     }
     const delay_ms = delay_for_error(outcome.error, attempt);
@@ -3394,11 +4214,15 @@ function caller_aborted(signal) {
 }
 function delay_for_error(error, attempt) {
   const backoff = compute_backoff_ms(attempt);
-  if (error instanceof ProviderError && error.retry_after_ms !== void 0 && error.retry_after_ms > backoff) {
-    return error.retry_after_ms;
+  if (error instanceof ProviderError && error.retry_after_ms !== void 0) {
+    const capped = Math.min(error.retry_after_ms, MAX_RETRY_AFTER_MS);
+    return capped > backoff ? capped : backoff;
   }
   return backoff;
 }
+function retry_after_too_long(error) {
+  return error instanceof ProviderError && error.retry_after_ms !== void 0 && error.retry_after_ms > MAX_RETRY_AFTER_MS;
+}
 async function wait_out_delay(delay_ms, signal) {
   if (delay_ms <= 0) {
     return;
@@ -3436,11 +4260,13 @@ var DEFAULT_BASE_URL = "https://api.anthropic.com";
 var ANTHROPIC_VERSION = "2023-06-01";
 var DEFAULT_KEY_ENV = "ANTHROPIC_API_KEY";
 var MAX_ERROR_BODY_CHARS = 500;
-var OVERFLOW_BODY_PATTERN = /context|token|maximum/i;
+var OVERFLOW_BODY_PATTERN = /context.?length|maximum context|prompt(?: is)? too (?:long|large)|token.?limit|context window|too many tokens|exceed.{0,30}context limit/i;
 var OVERLOADED_STATUS = 529;
 var UNPARSEABLE_ARGS_NOTE = "[unparseable tool arguments]";
+var TRUNCATED_TOOL_CALLS_NOTE = "[truncated tool call omitted]";
 var EMPTY_TEXT_PLACEHOLDER = "(empty)";
-var DEFAULT_MAX_TOKENS = 4096;
+var DEFAULT_MAX_TOKENS = 16384;
+var ANTHROPIC_TEMP_MAX = 1;
 var AnthropicProvider = class {
   name;
   model;
@@ -3464,7 +4290,7 @@ var AnthropicProvider = class {
       build_endpoint(this.config),
       build_request_init(
         api_key,
-        safe_stringify(build_request_body(this.config.model, messages, tools, options)),
+        safe_stringify(build_request_body(this.config.model, messages, tools, options, this.config)),
         build_abort_signal(options, this.config.timeout_ms)
       ),
       this.config.name
@@ -3512,7 +4338,7 @@ function build_abort_signal(options, timeout_ms) {
   }
   return AbortSignal.any(signals);
 }
-function build_request_body(model, messages, tools, options) {
+function build_request_body(model, messages, tools, options, config) {
   const body = {
     model,
     max_tokens: options?.max_tokens ?? DEFAULT_MAX_TOKENS,
@@ -3525,8 +4351,8 @@ function build_request_body(model, messages, tools, options) {
   if (tools.length > 0) {
     body.tools = to_anthropic_tools(tools);
   }
-  if (options?.temperature !== void 0) {
-    body.temperature = options.temperature;
+  if (config.send_temperature === true && options?.temperature !== void 0) {
+    body.temperature = Math.min(options.temperature, ANTHROPIC_TEMP_MAX);
   }
   return body;
 }
@@ -3582,6 +4408,9 @@ function tool_message_to_block(message) {
   return block;
 }
 function assistant_to_blocks(message) {
+  if (message.provider_content !== void 0 && message.provider_content.length > 0) {
+    return message.provider_content;
+  }
   const blocks = [];
   if (message.content.length > 0) {
     blocks.push({ type: "text", text: message.content });
@@ -3664,7 +4493,7 @@ function status_to_error_kind(status, body_text) {
   if (status === 429 || status === OVERLOADED_STATUS || status >= 500) {
     return "rate_limit";
   }
-  if (status === 400 && OVERFLOW_BODY_PATTERN.test(body_text) === true) {
+  if (status === 413 || status === 400 && OVERFLOW_BODY_PATTERN.test(body_text) === true) {
     return "overflow";
   }
   return "bad_request";
@@ -3681,28 +4510,57 @@ async function to_http_error(response, provider_name) {
   });
 }
 function parse_chat_response(dto, config) {
+  const finish_reason = map_stop_reason(dto.stop_reason);
   return {
-    message: parse_assistant_message(dto.content ?? []),
+    message: parse_assistant_message(dto.content ?? [], finish_reason),
     usage: parse_usage(dto.usage),
-    finish_reason: map_stop_reason(dto.stop_reason),
+    finish_reason,
     model: dto.model ?? config.model,
     provider_name: config.name
   };
 }
-function parse_assistant_message(blocks) {
+function parse_assistant_message(blocks, finish_reason) {
   const text_parts = [];
   const tool_calls = [];
+  const provider_content = [];
+  let has_thinking = false;
   for (const block of blocks) {
+    if (block.type === "thinking" || block.type === "redacted_thinking") {
+      has_thinking = true;
+      provider_content.push({ ...block });
+      continue;
+    }
     if (block.type === "text") {
       text_parts.push(block.text ?? "");
-    } else if (block.type === "tool_use") {
-      tool_calls.push(tool_use_to_call(block, text_parts));
+      const trimmed_text = (block.text ?? "").trim();
+      if (trimmed_text.length > 0) {
+        provider_content.push({ type: "text", text: block.text ?? "" });
+      }
+      continue;
     }
+    if (block.type === "tool_use") {
+      const call = tool_use_to_call(block, text_parts);
+      if (call !== void 0) {
+        tool_calls.push(call);
+        provider_content.push({
+          type: "tool_use",
+          id: call.id,
+          name: call.name,
+          input: call.args
+        });
+      }
+    }
+  }
+  const safe_calls = finish_reason === "length" ? [] : tool_calls;
+  if (finish_reason === "length" && tool_calls.length > 0) {
+    text_parts.push(TRUNCATED_TOOL_CALLS_NOTE);
   }
+  const safe_provider = finish_reason === "length" ? provider_content.filter((block) => block["type"] !== "tool_use") : provider_content;
   return {
     role: "assistant",
     content: text_parts.filter((part) => part.length > 0).join("\n"),
-    ...tool_calls.length > 0 ? { tool_calls } : {}
+    ...safe_calls.length > 0 ? { tool_calls: safe_calls } : {},
+    ...has_thinking === true ? { provider_content: safe_provider } : {}
   };
 }
 function tool_use_to_call(block, text_parts) {
@@ -3711,7 +4569,7 @@ function tool_use_to_call(block, text_parts) {
     return { id: block.id ?? "", name: block.name ?? "", args };
   }
   text_parts.push(UNPARSEABLE_ARGS_NOTE);
-  return { id: block.id ?? "", name: block.name ?? "", args: {} };
+  return void 0;
 }
 function parse_usage(dto) {
   const prompt_tokens = dto?.input_tokens ?? 0;
@@ -3755,8 +4613,9 @@ function is_abort_like2(error) {
 // src/providers/ollama.ts
 var DEFAULT_BASE_URL2 = "http://localhost:11434";
 var MAX_ERROR_BODY_CHARS2 = 500;
-var OVERFLOW_BODY_PATTERN2 = /context|token|maximum|too long/i;
+var OVERFLOW_BODY_PATTERN2 = /context.?length|maximum context|prompt(?: is)? too (?:long|large)|token.?limit|context window|too many tokens|too long|exceed.{0,30}context limit/i;
 var UNPARSEABLE_ARGS_NOTE2 = "[unparseable tool arguments]";
+var TRUNCATED_TOOL_CALLS_NOTE2 = "[truncated tool call omitted]";
 var tool_call_counter = 0;
 var OllamaProvider = class {
   name;
@@ -3864,7 +4723,7 @@ function build_request_body2(config, messages, tools, options) {
   if (wire_tools.length > 0) {
     body.tools = wire_tools;
   }
-  const wire_options = build_wire_options(options);
+  const wire_options = build_wire_options(config, options);
   if (wire_options !== void 0) {
     body.options = wire_options;
   }
@@ -3876,7 +4735,7 @@ function build_request_body2(config, messages, tools, options) {
   }
   return body;
 }
-function build_wire_options(options) {
+function build_wire_options(config, options) {
   const wire_options = {};
   if (options?.temperature !== void 0) {
     wire_options.temperature = options.temperature;
@@ -3884,7 +4743,10 @@ function build_wire_options(options) {
   if (options?.max_tokens !== void 0) {
     wire_options.num_predict = options.max_tokens;
   }
-  const has_any = wire_options.temperature !== void 0 || wire_options.num_predict !== void 0;
+  if (config.num_ctx !== void 0) {
+    wire_options.num_ctx = config.num_ctx;
+  }
+  const has_any = wire_options.temperature !== void 0 || wire_options.num_predict !== void 0 || wire_options.num_ctx !== void 0;
   return has_any === true ? wire_options : void 0;
 }
 function build_request_init2(api_key, body, signal) {
@@ -3950,7 +4812,7 @@ function status_to_error_kind2(status, body_text) {
   if (status === 429 || status >= 500) {
     return "rate_limit";
   }
-  if (status === 400 && OVERFLOW_BODY_PATTERN2.test(body_text) === true) {
+  if (status === 413 || status === 400 && OVERFLOW_BODY_PATTERN2.test(body_text) === true) {
     return "overflow";
   }
   return "bad_request";
@@ -3986,7 +4848,11 @@ function to_chat_response(dto, config) {
   if (message_content.length > 0) {
     content_parts.push(message_content);
   }
-  const parsed_calls = parse_tool_calls(dto.message.tool_calls ?? [], content_parts);
+  const finish_reason = map_done_reason(dto.done_reason, (dto.message.tool_calls ?? []).length > 0);
+  const parsed_calls = finish_reason === "length" ? [] : parse_tool_calls(dto.message.tool_calls ?? [], content_parts);
+  if (finish_reason === "length" && (dto.message.tool_calls ?? []).length > 0) {
+    content_parts.push(TRUNCATED_TOOL_CALLS_NOTE2);
+  }
   const has_tool_calls = parsed_calls.length > 0;
   return {
     message: {
@@ -3995,7 +4861,7 @@ function to_chat_response(dto, config) {
       ...has_tool_calls === true ? { tool_calls: parsed_calls } : {}
     },
     usage: parse_usage2(dto),
-    finish_reason: map_done_reason(dto.done_reason, has_tool_calls),
+    finish_reason: has_tool_calls === true ? "tool_calls" : finish_reason === "tool_calls" ? "stop" : finish_reason,
     model: dto.model ?? config.model,
     provider_name: config.name
   };
@@ -4004,30 +4870,34 @@ function next_tool_call_id() {
   tool_call_counter += 1;
   return `ollama_${Date.now().toString(36)}_${tool_call_counter}`;
 }
-function normalize_tool_arguments(raw_arguments, content_parts) {
-  if (is_record2(raw_arguments) === true) {
-    return raw_arguments;
-  }
-  if (typeof raw_arguments === "string") {
-    const parsed = safe_json_parse(raw_arguments);
-    if (is_record2(parsed) === true) {
-      return parsed;
-    }
-  }
-  content_parts.push(UNPARSEABLE_ARGS_NOTE2);
-  return {};
-}
 function parse_tool_calls(raw_calls, content_parts) {
   const tool_calls = [];
   for (const raw_call of raw_calls) {
     const name = raw_call.function?.name ?? "";
+    const args = try_normalize_tool_arguments(raw_call.function?.arguments, content_parts);
+    if (args === void 0) {
+      continue;
+    }
     tool_calls.push({
       id: next_tool_call_id(),
       name,
-      args: normalize_tool_arguments(raw_call.function?.arguments, content_parts)
+      args
     });
   }
-  return tool_calls;
+  return tool_calls;
+}
+function try_normalize_tool_arguments(raw_arguments, content_parts) {
+  if (is_record2(raw_arguments) === true) {
+    return raw_arguments;
+  }
+  if (typeof raw_arguments === "string") {
+    const parsed = safe_json_parse(raw_arguments);
+    if (is_record2(parsed) === true) {
+      return parsed;
+    }
+  }
+  content_parts.push(UNPARSEABLE_ARGS_NOTE2);
+  return void 0;
 }
 function parse_usage2(dto) {
   const prompt_tokens = dto.prompt_eval_count ?? 0;
@@ -4069,8 +4939,10 @@ var DEFAULT_BASE_URL3 = "https://api.openai.com/v1";
 var WELL_KNOWN_HOST = "api.openai.com";
 var WELL_KNOWN_KEY_ENV = "OPENAI_API_KEY";
 var MAX_ERROR_BODY_CHARS3 = 500;
-var OVERFLOW_BODY_PATTERN3 = /context|token|length/i;
+var OVERFLOW_BODY_PATTERN3 = /context.?length|maximum context|prompt(?: is)? too (?:long|large)|token.?limit|context window|too many tokens|exceed.{0,30}context limit/i;
 var UNPARSEABLE_ARGS_NOTE3 = "[unparseable tool arguments]";
+var TRUNCATED_TOOL_CALLS_NOTE3 = "[truncated tool call omitted]";
+var REASONING_MODEL_PATTERN = /^(o[1-9]|o[1-9]-|gpt-5)/i;
 var OpenAICompatProvider = class {
   name;
   model;
@@ -4197,14 +5069,21 @@ function build_request_body3(model, messages, tools, options) {
   if (wire_tools.length > 0) {
     body.tools = wire_tools;
   }
-  if (options?.temperature !== void 0) {
+  if (options?.temperature !== void 0 && is_reasoning_model(model) === false) {
     body.temperature = options.temperature;
   }
   if (options?.max_tokens !== void 0) {
-    body.max_tokens = options.max_tokens;
+    if (is_reasoning_model(model) === true) {
+      body.max_completion_tokens = options.max_tokens;
+    } else {
+      body.max_tokens = options.max_tokens;
+    }
   }
   return body;
 }
+function is_reasoning_model(model) {
+  return REASONING_MODEL_PATTERN.test(model) === true;
+}
 function build_request_init3(api_key, body, signal) {
   return {
     method: "POST",
@@ -4268,7 +5147,7 @@ function status_to_error_kind3(status, body_text) {
   if (status === 429 || status >= 500) {
     return "rate_limit";
   }
-  if (status === 400 && OVERFLOW_BODY_PATTERN3.test(body_text) === true) {
+  if (status === 413 || status === 400 && OVERFLOW_BODY_PATTERN3.test(body_text) === true) {
     return "overflow";
   }
   return "bad_request";
@@ -4293,27 +5172,39 @@ function parse_chat_response2(dto, config) {
       message: "provider returned a success response without choices"
     });
   }
+  const finish_reason = map_finish_reason(choice.finish_reason);
   return {
-    message: parse_assistant_message2(choice.message),
+    message: parse_assistant_message2(choice.message, finish_reason),
     usage: parse_usage3(dto.usage),
-    finish_reason: map_finish_reason(choice.finish_reason),
+    finish_reason,
     model: dto.model ?? config.model,
     provider_name: config.name
   };
 }
-function parse_assistant_message2(dto) {
+function parse_assistant_message2(dto, finish_reason) {
   const content_parts = [];
   if (dto.content !== void 0 && dto.content !== null && dto.content.length > 0) {
     content_parts.push(dto.content);
   }
+  const raw_calls = dto.tool_calls ?? [];
+  if (finish_reason === "length" && raw_calls.length > 0) {
+    content_parts.push(TRUNCATED_TOOL_CALLS_NOTE3);
+    return {
+      role: "assistant",
+      content: content_parts.filter((part) => part.length > 0).join("\n")
+    };
+  }
   const tool_calls = [];
-  for (const raw_call of dto.tool_calls ?? []) {
+  for (const raw_call of raw_calls) {
     const raw_arguments = raw_call.function?.arguments ?? "";
     const parsed_arguments = raw_arguments.length === 0 ? {} : safe_json_parse(raw_arguments);
     if (is_record3(parsed_arguments) === true) {
-      tool_calls.push({ id: raw_call.id ?? "", name: raw_call.function?.name ?? "", args: parsed_arguments });
+      tool_calls.push({
+        id: raw_call.id ?? "",
+        name: raw_call.function?.name ?? "",
+        args: parsed_arguments
+      });
     } else {
-      tool_calls.push({ id: raw_call.id ?? "", name: raw_call.function?.name ?? "", args: {} });
       content_parts.push(UNPARSEABLE_ARGS_NOTE3);
     }
   }
@@ -4426,9 +5317,10 @@ function build_provider(config) {
 }
 async function chat_with_failover(router, messages, tools, options) {
   let last_error;
+  let first_hard_error;
   for (const provider of router.list()) {
     if (options?.signal?.aborted === true) {
-      throw last_error ?? make_router_abort_error();
+      throw first_hard_error ?? last_error ?? make_router_abort_error();
     }
     const result = await attempt_provider(provider, messages, tools, options);
     if (result.ok === true) {
@@ -4438,15 +5330,24 @@ async function chat_with_failover(router, messages, tools, options) {
       throw result.error;
     }
     last_error = result.error;
+    if (first_hard_error === void 0 && is_hard_error(result.error) === true) {
+      first_hard_error = result.error;
+    }
     log_fail_over(result.error);
   }
-  throw last_error ?? new Error("no providers configured for failover");
+  throw first_hard_error ?? last_error ?? new Error("no providers configured for failover");
+}
+function is_hard_error(error) {
+  return error.kind === "auth" || error.kind === "overflow" || error.kind === "bad_request";
 }
 function log_fail_over(error) {
   if (error.kind === "rate_limit" || error.kind === "network") {
     return;
   }
-  logger.warn(`provider "${error.provider_name}" failed with ${error.kind}; failing over to next provider`);
+  const status_part = error.status !== void 0 ? ` status=${error.status}` : "";
+  logger.warn(
+    `provider "${error.provider_name}" failed with ${error.kind}${status_part}: ${error.message}; failing over to next provider`
+  );
 }
 function make_router_abort_error() {
   return new ProviderError({
@@ -4494,272 +5395,73 @@ function to_provider_error(error, fallback_name) {
   });
 }
 
-// src/session/store.ts
-import { appendFile, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
-import path14 from "path";
-var counter_state = { value: 0 };
-function slugify_label(label) {
-  const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
-  return slug.length > 0 ? `-${slug}` : "";
-}
-async function open_session(dir, label) {
-  await mkdir2(dir, { recursive: true });
-  counter_state.value += 1;
-  const label_part = label === void 0 ? "" : slugify_label(label);
-  const id = `${Date.now().toString(36)}-${counter_state.value}${label_part}`;
-  const file_path = path14.join(dir, `${id}.jsonl`);
-  return {
-    id,
-    path: file_path,
-    append: async (record) => {
-      await appendFile(file_path, `${safe_stringify(record)}
-`, "utf8");
-    }
-  };
-}
-
-// src/context/tokens.ts
-var TOOL_MESSAGE_OVERHEAD_TOKENS = 8;
-function estimate_text_tokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function estimate_message_tokens(message) {
-  const content_tokens = estimate_text_tokens(message.content);
-  if (message.role === "assistant" && message.tool_calls !== void 0) {
-    return content_tokens + estimate_text_tokens(safe_stringify(message.tool_calls));
-  }
-  if (message.role === "tool") {
-    return content_tokens + TOOL_MESSAGE_OVERHEAD_TOKENS;
-  }
-  return content_tokens;
-}
-function estimate_messages_tokens(messages) {
-  return messages.reduce((total, message) => total + estimate_message_tokens(message), 0);
-}
-
-// src/context/compressor.ts
-var COMPRESSION_SYSTEM_PROMPT = "You compress agent conversation history into terse factual summaries. Preserve: goals, decisions, file paths, commands run, errors, open questions. Output plain text only.";
-var MAX_TRANSCRIPT_CHARS = 24e3;
-function should_compress(messages, budget_tokens, threshold) {
-  return estimate_messages_tokens(messages) >= budget_tokens * threshold;
-}
-function format_history_line(message) {
-  const rendered_calls = message.role === "assistant" && message.tool_calls !== void 0 ? ` tool_calls=${safe_stringify(message.tool_calls)}` : "";
-  return `[${message.role}] ${message.content}${rendered_calls}`;
-}
-function build_summary_request(older, model_hint) {
-  const transcript = older.map((message) => format_history_line(message)).join("\n");
-  const hint = model_hint === void 0 ? "" : `
-(Continuing agent run as model: ${model_hint})`;
-  return {
-    role: "user",
-    content: "Summarize the following earlier conversation so the agent can continue the task from the summary alone.\n\n" + truncate_text(transcript, MAX_TRANSCRIPT_CHARS)
+// src/session/recorder.ts
+var seeded_handles = /* @__PURE__ */ new WeakSet();
+function record_ts() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function warn_append(error) {
+  logger.warn("session persistence failed; continuing without transcript", error);
+}
+function create_session_recorder(handle) {
+  let chain = Promise.resolve();
+  const enqueue = (write) => {
+    chain = chain.then(write).catch(warn_append);
   };
-}
-function log_compression_failure(error) {
-  if (error instanceof ProviderError) {
-    logger.warn(`context compression failed kind=${error.kind} provider=${error.provider_name}`, error);
-    return;
-  }
-  logger.warn("context compression failed", error);
-}
-function split_keep_recent(non_system, keep_recent) {
-  let cut = Math.max(0, non_system.length - keep_recent);
-  while (cut > 0 && non_system[cut]?.role === "tool") {
-    cut -= 1;
-  }
-  return { recent: non_system.slice(cut), older: non_system.slice(0, cut) };
-}
-async function compress_messages(deps, messages, params) {
-  const system_messages = messages.filter((message) => message.role === "system");
-  const non_system = messages.filter((message) => message.role !== "system");
-  const keep_recent = Math.max(0, params.keep_recent);
-  const { recent, older } = split_keep_recent(non_system, keep_recent);
-  if (older.length === 0) {
-    return { messages: [...messages], summary_chars: 0 };
-  }
-  try {
-    const result = await deps.chat(
-      [{ role: "system", content: COMPRESSION_SYSTEM_PROMPT }, build_summary_request(older, params.model_hint)],
-      [],
-      { signal: params.signal }
-    );
-    const summary = result.message.content;
-    const summary_message = {
-      role: "user",
-      content: `[context summary of earlier turns]
-${summary}
-[end summary]`
-    };
-    return { messages: [...system_messages, summary_message, ...recent], summary_chars: summary.length };
-  } catch (error) {
-    log_compression_failure(error);
-    return { messages: [...messages], summary_chars: 0 };
-  }
-}
-
-// src/agent/loop.ts
-var DEFAULT_COMPRESS_THRESHOLD = 0.8;
-var KEEP_RECENT_TURNS = 8;
-function turn_range(max_turns) {
-  return Array.from({ length: Math.max(0, max_turns) }, (_unused, index) => index + 1);
-}
-function seed_system_prompt(messages, system_prompt) {
-  const history = [...messages];
-  if (system_prompt === void 0) {
-    return history;
-  }
-  const system_index = history.findIndex((message) => message.role === "system");
-  if (system_index === -1) {
-    const seeded = { role: "system", content: system_prompt };
-    return [seeded, ...history];
-  }
-  const existing = history[system_index];
-  if (existing !== void 0 && existing.content === system_prompt) {
-    return history;
-  }
-  const replaced = { role: "system", content: system_prompt };
-  return [...history.slice(0, system_index), replaced, ...history.slice(system_index + 1)];
-}
-function format_tool_result_content(result) {
-  if (result.error !== void 0) {
-    return JSON.stringify({ ok: false, output: result.output, error: result.error });
-  }
-  return result.output;
-}
-async function run_tool_calls(deps, history, turn, calls, emitter, signal) {
-  for (const call of calls) {
-    if (signal_aborted(signal) === true) {
-      history.push(cancelled_tool_message(call));
-      continue;
+  const append = (record) => handle.append(record);
+  const append_message = (message) => append({ ts: record_ts(), kind: "message", message });
+  const append_meta = (meta) => append({ ts: record_ts(), kind: "meta", meta });
+  const on_event = (event) => {
+    if (event.type === "llm_end") {
+      enqueue(() => append_message(event.result.message));
+      return;
     }
-    emitter?.emit({ type: "tool_call_start", turn, call });
-    const result = await deps.tools.execute(call.name, call.args, deps.tool_context);
-    const tool_message = {
-      role: "tool",
-      tool_call_id: call.id,
-      name: call.name,
-      content: format_tool_result_content(result)
-    };
-    if (result.ok !== true) {
-      tool_message.is_error = true;
+    if (event.type === "tool_call_end") {
+      enqueue(() => append_message(tool_message_from_result(event.call, event.result)));
+      return;
     }
-    history.push(tool_message);
-    emitter?.emit({ type: "tool_call_end", turn, call, result });
-  }
-  return signal_aborted(signal) === true ? "aborted" : "continued";
-}
-function cancelled_tool_message(call) {
-  return {
-    role: "tool",
-    tool_call_id: call.id,
-    name: call.name,
-    content: format_tool_result_content({ ok: false, output: "", error: "cancelled" }),
-    is_error: true
-  };
-}
-async function call_chat(deps, history, params, emitter) {
-  try {
-    return await deps.chat(history, deps.definitions(), {
-      temperature: params.temperature,
-      max_tokens: params.max_tokens,
-      signal: params.signal
-    });
-  } catch (error) {
-    if (signal_aborted(params.signal) === true) {
-      throw error;
+    if (event.type === "budget_exhausted") {
+      enqueue(() => append_meta({ event: "budget_exhausted" }));
+      return;
     }
-    if (error instanceof ProviderError) {
-      logger.error(`provider error kind=${error.kind} provider=${error.provider_name}`, error);
-    } else {
-      logger.error("agent chat call failed", error);
+    if (event.type === "compress_end") {
+      enqueue(() => append_meta({ event: "compress_end", summary_chars: event.summary_chars }));
     }
-    emitter?.emit({ type: "error", error });
-    throw error;
-  }
-}
-async function compress_if_needed(deps, history, params, emitter) {
-  const budget_tokens = params.context_budget_tokens;
-  if (budget_tokens === void 0) {
-    return;
-  }
-  const threshold = params.compress_threshold ?? DEFAULT_COMPRESS_THRESHOLD;
-  if (!should_compress(history, budget_tokens, threshold)) {
-    return;
-  }
-  const non_system_count = history.filter((message) => message.role !== "system").length;
-  if (non_system_count <= KEEP_RECENT_TURNS) {
-    return;
-  }
-  emitter?.emit({ type: "compress_start", estimated_tokens: estimate_messages_tokens(history) });
-  const outcome = await compress_messages(
-    { chat: deps.chat },
-    history,
-    { budget_tokens, keep_recent: KEEP_RECENT_TURNS, signal: params.signal }
-  );
-  history.length = 0;
-  for (const message of outcome.messages) {
-    history.push(message);
-  }
-  emitter?.emit({ type: "compress_end", summary_chars: outcome.summary_chars });
-}
-function find_last_assistant(messages) {
-  return [...messages].reverse().find((message) => message.role === "assistant");
-}
-function signal_aborted(signal) {
-  return signal?.aborted === true;
-}
-function aborted_outcome(history, turns_used, emitter) {
-  emitter?.emit({ type: "error", error: new DOMException("agent loop aborted", "AbortError") });
-  return {
-    messages: history,
-    final: find_last_assistant(history),
-    result: void 0,
-    turns_used,
-    stopped_reason: "aborted"
   };
-}
-async function run_conversation(deps, messages, params) {
-  const history = seed_system_prompt(messages, params.system_prompt);
-  const emitter = deps.emitter;
-  for (const turn of turn_range(params.max_turns)) {
-    if (signal_aborted(params.signal) === true) {
-      return aborted_outcome(history, turn - 1, emitter);
-    }
-    emitter?.emit({ type: "turn_start", turn });
-    await compress_if_needed(deps, history, params, emitter);
-    emitter?.emit({ type: "llm_start", turn });
-    let result;
-    try {
-      result = await call_chat(deps, history, params, emitter);
-    } catch (error) {
-      if (signal_aborted(params.signal) === true) {
-        return aborted_outcome(history, turn - 1, emitter);
+  const seed = async (seed_opts) => {
+    const history_size = seed_opts.history.length;
+    await append_meta({
+      event: "run_start",
+      input_chars: seed_opts.input.length,
+      history_size
+    }).catch(warn_append);
+    const needs_history = seed_opts.owned || seeded_handles.has(handle) === false;
+    if (needs_history) {
+      seeded_handles.add(handle);
+      const has_system = seed_opts.history.some((message) => message.role === "system");
+      if (has_system === false && seed_opts.system_prompt !== void 0) {
+        await append_message({ role: "system", content: seed_opts.system_prompt }).catch(warn_append);
+      }
+      for (const message of seed_opts.history) {
+        await append_message(message).catch(warn_append);
       }
-      throw error;
-    }
-    emitter?.emit({ type: "llm_end", turn, result });
-    history.push(result.message);
-    const calls = result.message.tool_calls ?? [];
-    if (calls.length === 0) {
-      emitter?.emit({ type: "final", message: result.message, result });
-      emitter?.emit({ type: "turn_end", turn });
-      return { messages: history, final: result.message, result, turns_used: turn, stopped_reason: "final" };
-    }
-    const tool_status = await run_tool_calls(deps, history, turn, calls, emitter, params.signal);
-    if (tool_status === "aborted") {
-      return aborted_outcome(history, turn, emitter);
     }
-  }
-  emitter?.emit({ type: "budget_exhausted", turns_used: params.max_turns });
-  emitter?.emit({ type: "turn_end", turn: params.max_turns });
-  return {
-    messages: history,
-    final: find_last_assistant(history),
-    result: void 0,
-    turns_used: params.max_turns,
-    stopped_reason: "budget"
+    await append_message({ role: "user", content: seed_opts.input }).catch(warn_append);
+  };
+  const flush = () => chain;
+  const finish = async (stopped_reason, usage_total) => {
+    await flush();
+    await append_meta({
+      event: "run_end",
+      stopped_reason,
+      usage: {
+        prompt_tokens: usage_total.prompt_tokens,
+        completion_tokens: usage_total.completion_tokens,
+        total_tokens: usage_total.total_tokens
+      }
+    }).catch(warn_append);
   };
+  return { path: handle.path, on_event, seed, finish, flush };
 }
 
 // src/agent/agent.ts
@@ -4777,28 +5479,21 @@ function filter_registry(base, enabled) {
   }
   return filtered;
 }
+function add_usage(total, usage) {
+  total.prompt_tokens += usage.prompt_tokens;
+  total.completion_tokens += usage.completion_tokens;
+  total.total_tokens += usage.total_tokens;
+}
 function collect_usage(total) {
   return (event) => {
     if (event.type === "llm_end") {
-      total.prompt_tokens += event.result.usage.prompt_tokens;
-      total.completion_tokens += event.result.usage.completion_tokens;
-      total.total_tokens += event.result.usage.total_tokens;
+      add_usage(total, event.result.usage);
+      return;
     }
-  };
-}
-function append_meta(handle, meta) {
-  return handle.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "meta", meta });
-}
-function append_run_end(handle, stopped_reason, usage_total) {
-  return append_meta(handle, {
-    event: "run_end",
-    stopped_reason,
-    usage: {
-      prompt_tokens: usage_total.prompt_tokens,
-      completion_tokens: usage_total.completion_tokens,
-      total_tokens: usage_total.total_tokens
+    if (event.type === "compress_end" && event.usage !== void 0) {
+      add_usage(total, event.usage);
     }
-  });
+  };
 }
 function register_plugin_tools(registry, plugins) {
   for (const loaded of plugins) {
@@ -4858,13 +5553,30 @@ var Agent = class {
   }
   async run(options) {
     await this.attach_mcp_once();
+    const body = () => this.run_body(options);
+    if (this.hook_runner !== void 0) {
+      return this.hook_runner.run_scope(body);
+    }
+    return body();
+  }
+  async run_body(options) {
     const usage_total = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
     const run_events = new AgentEmitter();
     const stop_forwarding = run_events.on((event) => this.events.emit(event));
     const stop_collecting = run_events.on(collect_usage(usage_total));
+    const recorder = await this.open_recorder(options);
+    const stop_recording = recorder === void 0 ? void 0 : run_events.on((event) => recorder.on_event(event));
     await this.call_plugin_run_start(options.input);
     let outcome;
     try {
+      if (recorder !== void 0) {
+        await recorder.seed({
+          input: options.input,
+          history: options.history ?? [],
+          system_prompt: this.config.system_prompt ?? DEFAULT_AGENT_SYSTEM_PROMPT,
+          owned: options.session === void 0
+        });
+      }
       const seed_messages = [...options.history ?? []];
       seed_messages.push({ role: "user", content: options.input });
       const tool_context = {
@@ -4882,14 +5594,23 @@ var Agent = class {
         signal: options.signal
       });
     } finally {
+      stop_recording?.();
       stop_collecting();
       stop_forwarding();
+      if (recorder !== void 0) {
+        await recorder.flush();
+      }
       if (outcome !== void 0) {
         await this.call_plugin_run_end(outcome);
       }
     }
-    const session_path = await this.persist_session(outcome, options, usage_total);
-    return { outcome, messages: outcome.messages, usage_total, session_path };
+    if (outcome === void 0) {
+      throw new Error("agent run ended without outcome");
+    }
+    if (recorder !== void 0) {
+      await recorder.finish(outcome.stopped_reason, usage_total);
+    }
+    return { outcome, messages: outcome.messages, usage_total, session_path: recorder?.path };
   }
   /** Close MCP sessions so stdio children do not keep the event loop alive. */
   close() {
@@ -4935,19 +5656,11 @@ var Agent = class {
       ctx
     );
   }
-  /** Best-effort JSONL transcript: never fails the run, returns undefined path on error. */
-  async persist_session(outcome, options, usage_total) {
+  /** Best-effort recorder: open failures warn and skip persistence for this run. */
+  async open_recorder(options) {
     try {
-      const handle = await open_session(this.config.session_dir, options.label);
-      await append_meta(handle, { event: "run_start", input_chars: options.input.length, history_size: outcome.messages.length });
-      for (const message of outcome.messages) {
-        await handle.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), kind: "message", message });
-      }
-      if (outcome.stopped_reason === "budget") {
-        await append_meta(handle, { event: "budget_exhausted" });
-      }
-      await append_run_end(handle, outcome.stopped_reason, usage_total);
-      return handle.path;
+      const handle = options.session ?? await open_session(this.config.session_dir, options.label);
+      return create_session_recorder(handle);
     } catch (error) {
       logger.warn("session persistence failed; continuing without transcript", error);
       return void 0;
@@ -4975,8 +5688,6 @@ async function run_agent(raw_config, input, options) {
 }
 
 export {
-  safe_json_parse,
-  truncate_text,
   DEFAULT_GATEWAY_TOKEN_ENVS,
   is_env_var_name,
   platform_token_env,
@@ -4992,6 +5703,7 @@ export {
   plugin_errors_summary,
   sleep,
   ProviderError,
+  run_conversation,
   gateway_tools_enabled,
   check_gateway_sender,
   parse_agent_config,
@@ -5001,4 +5713,4 @@ export {
   create_agent_with_plugins,
   run_agent
 };
-//# sourceMappingURL=chunk-WNFBIX4E.js.map
+//# sourceMappingURL=chunk-KOEZQUIX.js.map