@itsautomata/prism 0.2.0 → 0.3.1

package/dist/cli.js

@@ -11,7 +11,7 @@ import React4 from "react";
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { useState as useState3, useCallback as useCallback3, useMemo as useMemo2 } from "react";
+import { useState as useState3, useCallback as useCallback3, useMemo as useMemo2, useEffect as useEffect3, useRef as useRef3 } from "react";
 import { Box as Box8, useApp, useInput as useInput3 } from "ink";
 
 // src/ui/Banner.tsx
@@ -40,8 +40,8 @@ var theme = {
   // amber for shell mode and warnings
   planMode: "#a78bfa",
   // soft violet for plan mode (cool, contemplative)
-  error: "#ff4444",
-  // red for errors
+  error: "#cf3d0c",
+  // burnt vermillion for errors
   success: "#00ff88",
   // same as primary
   // UI elements
@@ -54,11 +54,11 @@ var theme = {
   spinner: "#00ff88",
   // loading spinner
   // tool results
-  toolName: "#00ddff",
-  // tool name highlight
+  toolName: "#c29734",
+  // muted gold for tool name highlight
   toolOutput: "#aaaaaa",
   // tool output text
-  toolError: "#ff4444",
+  toolError: "#cf3d0c",
   // tool error text
   // thinking
   thinking: "#666666"
@@ -258,8 +258,8 @@ function MessageBlock({ message }) {
       return /* @__PURE__ */ jsx3(Box3, { marginTop: 0, marginBottom: 0, marginLeft: 2, children: /* @__PURE__ */ jsx3(Markdown, { text: message.text }) });
     case "tool_call":
       return /* @__PURE__ */ jsxs3(Box3, { marginTop: 0, marginBottom: 0, marginLeft: 2, children: [
-        /* @__PURE__ */ jsx3(Text3, { color: theme.accent, children: "\u26A1 " }),
-        /* @__PURE__ */ jsx3(Text3, { color: theme.accent, bold: true, children: message.toolName })
+        /* @__PURE__ */ jsx3(Text3, { color: theme.toolName, children: "\u26A1 " }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.toolName, bold: true, children: message.toolName?.toLowerCase() })
       ] });
     case "tool_result":
       if (message.isError) {
@@ -282,6 +282,7 @@ import { Box as Box5, Text as Text5, useInput } from "ink";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir as homedir2 } from "os";
+import { createHash } from "crypto";
 var PROFILES_DIR = join(homedir2(), ".prism", "models");
 function ensureDir() {
   if (!existsSync(PROFILES_DIR)) {
@@ -290,7 +291,8 @@ function ensureDir() {
 }
 function profilePath(model) {
   const safe = model.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return join(PROFILES_DIR, `${safe}.json`);
+  const hash = createHash("sha256").update(model).digest("hex").slice(0, 8);
+  return join(PROFILES_DIR, `${safe}-${hash}.json`);
 }
 function loadProfile(model) {
   const path = profilePath(model);
@@ -358,9 +360,17 @@ Follow these rules exactly. They override general instructions when they conflic
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, copyFileSync } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir3 } from "os";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { execSync } from "child_process";
 var PROJECTS_DIR = join2(homedir3(), ".prism", "projects");
+function normalizeRemote(url) {
+  let s = url.trim().toLowerCase().replace(/\/+$/, "").replace(/\.git$/, "");
+  const scp = s.match(/^[^@]+@([^:]+):(.+)$/);
+  if (scp) return `${scp[1]}/${scp[2]}`;
+  const proto = s.match(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?(.+)$/);
+  if (proto) return proto[1];
+  return s;
+}
 function getProjectId(cwd) {
   let key = cwd;
   try {
@@ -370,10 +380,10 @@ function getProjectId(cwd) {
       timeout: 1e3,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    if (remote) key = remote;
+    if (remote) key = normalizeRemote(remote);
   } catch {
   }
-  return createHash("sha256").update(key).digest("hex").slice(0, 12);
+  return createHash2("sha256").update(key).digest("hex").slice(0, 12);
 }
 function memoDir(id) {
   return join2(PROJECTS_DIR, id);
@@ -832,13 +842,19 @@ function handleSlashCommand(input, model, profile, setProfile, setMessages, exit
       }
       return true;
     case "/forget": {
-      const idx = parseInt(args) - 1;
-      if (isNaN(idx)) {
-        info("usage: /forget <number>");
+      const raw = args.trim();
+      const idx = parseInt(raw, 10) - 1;
+      if (!/^\d+$/.test(raw)) {
+        info("usage: /forget <number> (see /rules)");
       } else {
+        const before = loadProfile(model).rules.length;
         const updated = removeRule(model, idx);
-        setProfile(updated);
-        info("rule removed.");
+        if (updated.rules.length === before) {
+          info(`no rule #${raw}. you have ${before} rule${before === 1 ? "" : "s"} (see /rules).`);
+        } else {
+          setProfile(updated);
+          info("rule removed.");
+        }
       }
       return true;
     }
@@ -1177,27 +1193,744 @@ function SlashHints({ matches, selectedIdx }) {
   ] });
 }
 
+// src/ui/inputBuffer.ts
+import { randomUUID } from "crypto";
+var cp = (s) => Array.from(s);
+var clen = (s) => cp(s).length;
+var cslice = (s, a, b) => cp(s).slice(a, b).join("");
+function createBuffer() {
+  return [];
+}
+function flatLength(buf) {
+  let n = 0;
+  for (const seg of buf) n += seg.kind === "text" ? clen(seg.chars) : 1;
+  return n;
+}
+function locate(buf, pos) {
+  const clamped = Math.max(0, Math.min(pos, flatLength(buf)));
+  let consumed = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const seg = buf[i];
+    const len = seg.kind === "text" ? clen(seg.chars) : 1;
+    if (clamped <= consumed + len) {
+      return { segIdx: i, offset: clamped - consumed };
+    }
+    consumed += len;
+  }
+  return { segIdx: buf.length, offset: 0 };
+}
+function normalize(buf) {
+  const out = [];
+  for (const seg of buf) {
+    if (seg.kind === "text" && seg.chars.length === 0) continue;
+    const last = out[out.length - 1];
+    if (last && last.kind === "text" && seg.kind === "text") {
+      out[out.length - 1] = { kind: "text", chars: last.chars + seg.chars };
+    } else {
+      out.push(seg);
+    }
+  }
+  return out;
+}
+function insertText(buf, pos, str) {
+  if (!str) return buf;
+  if (buf.length === 0) return [{ kind: "text", chars: str }];
+  const { segIdx, offset } = locate(buf, pos);
+  const next = [];
+  for (let i = 0; i < buf.length; i++) {
+    const seg = buf[i];
+    if (i !== segIdx) {
+      next.push(seg);
+      continue;
+    }
+    if (seg.kind === "text") {
+      next.push({ kind: "text", chars: cslice(seg.chars, 0, offset) + str + cslice(seg.chars, offset) });
+    } else {
+      if (offset === 0) {
+        next.push({ kind: "text", chars: str }, seg);
+      } else {
+        next.push(seg, { kind: "text", chars: str });
+      }
+    }
+  }
+  if (segIdx === buf.length) {
+    next.push({ kind: "text", chars: str });
+  }
+  return normalize(next);
+}
+function insertPill(buf, pos, content, store, idOverride) {
+  const id = idOverride ?? randomUUID();
+  store.set(id, content);
+  const pill = { kind: "pill", id, size: content.length };
+  if (buf.length === 0) return [pill];
+  const { segIdx, offset } = locate(buf, pos);
+  const next = [];
+  for (let i = 0; i < buf.length; i++) {
+    const seg = buf[i];
+    if (i !== segIdx) {
+      next.push(seg);
+      continue;
+    }
+    if (seg.kind === "text") {
+      next.push({ kind: "text", chars: cslice(seg.chars, 0, offset) }, pill, { kind: "text", chars: cslice(seg.chars, offset) });
+    } else {
+      if (offset === 0) next.push(pill, seg);
+      else next.push(seg, pill);
+    }
+  }
+  if (segIdx === buf.length) {
+    next.push(pill);
+  }
+  return normalize(next);
+}
+function deleteBack(buf, pos) {
+  if (pos <= 0 || buf.length === 0) return { buf, pos: 0 };
+  const { segIdx, offset } = locate(buf, pos);
+  const next = [];
+  let removed = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const seg = buf[i];
+    if (i === segIdx) {
+      if (seg.kind === "text") {
+        if (offset === 0) {
+          const prev = next.pop();
+          if (!prev) {
+            next.push(seg);
+            break;
+          }
+          if (prev.kind === "text") {
+            next.push({ kind: "text", chars: cslice(prev.chars, 0, -1) });
+          }
+          removed = 1;
+        } else {
+          next.push({ kind: "text", chars: cslice(seg.chars, 0, offset - 1) + cslice(seg.chars, offset) });
+          removed = 1;
+        }
+      } else {
+        if (offset === 0) {
+          const prev = next.pop();
+          if (!prev) {
+            next.push(seg);
+            break;
+          }
+          if (prev.kind === "text") {
+            next.push({ kind: "text", chars: cslice(prev.chars, 0, -1) });
+          }
+          next.push(seg);
+          removed = 1;
+        } else {
+          removed = 1;
+          continue;
+        }
+      }
+    } else {
+      next.push(seg);
+    }
+  }
+  return { buf: normalize(next), pos: pos - removed };
+}
+function deleteForward(buf, pos) {
+  if (pos >= flatLength(buf) || buf.length === 0) return { buf, pos };
+  const { segIdx, offset } = locate(buf, pos);
+  const next = [];
+  for (let i = 0; i < buf.length; i++) {
+    const seg = buf[i];
+    if (i !== segIdx) {
+      next.push(seg);
+      continue;
+    }
+    if (seg.kind === "text") {
+      if (offset >= clen(seg.chars)) {
+        next.push(seg);
+        const target = buf[i + 1];
+        if (target?.kind === "text") {
+          next.push({ kind: "text", chars: cslice(target.chars, 1) });
+          i++;
+        } else if (target?.kind === "pill") {
+          i++;
+        }
+      } else {
+        next.push({ kind: "text", chars: cslice(seg.chars, 0, offset) + cslice(seg.chars, offset + 1) });
+      }
+    } else {
+      if (offset === 1) {
+        next.push(seg);
+        const target = buf[i + 1];
+        if (target?.kind === "text") {
+          next.push({ kind: "text", chars: cslice(target.chars, 1) });
+          i++;
+        } else if (target?.kind === "pill") {
+          i++;
+        }
+      } else {
+        continue;
+      }
+    }
+  }
+  return { buf: normalize(next), pos };
+}
+function expand(buf, store) {
+  let out = "";
+  for (const seg of buf) {
+    out += seg.kind === "text" ? seg.chars : store.get(seg.id) ?? "";
+  }
+  return out;
+}
+function wordBoundaryLeft(buf, pos) {
+  if (pos <= 0) return 0;
+  const { segIdx, offset } = locate(buf, pos);
+  const seg = buf[segIdx];
+  if (seg?.kind === "pill") {
+    return pos - offset;
+  }
+  let i = segIdx;
+  let off = offset;
+  let cursor = pos;
+  let inWord = false;
+  while (cursor > 0) {
+    const cur = buf[i];
+    if (!cur) break;
+    if (cur.kind === "pill") {
+      return cursor;
+    }
+    if (off === 0) {
+      i -= 1;
+      if (i < 0) return 0;
+      const prev = buf[i];
+      off = prev.kind === "text" ? clen(prev.chars) : 1;
+      continue;
+    }
+    const ch = cp(cur.chars)[off - 1];
+    const isWordChar = /\w/.test(ch);
+    if (isWordChar) inWord = true;
+    else if (inWord) return cursor;
+    cursor -= 1;
+    off -= 1;
+  }
+  return cursor;
+}
+function wordBoundaryRight(buf, pos) {
+  const total = flatLength(buf);
+  if (pos >= total) return total;
+  const { segIdx, offset } = locate(buf, pos);
+  const seg = buf[segIdx];
+  if (seg?.kind === "pill") {
+    return pos + (1 - offset);
+  }
+  let i = segIdx;
+  let off = offset;
+  let cursor = pos;
+  let inWord = false;
+  while (cursor < total) {
+    const cur = buf[i];
+    if (!cur) break;
+    if (cur.kind === "pill") {
+      return cursor + 1;
+    }
+    if (off >= clen(cur.chars)) {
+      i += 1;
+      off = 0;
+      continue;
+    }
+    const ch = cp(cur.chars)[off];
+    const isWordChar = /\w/.test(ch);
+    if (isWordChar) inWord = true;
+    else if (inWord) return cursor;
+    cursor += 1;
+    off += 1;
+  }
+  return cursor;
+}
+function deleteWordBack(buf, pos) {
+  const target = wordBoundaryLeft(buf, pos);
+  if (target >= pos) return { buf, pos };
+  let cur = pos;
+  let working = buf;
+  while (cur > target) {
+    const step = deleteBack(working, cur);
+    working = step.buf;
+    cur = step.pos;
+  }
+  return { buf: working, pos: cur };
+}
+function killToEnd(buf, pos) {
+  const total = flatLength(buf);
+  if (pos >= total) return buf;
+  let working = buf;
+  let n = total - pos;
+  while (n-- > 0) {
+    const step = deleteForward(working, pos);
+    working = step.buf;
+  }
+  return working;
+}
+function totalLines(buf) {
+  let n = 1;
+  for (const seg of buf) {
+    if (seg.kind === "text") {
+      for (const ch of cp(seg.chars)) {
+        if (ch === "\n") n++;
+      }
+    }
+  }
+  return n;
+}
+function flatToLineCol(buf, pos) {
+  let line = 0;
+  let col = 0;
+  let consumed = 0;
+  for (const seg of buf) {
+    if (consumed >= pos) return { line, col };
+    if (seg.kind === "text") {
+      for (const ch of cp(seg.chars)) {
+        if (consumed >= pos) return { line, col };
+        if (ch === "\n") {
+          line++;
+          col = 0;
+        } else {
+          col++;
+        }
+        consumed++;
+      }
+    } else {
+      if (consumed >= pos) return { line, col };
+      col++;
+      consumed++;
+    }
+  }
+  return { line, col };
+}
+function lineColToFlat(buf, targetLine, targetCol) {
+  let line = 0;
+  let col = 0;
+  let pos = 0;
+  for (const seg of buf) {
+    if (seg.kind === "text") {
+      for (const ch of cp(seg.chars)) {
+        if (line === targetLine && col >= targetCol) return pos;
+        if (line === targetLine && ch === "\n") return pos;
+        if (line > targetLine) return pos;
+        if (ch === "\n") {
+          line++;
+          col = 0;
+        } else {
+          col++;
+        }
+        pos++;
+      }
+    } else {
+      if (line === targetLine && col >= targetCol) return pos;
+      if (line > targetLine) return pos;
+      col++;
+      pos++;
+    }
+  }
+  return pos;
+}
+function moveCursorUp(buf, pos) {
+  const { line, col } = flatToLineCol(buf, pos);
+  if (line === 0) return pos;
+  return lineColToFlat(buf, line - 1, col);
+}
+function moveCursorDown(buf, pos) {
+  const { line, col } = flatToLineCol(buf, pos);
+  if (line >= totalLines(buf) - 1) return pos;
+  return lineColToFlat(buf, line + 1, col);
+}
+function sliceToLines(buf, startLine, endLine, cursor) {
+  const result = [];
+  let line = 0;
+  let consumed = 0;
+  let cursorDropped = 0;
+  for (const seg of buf) {
+    if (line >= endLine) break;
+    if (seg.kind === "text") {
+      let chunk = "";
+      for (const ch of cp(seg.chars)) {
+        if (line < startLine) {
+          if (consumed < cursor) cursorDropped++;
+        } else if (line < endLine) {
+          chunk += ch;
+        }
+        consumed++;
+        if (ch === "\n") line++;
+        if (line >= endLine) break;
+      }
+      if (chunk.endsWith("\n")) chunk = chunk.slice(0, -1);
+      if (chunk) result.push({ kind: "text", chars: chunk });
+    } else {
+      if (line < startLine) {
+        if (consumed < cursor) cursorDropped++;
+      } else if (line < endLine) {
+        result.push(seg);
+      }
+      consumed++;
+    }
+  }
+  let cursorOut = Math.max(0, cursor - cursorDropped);
+  const newLen = result.reduce((n, s) => n + (s.kind === "text" ? clen(s.chars) : 1), 0);
+  if (cursorOut > newLen) cursorOut = newLen;
+  return { buf: result, cursor: cursorOut };
+}
+
+// src/config/config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir6 } from "os";
+var PRISM_DIR = join5(homedir6(), ".prism");
+var CONFIG_PATH = join5(PRISM_DIR, "config.toml");
+var TUNING_DEFAULTS = {
+  repomap_max_files: 500,
+  repomap_max_lines: 500,
+  repomap_max_symbols_per_file: 10,
+  lens_max_bytes: 64 * 1024,
+  bash_timeout_ms: 3e4,
+  bash_max_output_bytes: 512 * 1024,
+  compaction_threshold: 0.8,
+  empty_turn_nudge_cap: 2,
+  input_viewport_max_lines: 10
+};
+var DEFAULTS = {
+  default_provider: "ollama",
+  default_model: "deepseek-r1:14b",
+  openrouter: { api_key: "" },
+  anthropic: { api_key: "" },
+  openai: { api_key: "" },
+  google: { api_key: "" },
+  ollama: { base_url: "http://localhost:11434" },
+  tuning: { ...TUNING_DEFAULTS }
+};
+function loadConfig() {
+  const config = structuredClone(DEFAULTS);
+  if (existsSync5(CONFIG_PATH)) {
+    try {
+      const text = readFileSync5(CONFIG_PATH, "utf-8");
+      const parsed = parseToml(text);
+      if (parsed.default_provider) config.default_provider = parsed.default_provider;
+      if (parsed.default_model) config.default_model = parsed.default_model;
+      if (parsed.openrouter?.api_key) config.openrouter.api_key = parsed.openrouter.api_key;
+      if (parsed.anthropic?.api_key) config.anthropic.api_key = parsed.anthropic.api_key;
+      if (parsed.openai?.api_key) config.openai.api_key = parsed.openai.api_key;
+      if (parsed.google?.api_key) config.google.api_key = parsed.google.api_key;
+      if (parsed.ollama?.base_url) config.ollama.base_url = parsed.ollama.base_url;
+      if (parsed.tuning) {
+        for (const key of Object.keys(TUNING_DEFAULTS)) {
+          const raw = parsed.tuning[key];
+          if (raw === void 0) continue;
+          const num = Number(raw);
+          if (Number.isFinite(num)) config.tuning[key] = num;
+        }
+      }
+    } catch {
+    }
+  }
+  if (process.env.OPENROUTER_API_KEY) config.openrouter.api_key = process.env.OPENROUTER_API_KEY;
+  if (process.env.ANTHROPIC_API_KEY) config.anthropic.api_key = process.env.ANTHROPIC_API_KEY;
+  if (process.env.OPENAI_API_KEY) config.openai.api_key = process.env.OPENAI_API_KEY;
+  if (process.env.GOOGLE_API_KEY) config.google.api_key = process.env.GOOGLE_API_KEY;
+  if (process.env.OLLAMA_HOST) config.ollama.base_url = process.env.OLLAMA_HOST;
+  return config;
+}
+var TUNING_BLOCK = `# global tuning knobs. every key is optional. missing entries use the defaults
+# shown here. CLI flags (--max-files, --max-lines, --no-repomap) override these
+# on a per-session basis.
+[tuning]
+
+# \u2500\u2500 retrieval / repo-map \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# the structural floor of the project that prism injects into every system
+# prompt: paths + symbols per file. bigger map = more context, more tokens.
+
+# how many source files the walker visits per build. larger repos are sampled.
+# bumping this trades startup time for broader coverage.
+# override per-session: --max-files <n>
+repomap_max_files = 500
+
+# how many lines the formatted block injects into the system prompt. excess
+# is truncated and replaced with a "...and N more files" footer the model can
+# act on with Read / Grep. higher = more structure visible, more tokens/turn.
+# override per-session: --max-lines <n>
+repomap_max_lines = 500
+
+# symbols shown per file in the rendered map. higher = denser detail per file,
+# fewer files fit. lower = more files visible, less detail each.
+repomap_max_symbols_per_file = 10
+
+# \u2500\u2500 memory layer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# size cap on lens.md (project-local rules, committed to the repo). only a
+# sanity bound against runaway files. normal lens.md is well under this.
+lens_max_bytes = 65536             # 64KB
+
+# \u2500\u2500 shell escape (! prefix in the prompt) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# timeout for '!<cmd>' shell escapes typed in the prompt. caps runaway
+# commands. does not affect the model's own Bash tool calls (those carry
+# their own timeout argument).
+bash_timeout_ms = 30000            # 30s
+
+# size cap on captured output from '!<cmd>' and the Bash tool. excess is
+# truncated with a marker. protects the UI from 'find /'-style floods.
+bash_max_output_bytes = 524288     # 512KB
+
+# \u2500\u2500 engine self-management \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# fraction of the model's context window at which compaction fires
+# (trim \u2192 snip \u2192 summarize). 0.8 = "compact once you've used 80%". lower
+# = compact earlier (safer, more model calls). a secondary snip threshold
+# derives from this at 0.75\xD7 to give summarize room to breathe.
+compaction_threshold = 0.8
+
+# how many consecutive empty model turns the engine will nudge before
+# giving up. higher = more patience with flaky models. lower = faster
+# failure on stuck loops.
+empty_turn_nudge_cap = 2
+
+# \u2500\u2500 input UX \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# max visible lines in the input box. typing past this freezes the box
+# height and scrolls the viewport to keep the cursor visible. above and
+# below the box, dim indicators show how many lines are hidden.
+input_viewport_max_lines = 10
+`;
+var BASE_TEMPLATE = `# prism config
+# env vars override these values. CLI flags override env vars and config.
+
+default_provider = "ollama"
+default_model = "deepseek-r1:14b"
+
+[openrouter]
+api_key = ""
+
+[anthropic]
+api_key = ""
+
+[openai]
+api_key = ""
+
+[google]
+api_key = ""
+
+[ollama]
+base_url = "http://localhost:11434"
+`;
+var REQUIRED_TABLES = [
+  { name: "tuning", block: TUNING_BLOCK }
+];
+function initConfig() {
+  if (existsSync5(CONFIG_PATH)) return;
+  if (!existsSync5(PRISM_DIR)) {
+    mkdirSync3(PRISM_DIR, { recursive: true });
+  }
+  const fresh = BASE_TEMPLATE + "\n" + TUNING_BLOCK;
+  writeFileSync3(CONFIG_PATH, fresh, "utf-8");
+}
+function migrateConfig() {
+  if (!existsSync5(CONFIG_PATH)) return [];
+  let text;
+  try {
+    text = readFileSync5(CONFIG_PATH, "utf-8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = parseToml(text);
+  } catch {
+    return [];
+  }
+  const missing = REQUIRED_TABLES.filter((t) => !parsed[t.name]);
+  if (missing.length === 0) return [];
+  const head = text.replace(/\s+$/, "");
+  const appended = missing.map((t) => t.block).join("\n");
+  const next = head + "\n\n" + appended + "\n";
+  try {
+    writeFileSync3(CONFIG_PATH, next, "utf-8");
+    return missing.map((t) => t.name);
+  } catch {
+    return [];
+  }
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+function parseToml(text) {
+  const result = {};
+  let currentSection = result;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]\s*(?:#.*)?$/);
+    if (sectionMatch) {
+      const key = sectionMatch[1];
+      result[key] = result[key] || {};
+      currentSection = result[key];
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*"([^"]*)"$/);
+    if (kvMatch) {
+      currentSection[kvMatch[1]] = kvMatch[2];
+      continue;
+    }
+    const kvUnquoted = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvUnquoted) {
+      currentSection[kvUnquoted[1]] = kvUnquoted[2].replace(/\s+#.*$/, "").trim();
+    }
+  }
+  return result;
+}
+
+// src/ui/spinnerPhrases.ts
+var STUCK_THRESHOLD_SEC = 30;
+var PHRASES = {
+  planMode: [
+    "mapping it out",
+    "drafting the approach",
+    "tracing the seam",
+    "weighing the options",
+    "before committing",
+    "sketching the shape"
+  ],
+  stuck: [
+    "still working",
+    "taking longer than usual",
+    "pushing through",
+    "still cooking",
+    "this one is a puzzle",
+    "sticking with it"
+  ],
+  thinking: [
+    "thinkering",
+    "considering",
+    "thinking",
+    "give me a moment",
+    "hold on lemme think",
+    "figuring it out",
+    "reasoning through",
+    "cooking",
+    "consulting the vibes"
+  ],
+  Read: [
+    "reading",
+    "pulling up the file",
+    "scanning the source",
+    "peeking",
+    "taking a look"
+  ],
+  Edit: [
+    "editing",
+    "applying the patch",
+    "rewriting in place",
+    "tweaking it",
+    "making the change"
+  ],
+  Write: [
+    "writing",
+    "saving to disk",
+    "putting it down",
+    "committing the file"
+  ],
+  Bash: [
+    "running the shell",
+    "firing the command",
+    "on the terminal",
+    "invoking the command"
+  ],
+  Verify: [
+    "running tests",
+    "confirming the change",
+    "asking the suite",
+    "checking the work"
+  ],
+  Agent: [
+    "briefing a subagent to help me out",
+    "delegating the work",
+    "splitting the work with a team mate",
+    "passing it down to someone else"
+  ],
+  Glob: [
+    "globbing",
+    "finding files",
+    "walking the tree",
+    "looking around"
+  ],
+  Grep: [
+    "grepping",
+    "searching the source",
+    "pattern matching"
+  ],
+  WebFetch: [
+    "fetching",
+    "reading the page"
+  ],
+  WebSearch: [
+    "searching the web",
+    "looking it up",
+    "consulting the world wide web"
+  ],
+  useSkill: [
+    "loading the skill",
+    "invoking the routine"
+  ],
+  afterTool: [
+    "piecing it together",
+    "reading the result",
+    "connecting it back",
+    "making sense of it",
+    "looking at what came back"
+  ]
+};
+function chooseBucket(ctx) {
+  if (ctx.inPlanMode && ctx.phase === "thinking") return "planMode";
+  if (ctx.phase === "thinking" && ctx.elapsedSec >= STUCK_THRESHOLD_SEC) return "stuck";
+  if (ctx.phase === "running" && ctx.tool && ctx.tool in PHRASES) return ctx.tool;
+  if (ctx.phase === "after-tool") return "afterTool";
+  return "thinking";
+}
+function pickPhrase(ctx, random = Math.random) {
+  const bucket = chooseBucket(ctx);
+  const pool = PHRASES[bucket] ?? PHRASES.thinking;
+  const recent = ctx.recentPhrases;
+  let candidates = pool;
+  if (recent && recent.length > 0) {
+    const filtered = pool.filter((p) => !recent.includes(p));
+    if (filtered.length > 0) candidates = filtered;
+  }
+  const idx = Math.floor(random() * candidates.length);
+  return candidates[idx] ?? candidates[0];
+}
+
 // src/ui/PromptInput.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode, invokeSkills = [] }) {
-  const bufferRef = useRef("");
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+var PHRASE_ROTATE_MS = 8e3;
+var PHRASE_RECENT_WINDOW = 3;
+var PASTE_PILL_THRESHOLD = 1e3;
+var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode, invokeSkills = [], activity, phase = "thinking", currentTool }) {
+  const bufferRef = useRef(createBuffer());
+  const pasteStoreRef = useRef(/* @__PURE__ */ new Map());
   const cursorRef = useRef(0);
-  const [display, setDisplay] = useState("");
+  const [displayBuf, setDisplayBuf] = useState([]);
   const [cursorPos, setCursorPos] = useState(0);
   const [selectedHintIdx, setSelectedHintIdx] = useState(0);
+  const [tick, setTick] = useState(0);
+  const [startedAt, setStartedAt] = useState(null);
+  const [phrase, setPhrase] = useState("thinking");
+  const recentPhrasesRef = useRef([]);
   const timerRef = useRef(null);
+  const escapeTimerRef = useRef(null);
   const flushNow = useCallback(() => {
     if (timerRef.current) {
       clearTimeout(timerRef.current);
       timerRef.current = null;
     }
-    setDisplay(bufferRef.current);
+    setDisplayBuf(bufferRef.current);
     setCursorPos(cursorRef.current);
   }, []);
   const scheduleDisplayUpdate = useCallback(() => {
     if (timerRef.current) return;
     timerRef.current = setTimeout(() => {
-      setDisplay(bufferRef.current);
+      setDisplayBuf(bufferRef.current);
       setCursorPos(cursorRef.current);
       timerRef.current = null;
     }, 16);
@@ -1205,13 +1938,82 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
   useEffect(() => {
     return () => {
       if (timerRef.current) clearTimeout(timerRef.current);
+      if (escapeTimerRef.current) clearTimeout(escapeTimerRef.current);
     };
   }, []);
-  const parts = display.split(/\s+/);
+  useEffect(() => {
+    if (!isLoading) {
+      setStartedAt(null);
+      return;
+    }
+    setStartedAt(Date.now());
+    setTick(0);
+    const id = setInterval(() => setTick((t) => t + 1), SPINNER_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [isLoading]);
+  const startedAtRef = useRef(null);
+  useEffect(() => {
+    startedAtRef.current = startedAt;
+  }, [startedAt]);
+  useEffect(() => {
+    if (!isLoading) {
+      recentPhrasesRef.current = [];
+      setPhrase("thinking");
+      return;
+    }
+    const repick = () => {
+      const elapsed = startedAtRef.current ? Math.floor((Date.now() - startedAtRef.current) / 1e3) : 0;
+      const next = pickPhrase({
+        phase,
+        tool: currentTool,
+        inPlanMode: !!inPlanMode,
+        elapsedSec: elapsed,
+        recentPhrases: recentPhrasesRef.current
+      });
+      const updated = [...recentPhrasesRef.current, next];
+      if (updated.length > PHRASE_RECENT_WINDOW) updated.shift();
+      recentPhrasesRef.current = updated;
+      setPhrase(next);
+    };
+    repick();
+    const id = setInterval(repick, PHRASE_ROTATE_MS);
+    return () => clearInterval(id);
+  }, [isLoading, phase, currentTool, inPlanMode]);
+  const clearBufferNow = useCallback(() => {
+    bufferRef.current = createBuffer();
+    pasteStoreRef.current = /* @__PURE__ */ new Map();
+    cursorRef.current = 0;
+    flushNow();
+  }, [flushNow]);
+  const ignoreNextReturnRef = useRef(false);
+  useEffect(() => {
+    if (isLoading) return;
+    const stdin = process.stdin;
+    if (!stdin || !stdin.isTTY) return;
+    const handler = (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      const isNewlineEnter = s === "\x1B\r" || s === "\x1B\n" || /^\x1b\[13;\d+u$/.test(s) || /^\x1b\[27;\d+;13~$/.test(s);
+      if (!isNewlineEnter) return;
+      bufferRef.current = insertText(bufferRef.current, cursorRef.current, "\n");
+      cursorRef.current += 1;
+      scheduleDisplayUpdate();
+      ignoreNextReturnRef.current = true;
+      setTimeout(() => {
+        ignoreNextReturnRef.current = false;
+      }, 50);
+    };
+    stdin.prependListener("data", handler);
+    return () => {
+      stdin.off("data", handler);
+    };
+  }, [isLoading, scheduleDisplayUpdate]);
+  const allText = displayBuf.every((s) => s.kind === "text");
+  const displayText = allText ? displayBuf.map((s) => s.chars).join("") : "";
+  const parts = displayText.split(/\s+/);
   const firstWord = parts[0] || "";
-  const isSkillCompletion = firstWord === "/run" && parts.length <= 2;
-  const isSectionCompletion = firstWord === "/run" && parts.length >= 3;
-  const isCmdCompletion = display.startsWith("/") && !display.includes(" ") && parts.length === 1 && !isSkillCompletion;
+  const isSkillCompletion = allText && firstWord === "/run" && parts.length <= 2;
+  const isSectionCompletion = allText && firstWord === "/run" && parts.length >= 3;
+  const isCmdCompletion = allText && displayText.startsWith("/") && !displayText.includes(" ") && parts.length === 1 && !isSkillCompletion;
   const showHints = isCmdCompletion || isSkillCompletion || isSectionCompletion;
   const matches = useMemo(() => {
     if (!showHints) return [];
@@ -1233,8 +2035,45 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
   useEffect(() => {
     setSelectedHintIdx(0);
   }, [firstWord, showHints]);
+  const RAW_WORD_LEFT = "\x1B[1;3D";
+  const RAW_WORD_RIGHT = "\x1B[1;3C";
+  const RAW_WORD_LEFT_CTRL = "\x1B[1;5D";
+  const RAW_WORD_RIGHT_CTRL = "\x1B[1;5C";
+  const RAW_DEL_WORD = "\x1B\x7F";
+  const RAW_DEL_WORD_ALT = "";
+  const RAW_KILL_LINE = "\v";
+  const RAW_NEWLINE_ESC_CR = "\x1B\r";
+  const RAW_NEWLINE_ESC_LF = "\x1B\n";
   useInput((input, key) => {
     if (isLoading) return;
+    if (key.return && ignoreNextReturnRef.current) {
+      ignoreNextReturnRef.current = false;
+      return;
+    }
+    const isNewlineChord = key.return && (key.shift || key.meta) || input === RAW_NEWLINE_ESC_CR || input === RAW_NEWLINE_ESC_LF;
+    if (isNewlineChord) {
+      if (escapeTimerRef.current) {
+        clearTimeout(escapeTimerRef.current);
+        escapeTimerRef.current = null;
+      }
+      bufferRef.current = insertText(bufferRef.current, cursorRef.current, "\n");
+      cursorRef.current += 1;
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (key.return && escapeTimerRef.current) {
+      clearTimeout(escapeTimerRef.current);
+      escapeTimerRef.current = null;
+      bufferRef.current = insertText(bufferRef.current, cursorRef.current, "\n");
+      cursorRef.current += 1;
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (escapeTimerRef.current && !key.escape) {
+      clearTimeout(escapeTimerRef.current);
+      escapeTimerRef.current = null;
+      clearBufferNow();
+    }
     if (matches.length > 0) {
       if (key.upArrow) {
         setSelectedHintIdx((prev) => Math.max(0, prev - 1));
@@ -1245,12 +2084,12 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
         return;
       }
       if (key.tab || key.return) {
-        const liveBuffer = bufferRef.current;
-        const liveParts = liveBuffer.split(/\s+/);
+        const liveText = bufferRef.current.every((s) => s.kind === "text") ? bufferRef.current.map((s) => s.chars).join("") : "";
+        const liveParts = liveText.split(/\s+/);
         const liveFirst = liveParts[0] ?? "";
         const liveIsSkillCompletion = liveFirst === "/run" && liveParts.length <= 2;
         const liveIsSectionCompletion = liveFirst === "/run" && liveParts.length >= 3;
-        const liveIsCmdCompletion = liveBuffer.startsWith("/") && !liveBuffer.includes(" ") && liveParts.length === 1 && !liveIsSkillCompletion;
+        const liveIsCmdCompletion = liveText.startsWith("/") && !liveText.includes(" ") && liveParts.length === 1 && !liveIsSkillCompletion;
         const liveShowHints = liveIsCmdCompletion || liveIsSkillCompletion || liveIsSectionCompletion;
         let liveMatches;
         if (liveIsSectionCompletion) {
@@ -1272,9 +2111,9 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
         const selected = liveMatches[selectedHintIdx] ?? liveMatches[0];
         if (selected) {
           const newText = liveIsSectionCompletion ? `/run ${liveParts[1]} ${selected.name} ` : liveIsSkillCompletion ? `/run ${selected.name} ` : selected.name + (selected.args ? " " : "");
-          if (liveBuffer !== newText) {
-            bufferRef.current = newText;
-            cursorRef.current = newText.length;
+          if (liveText !== newText) {
+            bufferRef.current = [{ kind: "text", chars: newText }];
+            cursorRef.current = [...newText].length;
             flushNow();
             return;
           }
@@ -1283,28 +2122,55 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
       }
     }
     if (key.return) {
-      const text = bufferRef.current.trim();
+      const text = expand(bufferRef.current, pasteStoreRef.current).trim();
       if (text) {
         onSubmit(text);
-        bufferRef.current = "";
+        bufferRef.current = createBuffer();
+        pasteStoreRef.current = /* @__PURE__ */ new Map();
         cursorRef.current = 0;
         flushNow();
       }
       return;
     }
+    if (input === RAW_DEL_WORD || input === RAW_DEL_WORD_ALT || key.ctrl && input === "w") {
+      const { buf, pos } = deleteWordBack(bufferRef.current, cursorRef.current);
+      bufferRef.current = buf;
+      cursorRef.current = pos;
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (input === RAW_KILL_LINE || key.ctrl && input === "k") {
+      bufferRef.current = killToEnd(bufferRef.current, cursorRef.current);
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (input === RAW_WORD_LEFT || input === RAW_WORD_LEFT_CTRL || key.meta && key.leftArrow) {
+      cursorRef.current = wordBoundaryLeft(bufferRef.current, cursorRef.current);
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (input === RAW_WORD_RIGHT || input === RAW_WORD_RIGHT_CTRL || key.meta && key.rightArrow) {
+      cursorRef.current = wordBoundaryRight(bufferRef.current, cursorRef.current);
+      scheduleDisplayUpdate();
+      return;
+    }
     if (key.backspace || key.delete) {
-      const c2 = cursorRef.current;
-      if (c2 > 0) {
-        bufferRef.current = bufferRef.current.slice(0, c2 - 1) + bufferRef.current.slice(c2);
-        cursorRef.current = c2 - 1;
-        scheduleDisplayUpdate();
-      }
+      const { buf, pos } = deleteBack(bufferRef.current, cursorRef.current);
+      bufferRef.current = buf;
+      cursorRef.current = pos;
+      scheduleDisplayUpdate();
       return;
     }
-    if (key.ctrl && input === "u" || key.escape) {
-      bufferRef.current = "";
-      cursorRef.current = 0;
-      flushNow();
+    if (key.ctrl && input === "u") {
+      clearBufferNow();
+      return;
+    }
+    if (key.escape) {
+      if (escapeTimerRef.current) clearTimeout(escapeTimerRef.current);
+      escapeTimerRef.current = setTimeout(() => {
+        clearBufferNow();
+        escapeTimerRef.current = null;
+      }, 50);
       return;
     }
     if (key.leftArrow) {
@@ -1313,7 +2179,7 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
       return;
     }
     if (key.rightArrow) {
-      cursorRef.current = Math.min(bufferRef.current.length, cursorRef.current + 1);
+      cursorRef.current = Math.min(flatLength(bufferRef.current), cursorRef.current + 1);
       scheduleDisplayUpdate();
       return;
     }
@@ -1323,57 +2189,158 @@ var PromptInput = memo(function PromptInput2({ onSubmit, isLoading, inPlanMode,
       return;
     }
     if (key.ctrl && input === "e") {
-      cursorRef.current = bufferRef.current.length;
+      cursorRef.current = flatLength(bufferRef.current);
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (key.upArrow) {
+      cursorRef.current = moveCursorUp(bufferRef.current, cursorRef.current);
+      scheduleDisplayUpdate();
+      return;
+    }
+    if (key.downArrow) {
+      cursorRef.current = moveCursorDown(bufferRef.current, cursorRef.current);
       scheduleDisplayUpdate();
       return;
     }
-    if (key.ctrl || key.meta || key.upArrow || key.downArrow || key.tab) {
+    if (key.ctrl || key.meta || key.tab) {
       return;
     }
-    const c = cursorRef.current;
-    bufferRef.current = bufferRef.current.slice(0, c) + input + bufferRef.current.slice(c);
-    cursorRef.current = c + input.length;
+    if (input.length >= PASTE_PILL_THRESHOLD) {
+      bufferRef.current = insertPill(bufferRef.current, cursorRef.current, input, pasteStoreRef.current);
+      cursorRef.current += 1;
+      flushNow();
+      return;
+    }
+    bufferRef.current = insertText(bufferRef.current, cursorRef.current, input);
+    cursorRef.current += [...input].length;
     scheduleDisplayUpdate();
   }, { isActive: !isLoading });
   if (isLoading) {
+    const frame = SPINNER_FRAMES[tick % SPINNER_FRAMES.length];
+    const label = activity ?? phrase;
+    const elapsedSec = startedAt ? Math.floor((Date.now() - startedAt) / 1e3) : 0;
     return /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
       /* @__PURE__ */ jsxs5(Box5, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: theme.spinner, children: "\u25C7 " }),
-        /* @__PURE__ */ jsx5(Text5, { color: theme.textDim, children: "thinking..." })
+        /* @__PURE__ */ jsxs5(Text5, { color: theme.spinner, children: [
+          frame,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { color: theme.textDim, children: [
+          label,
+          "..."
+        ] }),
+        elapsedSec >= 1 && /* @__PURE__ */ jsxs5(Text5, { color: theme.textMuted, children: [
+          " \xB7 ",
+          elapsedSec,
+          "s"
+        ] })
       ] }),
       /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(Text5, { color: theme.textMuted, children: "  esc to interrupt" }) })
     ] });
   }
-  const isShell = display.startsWith("!");
+  const firstSeg = displayBuf[0];
+  const isShell = firstSeg?.kind === "text" && firstSeg.chars.startsWith("!");
   const isPlanInput = inPlanMode && !isShell;
   const promptChar = isShell ? "$" : isPlanInput ? "\u25C7" : "\u25C6";
   const accent = isShell ? theme.warning : isPlanInput ? theme.planMode : theme.prompt;
-  const visible = isShell ? display.slice(1) : display;
-  const visibleCursor = isShell ? Math.max(0, cursorPos - 1) : cursorPos;
-  const before = visible.slice(0, visibleCursor);
-  const cursorChar = visible[visibleCursor] ?? " ";
-  const after = visible.slice(visibleCursor + 1);
+  const visibleSegs = isShell ? [
+    { kind: "text", chars: firstSeg.chars.slice(1) },
+    ...displayBuf.slice(1)
+  ] : displayBuf;
+  const initialVisibleCursor = isShell ? Math.max(0, cursorPos - 1) : cursorPos;
+  const maxLines = loadConfig().tuning.input_viewport_max_lines;
+  const total = totalLines(visibleSegs);
+  let renderSegs = visibleSegs;
+  let renderCursor = initialVisibleCursor;
+  let hiddenAbove = 0;
+  let hiddenBelow = 0;
+  if (total > maxLines) {
+    const { line: curLine } = flatToLineCol(visibleSegs, initialVisibleCursor);
+    const start = Math.max(0, Math.min(total - maxLines, curLine - Math.floor(maxLines / 2)));
+    const end = start + maxLines;
+    const sliced = sliceToLines(visibleSegs, start, end, initialVisibleCursor);
+    renderSegs = sliced.buf;
+    renderCursor = sliced.cursor;
+    hiddenAbove = start;
+    hiddenBelow = total - end;
+  }
+  const renderAtomLen = renderSegs.reduce(
+    (acc, s) => acc + (s.kind === "text" ? [...s.chars].length : 1),
+    0
+  );
+  const cursorOnEnd = renderCursor >= renderAtomLen;
+  const bufferEmpty = visibleSegs.length === 0;
   return /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
     isShell && /* @__PURE__ */ jsx5(Text5, { color: theme.textMuted, children: "  shell mode (delete the `!` to exit, or esc to clear. output stays here, the model won't see it)" }),
     isPlanInput && /* @__PURE__ */ jsxs5(Text5, { color: theme.planMode, children: [
       "  plan mode ",
       /* @__PURE__ */ jsx5(Text5, { color: theme.textMuted, children: "(type /exec-plan to execute, /cancel-plan to abandon, or push back to revise)" })
     ] }),
-    /* @__PURE__ */ jsxs5(Box5, { children: [
+    hiddenAbove > 0 && /* @__PURE__ */ jsxs5(Text5, { color: theme.textMuted, children: [
+      "  \u2191 ",
+      hiddenAbove,
+      " more line",
+      hiddenAbove === 1 ? "" : "s",
+      " above"
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { borderStyle: "round", borderColor: accent, paddingX: 1, children: /* @__PURE__ */ jsxs5(Text5, { wrap: "wrap", color: isShell ? theme.warning : void 0, children: [
       /* @__PURE__ */ jsxs5(Text5, { color: accent, children: [
         promptChar,
         " "
       ] }),
-      /* @__PURE__ */ jsxs5(Text5, { wrap: "wrap", color: isShell ? theme.warning : void 0, children: [
-        before,
-        /* @__PURE__ */ jsx5(Text5, { inverse: true, children: cursorChar }),
-        after,
-        !display && /* @__PURE__ */ jsx5(Text5, { color: theme.textMuted, children: "ask anything..." })
+      renderSegments(renderSegs, renderCursor),
+      cursorOnEnd && /* @__PURE__ */ jsx5(Text5, { inverse: true, children: " " }),
+      bufferEmpty && /* @__PURE__ */ jsxs5(Text5, { color: theme.textMuted, children: [
+        "ask anything...   ",
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(shift+enter for newline)" })
       ] })
+    ] }) }),
+    hiddenBelow > 0 && /* @__PURE__ */ jsxs5(Text5, { color: theme.textMuted, children: [
+      "  \u2193 ",
+      hiddenBelow,
+      " more line",
+      hiddenBelow === 1 ? "" : "s",
+      " below"
     ] }),
     /* @__PURE__ */ jsx5(SlashHints, { matches, selectedIdx: selectedHintIdx })
   ] });
 });
+function renderSegments(segs, cursor) {
+  const nodes = [];
+  let pos = 0;
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    if (seg.kind === "text") {
+      const len = seg.chars.length;
+      if (cursor >= pos && cursor < pos + len) {
+        const off = cursor - pos;
+        const before = seg.chars.slice(0, off);
+        const ch = seg.chars[off] ?? " ";
+        const after = seg.chars.slice(off + 1);
+        if (before) nodes.push(/* @__PURE__ */ jsx5(Text5, { children: before }, `t-${i}-pre`));
+        if (ch === "\n") {
+          nodes.push(/* @__PURE__ */ jsx5(Text5, { inverse: true, children: " " }, `t-${i}-cur`));
+          nodes.push(/* @__PURE__ */ jsx5(Text5, { children: "\n" }, `t-${i}-nl`));
+        } else {
+          nodes.push(/* @__PURE__ */ jsx5(Text5, { inverse: true, children: ch }, `t-${i}-cur`));
+        }
+        if (after) nodes.push(/* @__PURE__ */ jsx5(Text5, { children: after }, `t-${i}-post`));
+      } else {
+        nodes.push(/* @__PURE__ */ jsx5(Text5, { children: seg.chars }, `t-${i}`));
+      }
+      pos += len;
+    } else {
+      const label = `[paste ${seg.size} chars]`;
+      const onPill = cursor === pos;
+      nodes.push(
+        /* @__PURE__ */ jsx5(Text5, { color: theme.prompt, dimColor: true, inverse: onPill, children: label }, `p-${seg.id}`)
+      );
+      pos += 1;
+    }
+  }
+  return nodes;
+}
 
 // src/ui/PermissionPrompt.tsx
 import { useState as useState2, useRef as useRef2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
@@ -1541,8 +2508,7 @@ function isSessionAllowed(toolName) {
 function allowForSession(toolName) {
   sessionRules.add(toolName);
 }
-function needsPermission(toolName, permissionResult, isReadOnly) {
-  if (isReadOnly) return false;
+function needsPermission(toolName, permissionResult) {
   if (isSessionAllowed(toolName)) return false;
   if (permissionResult.behavior === "allow") return false;
   if (permissionResult.behavior === "deny") return false;
@@ -1642,8 +2608,8 @@ function isObviousBadToolCall(block) {
     }
     if (/^[a-z]+$/.test(cmd) && cmd.length < 10 && !cmd.includes("/")) {
       try {
-        const { execSync: execSync6 } = __require("child_process");
-        execSync6(`which ${cmd}`, { stdio: "pipe" });
+        const { execSync: execSync5 } = __require("child_process");
+        execSync5(`which ${cmd}`, { stdio: "pipe" });
       } catch {
         return `"${cmd}" is not a recognized command. respond with text instead.`;
       }
@@ -1652,6 +2618,15 @@ function isObviousBadToolCall(block) {
   return null;
 }
 async function executeToolCall(block, tools, context, askPermission) {
+  if (block.invalidArgs) {
+    return {
+      toolUseId: block.id,
+      result: {
+        content: `malformed tool arguments for ${block.name} \u2014 not executed. resend the call with valid JSON arguments.`,
+        isError: true
+      }
+    };
+  }
   const badCallReason = isObviousBadToolCall(block);
   if (badCallReason) {
     return {
@@ -1692,8 +2667,16 @@ async function executeToolCall(block, tools, context, askPermission) {
       }
     };
   }
-  const isReadOnly = tool.isReadOnly(parsed.data);
-  if (askPermission && needsPermission(tool.name, permission, isReadOnly)) {
+  if (needsPermission(tool.name, permission)) {
+    if (!askPermission) {
+      return {
+        toolUseId: block.id,
+        result: {
+          content: `permission required for ${tool.name} but no approval is available in this context`,
+          isError: true
+        }
+      };
+    }
     const description = permission.behavior === "ask" ? permission.message : `run ${tool.name}`;
     const choice = await askPermission(tool.name, description, block.id);
     if (choice === "deny") {
@@ -1787,7 +2770,7 @@ async function runAgent(agent, task) {
   const messages = [
     { role: "user", content: [{ type: "text", text: prompt }] }
   ];
-  const context = { cwd: process.cwd(), signal };
+  const context = { cwd: task.cwd ?? process.cwd(), signal };
   let turnCount = 0;
   let finalOutput = "";
   while (turnCount < maxTurns) {
@@ -1830,7 +2813,9 @@ async function runAgent(agent, task) {
             if (toolBlock) {
               try {
                 toolBlock.input = JSON.parse(event.inputJson);
+                toolBlock.invalidArgs = false;
               } catch {
+                if (event.inputJson.trim().length > 0) toolBlock.invalidArgs = true;
               }
             }
             break;
@@ -1904,11 +2889,23 @@ ${last}`;
   return { ...block, content: trimmed };
 }
 
+// src/compact/pairing.ts
+function isToolResultBearingUser(msg) {
+  return msg.role === "user" && msg.content.some((b) => b.type === "tool_result");
+}
+function safeKeepStart(messages, desiredKeepCount) {
+  let start = Math.max(0, messages.length - desiredKeepCount);
+  while (start < messages.length && isToolResultBearingUser(messages[start])) {
+    start++;
+  }
+  return start;
+}
+
 // src/compact/snip.ts
 function snipOldTurns(messages) {
   if (messages.length <= 4) return messages;
   const keepCount = Math.ceil(messages.length / 2);
-  const snipped = messages.slice(-keepCount);
+  const snipped = messages.slice(safeKeepStart(messages, keepCount));
   const marker = {
     role: "user",
     content: [{
@@ -1939,8 +2936,9 @@ async function summarizeOldTurns(messages, provider, model, keepRecent = 10) {
   if (messages.length <= keepRecent + 2) {
     return { ok: true, messages };
   }
-  const oldMessages = messages.slice(0, -keepRecent);
-  const recentMessages = messages.slice(-keepRecent);
+  const start = safeKeepStart(messages, keepRecent);
+  const oldMessages = messages.slice(0, start);
+  const recentMessages = messages.slice(start);
   const conversationText = oldMessages.map((msg) => {
     const role = msg.role;
     const text = msg.content.map((b) => {
@@ -2006,6 +3004,10 @@ async function* query(options) {
     cwd: process.cwd(),
     signal
   };
+  const { tuning } = loadConfig();
+  const compactionThreshold = tuning.compaction_threshold;
+  const snipThreshold = compactionThreshold * 0.75;
+  const emptyTurnNudgeCap = tuning.empty_turn_nudge_cap;
   let turnCount = 0;
   let consecutiveErrors = 0;
   let consecutiveEmptyTurns = 0;
@@ -2022,13 +3024,16 @@ async function* query(options) {
     messages.splice(0, messages.length, ...trimOldToolResults(messages));
     const tokenCount = countConversationTokens(messages);
     yield { type: "token_update", used: tokenCount, max: capabilities.maxContextTokens, formatted: `${formatTokens(tokenCount)} / ${formatTokens(capabilities.maxContextTokens)}` };
-    if (tokenCount > capabilities.maxContextTokens * 0.8) {
+    if (tokenCount > capabilities.maxContextTokens * compactionThreshold) {
       let compacted = false;
       if (!summarizeBlocked) {
         const result = await summarizeOldTurns(messages, provider, model);
         if (result.ok) {
           messages.splice(0, messages.length, ...result.messages);
           compacted = true;
+          if (countConversationTokens(messages) > capabilities.maxContextTokens * compactionThreshold) {
+            messages.splice(0, messages.length, ...snipOldTurns(messages));
+          }
         } else {
           summarizeBlocked = true;
           yield { type: "error", error: `compaction degraded to snip: ${result.reason}` };
@@ -2038,7 +3043,7 @@ async function* query(options) {
         const snipped = snipOldTurns(messages);
         messages.splice(0, messages.length, ...snipped);
       }
-    } else if (tokenCount > capabilities.maxContextTokens * 0.6) {
+    } else if (tokenCount > capabilities.maxContextTokens * snipThreshold) {
       const snipped = snipOldTurns(messages);
       messages.splice(0, messages.length, ...snipped);
     }
@@ -2088,7 +3093,7 @@ async function* query(options) {
       (b) => b.type === "text" && b.text.trim().length > 0
     );
     if (toolUseBlocks.length === 0 && !hasText) {
-      if (consecutiveEmptyTurns >= 2) {
+      if (consecutiveEmptyTurns >= emptyTurnNudgeCap) {
         yield { type: "done", reason: "empty_turn_cap", turnCount };
         return;
       }
@@ -2218,7 +3223,9 @@ function collectContentBlock(event, content) {
       if (toolBlock) {
         try {
           toolBlock.input = JSON.parse(event.inputJson);
+          toolBlock.invalidArgs = false;
         } catch {
+          if (event.inputJson.trim().length > 0) toolBlock.invalidArgs = true;
         }
       }
       break;
@@ -2251,7 +3258,8 @@ check if relevant files/paths exist. then report:
     // runAgent filters Agent out internally so subagents cannot nest.
     // turn cap and permission policy come from RECOVERY_AGENT.
     tools: opts.tools,
-    signal: opts.signal
+    signal: opts.signal,
+    cwd: opts.cwd
   });
   return result.output || "recovery agent could not diagnose the error";
 }
@@ -2299,6 +3307,13 @@ function formatContext(ctx) {
   if (ctx.deps.count > 0) {
     lines.push(`deps: ${ctx.deps.count} (${ctx.deps.file})`);
   }
+  const { testing } = ctx;
+  if (testing.hasTests) {
+    const parts = [`tests: ${testing.testFileCount}`];
+    if (testing.framework) parts.push(`framework: ${testing.framework}`);
+    if (testing.command) parts.push(`scripts.test: ${testing.command}`);
+    lines.push(parts.join(" \xB7 "));
+  }
   if (ctx.prism.learnedRules > 0) {
     lines.push(`learned rules: ${ctx.prism.learnedRules}`);
   }
@@ -2326,11 +3341,11 @@ function formatMemory(m) {
 }
 
 // src/context/lenses.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3 } from "fs";
-import { join as join5, basename as basename3 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join6, basename as basename3 } from "path";
 function loadLenses(cwd) {
-  const dir = join5(cwd, ".prism");
-  if (!existsSync5(dir)) return [];
+  const dir = join6(cwd, ".prism");
+  if (!existsSync6(dir)) return [];
   let files;
   try {
     files = readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
@@ -2345,7 +3360,7 @@ function loadLenses(cwd) {
   const lenses = [];
   for (const file of files) {
     try {
-      const content = readFileSync5(join5(dir, file), "utf-8").trim();
+      const content = readFileSync6(join6(dir, file), "utf-8").trim();
       if (content.length > 0) {
         lenses.push({ name: basename3(file, ".md"), content });
       }
@@ -2356,8 +3371,42 @@ function loadLenses(cwd) {
 }
 
 // src/prompts/system.ts
+var refIds = /* @__PURE__ */ new WeakMap();
+var nextRefId = 0;
+function refId(obj) {
+  if (!obj) return -1;
+  let id = refIds.get(obj);
+  if (id === void 0) {
+    id = ++nextRefId;
+    refIds.set(obj, id);
+  }
+  return id;
+}
+var cachedStaticKey = null;
+var cachedStaticPrefix = null;
+function staticKey(options) {
+  return [
+    options.capabilities.maxTools,
+    options.cwd,
+    refId(options.tools),
+    refId(options.projectContext),
+    refId(options.memory),
+    refId(options.profile)
+  ].join("|");
+}
 function buildSystemPrompt(options) {
-  const { capabilities, tools, cwd, profile, projectContext, memory, inPlanMode, activeSkills } = options;
+  const key = staticKey(options);
+  if (key !== cachedStaticKey) {
+    cachedStaticPrefix = composeStatic(options);
+    cachedStaticKey = key;
+  }
+  const dynamic = composeDynamic(options);
+  return dynamic ? `${cachedStaticPrefix}
+
+${dynamic}` : cachedStaticPrefix;
+}
+function composeStatic(options) {
+  const { capabilities, tools, cwd, profile, projectContext, memory } = options;
   const sections = [
     getCore(),
     getTools(tools, capabilities),
@@ -2367,13 +3416,12 @@ function buildSystemPrompt(options) {
   if (agentsBlock) sections.push(agentsBlock);
   const invokeSkillsBlock = getInvokeSkills(cwd);
   if (invokeSkillsBlock) sections.push(invokeSkillsBlock);
-  const skillsBlock = getActiveSkills(cwd, activeSkills);
-  if (skillsBlock) sections.push(skillsBlock);
   if (projectContext) {
     sections.push(formatContext(projectContext));
     if (projectContext.git) {
       sections.push(getGitGuidance());
     }
+    sections.push(getVerificationGuidance(projectContext.testing.hasTests));
   }
   const lensesBlock = getLenses(cwd);
   if (lensesBlock) sections.push(lensesBlock);
@@ -2385,6 +3433,14 @@ function buildSystemPrompt(options) {
     const learned = rulesToPrompt(profile);
     if (learned) sections.push(learned);
   }
+  return sections.join("\n\n");
+}
+function composeDynamic(options) {
+  const { cwd, activeSkills, repoMap, inPlanMode } = options;
+  const sections = [];
+  const skillsBlock = getActiveSkills(cwd, activeSkills);
+  if (skillsBlock) sections.push(skillsBlock);
+  if (repoMap && repoMap.length > 0) sections.push(repoMap);
   if (inPlanMode) {
     sections.push(getPlanModeAddendum());
   }
@@ -2508,8 +3564,9 @@ function getInvokeSkills(cwd) {
 }
 function getActiveSkills(cwd, names) {
   if (!names || names.size === 0) return null;
+  const sortedNames = [...names].sort();
   const bodies = [];
-  for (const name of names) {
+  for (const name of sortedNames) {
     try {
       const skill = loadSkill(name, cwd);
       bodies.push(skill.body);
@@ -2546,6 +3603,17 @@ function getGitGuidance() {
 - Before committing, always show the user what will be committed.
 - Never force-push or reset --hard without explicit permission.`;
 }
+function getVerificationGuidance(hasTests) {
+  if (!hasTests) {
+    return `# verification
+- This project has no test suite. After a non-trivial edit, confirm the change and stop. Do not propose writing tests unless the user explicitly asks.
+- Typo and comment-only edits: call out that the change is trivial.`;
+  }
+  return `# verification
+- After a non-trivial edit, call Verify with the project's test command. Derive it from \`# project scan\` (framework, scripts.test) and \`# repo map\` (test file structure).
+- Skip Verify for typo or comment-only edits; call out that the change is trivial.
+- If Verify fails, debug from its output. Do not claim done until it passes (or the user accepts the failing state explicitly).`;
+}
 function getPlanModeAddendum() {
   return `## plan mode
 
@@ -2578,10 +3646,10 @@ date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`;
 }
 
 // src/context/scanner.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join6, basename as basename4, extname } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join7, basename as basename4, extname } from "path";
+import { homedir as homedir7 } from "os";
 var LANG_MAP = {
   // scripting
   ".py": "python",
@@ -2886,7 +3954,8 @@ function scanProject(cwd) {
     git: detectGit(cwd),
     deps,
     prism: detectPrismState(cwd),
-    runtime: detectRuntime()
+    runtime: detectRuntime(),
+    testing: detectTesting(cwd, structure, deps)
   };
 }
 function detectLanguage(filesByType) {
@@ -2911,10 +3980,10 @@ function detectFramework(depNames) {
   return null;
 }
 function detectEntryPoint(cwd, language) {
-  const pyproject = join6(cwd, "pyproject.toml");
-  if (existsSync6(pyproject)) {
+  const pyproject = join7(cwd, "pyproject.toml");
+  if (existsSync7(pyproject)) {
     try {
-      const text = readFileSync6(pyproject, "utf-8");
+      const text = readFileSync7(pyproject, "utf-8");
       const match = text.match(/\[project\.scripts\]\s*\n\w+\s*=\s*"([^"]+)"/);
       if (match) {
         return match[1].split(":")[0].replace(/\./g, "/") + ".py";
@@ -2922,10 +3991,10 @@ function detectEntryPoint(cwd, language) {
     } catch {
     }
   }
-  const pkgJson = join6(cwd, "package.json");
-  if (existsSync6(pkgJson)) {
+  const pkgJson = join7(cwd, "package.json");
+  if (existsSync7(pkgJson)) {
     try {
-      const data = JSON.parse(readFileSync6(pkgJson, "utf-8"));
+      const data = JSON.parse(readFileSync7(pkgJson, "utf-8"));
       if (data.main) return data.main;
     } catch {
     }
@@ -2938,7 +4007,7 @@ function detectEntryPoint(cwd, language) {
     rust: ["src/main.rs"]
   };
   for (const candidate of candidates[language || ""] || []) {
-    if (existsSync6(join6(cwd, candidate))) return candidate;
+    if (existsSync7(join7(cwd, candidate))) return candidate;
   }
   return null;
 }
@@ -2948,11 +4017,11 @@ function detectStructure(cwd) {
   const configFiles = [];
   let totalFiles = 0;
   for (const cf of CONFIG_FILES) {
-    if (existsSync6(join6(cwd, cf))) configFiles.push(cf);
+    if (existsSync7(join7(cwd, cf))) configFiles.push(cf);
   }
   try {
     for (const entry of readdirSync4(cwd)) {
-      const path = join6(cwd, entry);
+      const path = join7(cwd, entry);
       try {
         const stat = statSync(path);
         if (stat.isDirectory() && !entry.startsWith(".") && !IGNORE_DIRS.has(entry)) {
@@ -2974,7 +4043,7 @@ function countFiles(dir, counts, depth, maxDepth) {
   try {
     for (const entry of readdirSync4(dir)) {
       if (IGNORE_DIRS.has(entry) || entry.startsWith(".")) continue;
-      const path = join6(dir, entry);
+      const path = join7(dir, entry);
       try {
         const stat = statSync(path);
         if (stat.isFile()) {
@@ -2992,7 +4061,7 @@ function countFiles(dir, counts, depth, maxDepth) {
   }
 }
 function detectGit(cwd) {
-  if (!existsSync6(join6(cwd, ".git"))) return null;
+  if (!existsSync7(join7(cwd, ".git"))) return null;
   try {
     const branch = exec(cwd, "git branch --show-current").trim();
     const status = exec(cwd, "git status --porcelain");
@@ -3019,18 +4088,18 @@ function detectGit(cwd) {
   }
 }
 function detectDeps(cwd) {
-  const reqTxt = join6(cwd, "requirements.txt");
-  if (existsSync6(reqTxt)) {
+  const reqTxt = join7(cwd, "requirements.txt");
+  if (existsSync7(reqTxt)) {
     try {
-      const lines = readFileSync6(reqTxt, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("-")).map((l) => l.split(/[><=!~]/)[0].trim());
+      const lines = readFileSync7(reqTxt, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("-")).map((l) => l.split(/[><=!~]/)[0].trim());
       return { file: "requirements.txt", count: lines.length, names: lines };
     } catch {
     }
   }
-  const pyproject = join6(cwd, "pyproject.toml");
-  if (existsSync6(pyproject)) {
+  const pyproject = join7(cwd, "pyproject.toml");
+  if (existsSync7(pyproject)) {
     try {
-      const text = readFileSync6(pyproject, "utf-8");
+      const text = readFileSync7(pyproject, "utf-8");
       const names = [];
       let inDeps = false;
       for (const line of text.split("\n")) {
@@ -3048,10 +4117,10 @@ function detectDeps(cwd) {
     } catch {
     }
   }
-  const pkgJson = join6(cwd, "package.json");
-  if (existsSync6(pkgJson)) {
+  const pkgJson = join7(cwd, "package.json");
+  if (existsSync7(pkgJson)) {
     try {
-      const data = JSON.parse(readFileSync6(pkgJson, "utf-8"));
+      const data = JSON.parse(readFileSync7(pkgJson, "utf-8"));
       const names = [
         ...Object.keys(data.dependencies || {}),
         ...Object.keys(data.devDependencies || {})
@@ -3065,11 +4134,11 @@ function detectDeps(cwd) {
 function detectPrismState(_cwd) {
   let learnedRules = 0;
   try {
-    const modelsDir = join6(homedir6(), ".prism", "models");
-    if (existsSync6(modelsDir)) {
+    const modelsDir = join7(homedir7(), ".prism", "models");
+    if (existsSync7(modelsDir)) {
       for (const file of readdirSync4(modelsDir)) {
         if (file.endsWith(".json")) {
-          const data = JSON.parse(readFileSync6(join6(modelsDir, file), "utf-8"));
+          const data = JSON.parse(readFileSync7(join7(modelsDir, file), "utf-8"));
           learnedRules += (data.rules || []).length;
         }
       }
@@ -3095,24 +4164,106 @@ function tryVersion(cmd) {
     return null;
   }
 }
+function detectTesting(cwd, structure, deps) {
+  const configs = new Set(structure.configFiles);
+  const depNames = new Set(deps.names);
+  const testFileCount = countTestFiles(cwd);
+  let framework = null;
+  if (depNames.has("vitest")) framework = "vitest";
+  else if (depNames.has("jest")) framework = "jest";
+  else if (depNames.has("mocha")) framework = "mocha";
+  else if (depNames.has("@playwright/test") || depNames.has("playwright")) framework = "playwright";
+  else if (depNames.has("pytest")) framework = "pytest";
+  else if (configs.has("pyproject.toml") || configs.has("setup.py")) framework = "pytest";
+  else if (configs.has("Cargo.toml")) framework = "cargo-test";
+  else if (configs.has("go.mod")) framework = "go-test";
+  let command = null;
+  const pkgJsonPath = join7(cwd, "package.json");
+  if (existsSync7(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync7(pkgJsonPath, "utf-8"));
+      if (pkg.scripts && typeof pkg.scripts.test === "string") {
+        command = pkg.scripts.test;
+      }
+    } catch {
+    }
+  }
+  return { hasTests: testFileCount > 0, testFileCount, framework, command };
+}
+function countTestFiles(cwd) {
+  const TEST_NAME = /(?:^|[._-])(?:test|spec)(?:[._-]|$)/i;
+  const TEST_DIRS = /* @__PURE__ */ new Set(["tests", "test", "__tests__"]);
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    ".venv",
+    "venv",
+    "env",
+    "__pycache__",
+    "dist",
+    "build",
+    "out",
+    "target",
+    "_build",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "coverage",
+    ".nyc_output"
+  ]);
+  let count = 0;
+  const stack = [cwd];
+  let budget = 1500;
+  while (stack.length > 0 && budget-- > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync4(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (SKIP.has(name) || name.startsWith(".")) continue;
+      const full = join7(dir, name);
+      let s;
+      try {
+        s = statSync(full);
+      } catch {
+        continue;
+      }
+      if (s.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (TEST_NAME.test(name)) {
+        count++;
+        continue;
+      }
+      const parent = basename4(dir);
+      if (TEST_DIRS.has(parent)) count++;
+    }
+  }
+  return count;
+}
 
 // src/sessions/store.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3, readdirSync as readdirSync5 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir7 } from "os";
-var SESSIONS_DIR = join7(homedir7(), ".prism", "sessions");
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir8 } from "os";
+import { randomBytes } from "crypto";
+var SESSIONS_DIR = join8(homedir8(), ".prism", "sessions");
 function ensureDir3() {
-  if (!existsSync7(SESSIONS_DIR)) {
-    mkdirSync3(SESSIONS_DIR, { recursive: true });
+  if (!existsSync8(SESSIONS_DIR)) {
+    mkdirSync4(SESSIONS_DIR, { recursive: true });
   }
 }
 function sessionPath(id) {
-  return join7(SESSIONS_DIR, `${id}.json`);
+  return join8(SESSIONS_DIR, `${id}.json`);
 }
 function createSession(model, provider, cwd) {
   ensureDir3();
   const now = /* @__PURE__ */ new Date();
-  const id = now.toISOString().replace(/[:.]/g, "-").slice(0, 23);
+  const id = now.toISOString().replace(/[:.]/g, "-").slice(0, 23) + "-" + randomBytes(3).toString("hex");
   return {
     id,
     model,
@@ -3127,13 +4278,13 @@ function saveSession(session) {
   ensureDir3();
   session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const path = sessionPath(session.id);
-  writeFileSync3(path, JSON.stringify(session, null, 2), "utf-8");
+  writeFileSync4(path, JSON.stringify(session, null, 2), "utf-8");
 }
 function loadSession(id) {
   const path = sessionPath(id);
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
@@ -3144,7 +4295,7 @@ function loadAllSorted() {
   const sessions = [];
   for (const file of files) {
     try {
-      sessions.push(JSON.parse(readFileSync7(join7(SESSIONS_DIR, file), "utf-8")));
+      sessions.push(JSON.parse(readFileSync8(join8(SESSIONS_DIR, file), "utf-8")));
     } catch {
       continue;
     }
@@ -3176,6 +4327,15 @@ var DESCRIPTION = "Spawn a subagent to handle a focused task. The subagent gets
 function createAgentTool(opts) {
   const subagentTools = opts.subagentTools.filter((t) => t.name !== "Agent");
   const boundCwd = opts.cwd ?? process.cwd();
+  const resolveRequested = (input) => {
+    try {
+      const requested = input.agent?.trim();
+      const agentName = requested && requested.length > 0 ? requested : void 0;
+      return resolveAgent(agentName, boundCwd);
+    } catch {
+      return null;
+    }
+  };
   return buildTool({
     name: "Agent",
     description: DESCRIPTION,
@@ -3205,7 +4365,8 @@ function createAgentTool(opts) {
         model: opts.model,
         tools: subagentTools,
         signal: context.signal,
-        onProgress: opts.onProgress
+        onProgress: opts.onProgress,
+        cwd: context.cwd
       });
       if (!result.success) {
         return {
@@ -3223,20 +4384,18 @@ ${result.output}`
     // inherit can write through the parent's resolver; two inherit agents
     // in the same batch could race on shared files. serialize those.
     // unresolvable agents (unknown name, broken file) → assume unsafe.
-    isConcurrencySafe: (input) => {
-      try {
-        const requested = input.agent?.trim();
-        const agentName = requested && requested.length > 0 ? requested : void 0;
-        const agent = resolveAgent(agentName, boundCwd);
-        return agent.permissions === "deny-writes";
-      } catch {
-        return false;
-      }
-    },
-    isReadOnly: () => true,
-    // agents report back, parent decides what to do
-    checkPermissions: () => ({ behavior: "allow" })
-    // auto-allow agent spawning
+    isConcurrencySafe: (input) => resolveRequested(input)?.permissions === "deny-writes",
+    // a spawn is only read-only when the requested agent cannot write. inherit
+    // agents write through the parent's resolver, so they are not read-only.
+    isReadOnly: (input) => resolveRequested(input)?.permissions === "deny-writes",
+    // deny-writes agents are sandboxed → auto-allow the spawn. inherit agents
+    // can mutate state through the parent's resolver → prompt before spawning.
+    checkPermissions: (input) => {
+      const agent = resolveRequested(input);
+      if (agent?.permissions === "deny-writes") return { behavior: "allow" };
+      const label = agent?.name ?? input.agent ?? "agent";
+      return { behavior: "ask", message: `spawn write-capable agent "${label}"` };
+    }
   });
 }
 
@@ -3300,9 +4459,8 @@ follow the skill instructions.]` };
     isConcurrencySafe: () => false,
     // not read-only: the skill body lands in the conversation framed as
     // "follow these instructions," which drives downstream Edit/Write/Bash
-    // calls. claiming read-only here short-circuits needsPermission() in
-    // orchestration.ts:54, killing the `requirePermission` gate. flagging
-    // false honors the operator's `require-permission: true` frontmatter.
+    // calls. isReadOnly is a concurrency/UI hint; the `require-permission`
+    // gate is enforced by checkPermissions below.
     isReadOnly: () => false,
     checkPermissions: (input) => {
       try {
@@ -3319,21 +4477,20 @@ follow the skill instructions.]` };
 
 // src/ui/bash.ts
 import { execSync as execSync3 } from "child_process";
-var MAX_OUTPUT = 512 * 1024;
-var TIMEOUT_MS = 3e4;
 function handleBashCommand(input, setMessages) {
   if (!input.startsWith("!")) return false;
   const cmd = input.slice(1).trim();
   if (!cmd) return true;
   setMessages((prev) => [...prev, { role: "tool_call", text: "", toolName: `! ${cmd}` }]);
+  const { tuning } = loadConfig();
   let output;
   let isError = false;
   try {
     output = execSync3(cmd, {
       cwd: process.cwd(),
       encoding: "utf-8",
-      timeout: TIMEOUT_MS,
-      maxBuffer: MAX_OUTPUT,
+      timeout: tuning.bash_timeout_ms,
+      maxBuffer: tuning.bash_max_output_bytes,
       stdio: ["pipe", "pipe", "pipe"]
     }).trim() || "(no output)";
   } catch (e) {
@@ -3613,14 +4770,17 @@ var OllamaProvider = class {
 
 // src/completion/spec.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir9 } from "os";
 var FLAGS = [
   { flag: "--or", alias: "--openrouter", desc: "use OpenRouter provider", takesValue: "model-openrouter", positionalValue: true },
   { flag: "-c", alias: "--continue", desc: "resume last session in this directory" },
   { flag: "-r", alias: "--resume", desc: "resume a specific session by id", takesValue: "session-id" },
   { flag: "--max-tokens", desc: "max output tokens per response", takesValue: "number" },
+  { flag: "--max-files", desc: "repo-map walk cap (overrides [tuning].repomap_max_files)", takesValue: "number" },
+  { flag: "--max-lines", desc: "repo-map render cap (overrides [tuning].repomap_max_lines)", takesValue: "number" },
+  { flag: "--no-repomap", desc: "skip the repo-map retrieval pass for this session" },
   { flag: "--config", desc: "show config file path" },
   { flag: "--sessions", desc: "list recent sessions" },
   { flag: "--no-scan", desc: "skip the live project scan at startup" },
@@ -3664,13 +4824,13 @@ var FALLBACK_OPENROUTER_MODELS = [
   { id: "anthropic/claude-haiku-4.5", context_length: 2e5, supported_parameters: ["tools", "tool_choice"] },
   { id: "anthropic/claude-sonnet-4", context_length: 2e5, supported_parameters: ["tools", "tool_choice"] }
 ];
-var CACHE_DIR = join8(homedir8(), ".prism", "cache");
-var OR_CACHE_PATH = join8(CACHE_DIR, "openrouter-models.json");
+var CACHE_DIR = join9(homedir9(), ".prism", "cache");
+var OR_CACHE_PATH = join9(CACHE_DIR, "openrouter-models.json");
 var TTL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
-  if (!existsSync8(OR_CACHE_PATH)) return null;
+  if (!existsSync9(OR_CACHE_PATH)) return null;
   try {
-    const raw = JSON.parse(readFileSync8(OR_CACHE_PATH, "utf-8"));
+    const raw = JSON.parse(readFileSync9(OR_CACHE_PATH, "utf-8"));
     if (!Array.isArray(raw.models) || raw.models.length === 0 || typeof raw.models[0] === "string") {
       return null;
     }
@@ -3681,8 +4841,8 @@ function readCache() {
 }
 function writeCache(models) {
   try {
-    if (!existsSync8(CACHE_DIR)) mkdirSync4(CACHE_DIR, { recursive: true });
-    writeFileSync4(OR_CACHE_PATH, JSON.stringify({ fetchedAt: Date.now(), models }), "utf-8");
+    if (!existsSync9(CACHE_DIR)) mkdirSync5(CACHE_DIR, { recursive: true });
+    writeFileSync5(OR_CACHE_PATH, JSON.stringify({ fetchedAt: Date.now(), models }), "utf-8");
   } catch {
   }
 }
@@ -3785,6 +4945,34 @@ function inferCapabilities(modelId, meta) {
   caps.parallelToolCalls = params.includes("tools") && params.includes("tool_choice");
   return caps;
 }
+function extractCachedTokens(u) {
+  if (!u) return 0;
+  return u.prompt_tokens_details?.cached_tokens ?? u.cache_read_input_tokens ?? u.prompt_cache_hit_tokens ?? 0;
+}
+function formatOpenRouterError(status, rawBody) {
+  let message = rawBody;
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (parsed.error?.message) message = parsed.error.message;
+  } catch {
+  }
+  if (status === 402) {
+    const m = message.match(/requested up to (\d+) tokens, but can only afford (\d+)/);
+    if (m) {
+      return `openrouter: out of credits. requested ${m[1]} tokens, only ${m[2]} affordable.
+  fix: lower max_tokens in config, or add credits at https://openrouter.ai/settings/credits`;
+    }
+    return "openrouter: out of credits. add credits at https://openrouter.ai/settings/credits, or lower max_tokens";
+  }
+  if (status === 401) {
+    return "openrouter: invalid api key. check OPENROUTER_API_KEY or ~/.prism/config.toml";
+  }
+  if (status === 429) {
+    return "openrouter: rate limited. try again in a moment";
+  }
+  const clamped = message.length > 240 ? message.slice(0, 240) + "..." : message;
+  return `openrouter ${status}: ${clamped}`;
+}
 var OpenRouterProvider = class {
   name = "openrouter";
   apiKey = "";
@@ -3829,7 +5017,7 @@ var OpenRouterProvider = class {
     });
     if (!res.ok) {
       const errorText = await res.text().catch(() => res.statusText);
-      yield { type: "error", error: `openrouter error: ${res.status} ${errorText}` };
+      yield { type: "error", error: formatOpenRouterError(res.status, errorText) };
       return;
     }
     const reader = res.body?.getReader();
@@ -3841,6 +5029,7 @@ var OpenRouterProvider = class {
     const messageId = crypto.randomUUID();
     let inputTokens = 0;
     let outputTokens = 0;
+    let cachedInputTokens = 0;
     const toolCalls = /* @__PURE__ */ new Map();
     yield { type: "message_start", id: messageId };
     let buffer = "";
@@ -3867,16 +5056,16 @@ var OpenRouterProvider = class {
         }
         if (choice.delta.tool_calls) {
           for (const tc of choice.delta.tool_calls) {
-            const idx = tc.index ?? 0;
-            if (!toolCalls.has(idx)) {
+            const key = tc.index ?? tc.id ?? 0;
+            if (!toolCalls.has(key)) {
               const id = tc.id || crypto.randomUUID();
               const name = tc.function?.name || "";
-              toolCalls.set(idx, { id, name, args: "" });
+              toolCalls.set(key, { id, name, args: "" });
               if (name) {
                 yield { type: "tool_call_start", id, name };
               }
             }
-            const existing = toolCalls.get(idx);
+            const existing = toolCalls.get(key);
             if (tc.function?.name && !existing.name) {
               existing.name = tc.function.name;
               yield { type: "tool_call_start", id: existing.id, name: existing.name };
@@ -3897,13 +5086,14 @@ var OpenRouterProvider = class {
         if (chunk.usage) {
           inputTokens = chunk.usage.prompt_tokens;
           outputTokens = chunk.usage.completion_tokens;
+          cachedInputTokens = extractCachedTokens(chunk.usage);
         }
       }
     }
     const stopReason = toolCalls.size > 0 ? "tool_use" : "end_turn";
     yield {
       type: "message_end",
-      usage: { inputTokens, outputTokens },
+      usage: { inputTokens, outputTokens, cachedInputTokens },
       stopReason
     };
   }
@@ -3922,7 +5112,7 @@ var OpenRouterProvider = class {
     });
     if (!res.ok) {
       const errorText = await res.text().catch(() => res.statusText);
-      throw new Error(`openrouter error: ${res.status} ${errorText}`);
+      throw new Error(formatOpenRouterError(res.status, errorText));
     }
     const data = await res.json();
     const choice = data.choices?.[0];
@@ -3934,15 +5124,18 @@ var OpenRouterProvider = class {
     if (choice.message.tool_calls) {
       for (const tc of choice.message.tool_calls) {
         let input = {};
+        let invalidArgs = false;
         try {
-          input = JSON.parse(tc.function.arguments);
+          input = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
         } catch {
+          invalidArgs = true;
         }
         content.push({
           type: "tool_use",
-          id: tc.id,
+          id: tc.id || crypto.randomUUID(),
           name: tc.function.name,
-          input
+          input,
+          ...invalidArgs ? { invalidArgs: true } : {}
         });
       }
     }
@@ -3952,7 +5145,8 @@ var OpenRouterProvider = class {
       content,
       usage: {
         inputTokens: data.usage?.prompt_tokens || 0,
-        outputTokens: data.usage?.completion_tokens || 0
+        outputTokens: data.usage?.completion_tokens || 0,
+        cachedInputTokens: extractCachedTokens(data.usage)
       },
       stopReason: hasTools ? "tool_use" : "end_turn"
     };
@@ -4046,126 +5240,463 @@ var OpenRouterProvider = class {
         }
       }
     }
-    return result;
+    return result;
+  }
+};
+
+// src/ui/useModelSwitch.ts
+async function switchModel(newModel, session, setProvider, setModel, setCaps, setDisplayMessages) {
+  const config = loadConfig();
+  const isOpenRouter = newModel.includes("/");
+  let newProvider;
+  if (isOpenRouter) {
+    const or = new OpenRouterProvider();
+    await or.connect({ model: newModel, apiKey: config.openrouter.api_key });
+    newProvider = or;
+  } else {
+    const ollama = new OllamaProvider();
+    await ollama.connect({ model: newModel, baseUrl: config.ollama.base_url });
+    newProvider = ollama;
+  }
+  setProvider(newProvider);
+  setModel(newModel);
+  setCaps(newProvider.getCapabilities());
+  session.model = newModel;
+  session.provider = newProvider.name;
+  saveSession(session);
+  setDisplayMessages((prev) => [...prev, { role: "tool_result", text: `switched to ${newModel}`, isError: false }]);
+}
+
+// src/retrieval/repomap.ts
+import { readdirSync as readdirSync7, statSync as statSync3, lstatSync, readFileSync as readFileSync12 } from "fs";
+import { join as join12, relative } from "path";
+
+// src/retrieval/languages.ts
+import { extname as extname2, basename as basename5 } from "path";
+var EXT_MAP = {
+  // typescript / javascript
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  // scripting
+  ".py": "python",
+  ".pyw": "python",
+  ".pyx": "python",
+  ".rb": "ruby",
+  ".php": "php",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".jl": "julia",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  // systems
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hh": "cpp",
+  ".rs": "rust",
+  ".go": "go",
+  ".zig": "zig",
+  // jvm
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  // dotnet
+  ".cs": "c-sharp",
+  // mobile
+  ".swift": "swift",
+  ".dart": "dart",
+  // functional
+  ".hs": "haskell",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  // markup / data
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".json": "json",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".md": "markdown",
+  ".mdx": "markdown",
+  ".sql": "sql",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".svelte": "svelte"
+};
+var FILENAME_MAP = {
+  "Dockerfile": "dockerfile",
+  "Containerfile": "dockerfile",
+  "Makefile": "make",
+  "makefile": "make",
+  "GNUmakefile": "make"
+};
+function detectLanguage2(filePath) {
+  const base = basename5(filePath);
+  if (FILENAME_MAP[base]) return FILENAME_MAP[base];
+  const ext = extname2(filePath).toLowerCase();
+  return EXT_MAP[ext] ?? null;
+}
+function knownLanguages() {
+  return /* @__PURE__ */ new Set([...Object.values(EXT_MAP), ...Object.values(FILENAME_MAP)]);
+}
+
+// src/retrieval/treesitter.ts
+import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
+import { dirname, join as join10 } from "path";
+import { fileURLToPath } from "url";
+import { Parser, Language } from "web-tree-sitter";
+var initPromise = null;
+var grammars = /* @__PURE__ */ new Map();
+var resolvedWasmDir = null;
+function wasmDir() {
+  if (resolvedWasmDir) return resolvedWasmDir;
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join10(here, "wasm"),
+    // dist/cli.js → dist/wasm/ (bundled)
+    join10(here, "..", "wasm", "build"),
+    // src/retrieval/foo.ts → wasm/build (dev, tsx)
+    join10(here, "..", "..", "wasm", "build")
+    // dist/cli.js fallback if dist/ is one level deeper
+  ];
+  for (const c of candidates) {
+    if (existsSync10(c)) {
+      resolvedWasmDir = c;
+      return c;
+    }
+  }
+  throw new Error(
+    `grammar wasm directory not found. checked: ${candidates.join(", ")}. run \`npm run build:wasms\` to build them, or \`npm run cp:wasms\` to copy from wasm/build to dist/wasm.`
+  );
+}
+async function ensureInit() {
+  if (!initPromise) initPromise = Parser.init();
+  return initPromise;
+}
+async function loadGrammar(language) {
+  if (grammars.has(language)) return grammars.get(language);
+  await ensureInit();
+  const path = join10(wasmDir(), `tree-sitter-${language}.wasm`);
+  if (!existsSync10(path)) {
+    grammars.set(language, null);
+    return null;
+  }
+  try {
+    const lang = await Language.load(readFileSync10(path));
+    grammars.set(language, lang);
+    return lang;
+  } catch {
+    grammars.set(language, null);
+    return null;
+  }
+}
+async function extractSymbols(filePath, source) {
+  const language = detectLanguage2(filePath);
+  if (!language) return null;
+  const grammar = await loadGrammar(language);
+  if (!grammar) return null;
+  const parser = new Parser();
+  parser.setLanguage(grammar);
+  const tree = parser.parse(source);
+  if (!tree) {
+    parser.delete();
+    return null;
+  }
+  const symbols = [];
+  const imports = [];
+  const root = tree.rootNode;
+  collectFromNode(root, symbols, imports);
+  tree.delete();
+  parser.delete();
+  return { language, symbols, imports };
+}
+function collectFromNode(root, symbols, imports) {
+  for (let i = 0; i < root.childCount; i++) {
+    const child = root.child(i);
+    if (!child) continue;
+    pushSymbolIfNamed(child, symbols);
+    pushImportIfImport(child, imports);
+    if (child.type === "export_statement") {
+      for (let j = 0; j < child.childCount; j++) {
+        const inner = child.child(j);
+        if (inner) pushSymbolIfNamed(inner, symbols);
+      }
+    }
+  }
+}
+function pushSymbolIfNamed(node, symbols) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const firstLine = node.text.split("\n")[0] ?? "";
+  symbols.push({
+    kind: node.type,
+    name: nameNode.text,
+    line: node.startPosition.row + 1,
+    signature: firstLine.length > 100 ? firstLine.slice(0, 100) + "..." : firstLine
+  });
+}
+function pushImportIfImport(node, imports) {
+  if (!node.type.includes("import") && node.type !== "use_declaration") return;
+  const src = findStringDescendant(node);
+  if (src) imports.push(src);
+}
+function findStringDescendant(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "string" || child.type === "string_literal") {
+      return child.text.replace(/^["'`]|["'`]$/g, "");
+    }
+    const nested = findStringDescendant(child);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+// src/retrieval/cache.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync6, renameSync, readdirSync as readdirSync6, rmSync, statSync as statSync2 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir10 } from "os";
+import { createHash as createHash3 } from "crypto";
+var ROOT = join11(homedir10(), ".prism", "cache", "trees");
+function cacheDir(projectId) {
+  return join11(ROOT, projectId);
+}
+function hashPath(filePath) {
+  return createHash3("sha256").update(filePath).digest("hex").slice(0, 16);
+}
+function entryFile(projectId, filePath) {
+  return join11(cacheDir(projectId), `${hashPath(filePath)}.json`);
+}
+function getCached(projectId, filePath, mtime, size) {
+  const path = entryFile(projectId, filePath);
+  if (!existsSync11(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync11(path, "utf-8"));
+    if (data.path !== filePath) return null;
+    if (data.mtime !== mtime) return null;
+    if (data.size !== size) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function setCached(projectId, filePath, data) {
+  const dir = cacheDir(projectId);
+  if (!existsSync11(dir)) {
+    try {
+      mkdirSync6(dir, { recursive: true });
+    } catch {
+      return;
+    }
   }
-};
-
-// src/config/config.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir9 } from "os";
-var PRISM_DIR = join9(homedir9(), ".prism");
-var CONFIG_PATH = join9(PRISM_DIR, "config.toml");
-var DEFAULTS = {
-  default_provider: "ollama",
-  default_model: "deepseek-r1:14b",
-  openrouter: { api_key: "" },
-  anthropic: { api_key: "" },
-  openai: { api_key: "" },
-  google: { api_key: "" },
-  ollama: { base_url: "http://localhost:11434" }
-};
-function loadConfig() {
-  const config = { ...DEFAULTS };
-  if (existsSync9(CONFIG_PATH)) {
+  const entry = {
+    path: filePath,
+    mtime: data.mtime,
+    size: data.size,
+    language: data.language,
+    symbols: data.symbols,
+    imports: data.imports,
+    cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const final = entryFile(projectId, filePath);
+  const tmp = `${final}.${process.pid}.tmp`;
+  try {
+    writeFileSync6(tmp, JSON.stringify(entry), "utf-8");
+    renameSync(tmp, final);
+  } catch {
     try {
-      const text = readFileSync9(CONFIG_PATH, "utf-8");
-      const parsed = parseToml(text);
-      if (parsed.default_provider) config.default_provider = parsed.default_provider;
-      if (parsed.default_model) config.default_model = parsed.default_model;
-      if (parsed.openrouter?.api_key) config.openrouter.api_key = parsed.openrouter.api_key;
-      if (parsed.anthropic?.api_key) config.anthropic.api_key = parsed.anthropic.api_key;
-      if (parsed.openai?.api_key) config.openai.api_key = parsed.openai.api_key;
-      if (parsed.google?.api_key) config.google.api_key = parsed.google.api_key;
-      if (parsed.ollama?.base_url) config.ollama.base_url = parsed.ollama.base_url;
+      rmSync(tmp, { force: true });
     } catch {
     }
   }
-  if (process.env.OPENROUTER_API_KEY) config.openrouter.api_key = process.env.OPENROUTER_API_KEY;
-  if (process.env.ANTHROPIC_API_KEY) config.anthropic.api_key = process.env.ANTHROPIC_API_KEY;
-  if (process.env.OPENAI_API_KEY) config.openai.api_key = process.env.OPENAI_API_KEY;
-  if (process.env.GOOGLE_API_KEY) config.google.api_key = process.env.GOOGLE_API_KEY;
-  if (process.env.OLLAMA_HOST) config.ollama.base_url = process.env.OLLAMA_HOST;
-  return config;
 }
-function initConfig() {
-  if (existsSync9(CONFIG_PATH)) return;
-  if (!existsSync9(PRISM_DIR)) {
-    mkdirSync5(PRISM_DIR, { recursive: true });
-  }
-  const template = `# prism config
-# env vars override these values.
-
-default_provider = "ollama"
-default_model = "deepseek-r1:14b"
-
-[openrouter]
-api_key = ""
-
-[anthropic]
-api_key = ""
-
-[openai]
-api_key = ""
-
-[google]
-api_key = ""
 
-[ollama]
-base_url = "http://localhost:11434"
-`;
-  writeFileSync5(CONFIG_PATH, template, "utf-8");
-}
-function getConfigPath() {
-  return CONFIG_PATH;
-}
-function parseToml(text) {
-  const result = {};
-  let currentSection = result;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
-    if (sectionMatch) {
-      const key = sectionMatch[1];
-      result[key] = result[key] || {};
-      currentSection = result[key];
+// src/retrieval/repomap.ts
+var IGNORE_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "env",
+  "__pycache__",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  "dist",
+  "build",
+  "out",
+  "target",
+  "_build",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".astro",
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  "vendor",
+  "deps",
+  "_deps",
+  "coverage",
+  ".nyc_output",
+  ".idea",
+  ".vscode",
+  ".fleet",
+  // prism build artifact: wasm/sources/ holds cloned grammar repos (zig,
+  // python, etc.); wasm/build/ holds the compiled wasms. neither is "the
+  // project," both confuse the repo-map with generated parser code.
+  "wasm"
+]);
+async function extractRepoMap(cwd, opts = {}) {
+  const { tuning } = loadConfig();
+  const maxFiles = opts.maxFiles ?? tuning.repomap_max_files;
+  const maxSymbolsPerFile = opts.maxSymbolsPerFile ?? tuning.repomap_max_symbols_per_file;
+  const ignore = /* @__PURE__ */ new Set([...IGNORE_DIRS2, ...opts.extraIgnore ?? []]);
+  const supported = knownLanguages();
+  const candidates = walkProject(cwd, ignore, supported, maxFiles);
+  const projectId = getProjectId(cwd);
+  const entries = [];
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  let parseFailures = 0;
+  for (const filePath of candidates) {
+    let mtime = 0;
+    let size = 0;
+    try {
+      const st = statSync3(filePath);
+      mtime = st.mtimeMs;
+      size = st.size;
+    } catch {
       continue;
     }
-    const kvMatch = trimmed.match(/^(\w+)\s*=\s*"([^"]*)"$/);
-    if (kvMatch) {
-      currentSection[kvMatch[1]] = kvMatch[2];
+    const cached = getCached(projectId, filePath, mtime, size);
+    if (cached) {
+      cacheHits += 1;
+      if (cached.symbols.length > 0) {
+        entries.push({
+          path: relative(cwd, filePath),
+          language: cached.language,
+          symbols: cached.symbols.slice(0, maxSymbolsPerFile)
+        });
+      }
       continue;
     }
-    const kvUnquoted = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
-    if (kvUnquoted) {
-      currentSection[kvUnquoted[1]] = kvUnquoted[2].trim();
+    cacheMisses += 1;
+    let source;
+    try {
+      source = readFileSync12(filePath, "utf-8");
+    } catch {
+      parseFailures += 1;
+      continue;
+    }
+    const result = await extractSymbols(filePath, source);
+    if (!result) {
+      parseFailures += 1;
+      continue;
+    }
+    setCached(projectId, filePath, {
+      mtime,
+      size,
+      language: result.language,
+      symbols: result.symbols,
+      imports: result.imports
+    });
+    if (result.symbols.length > 0) {
+      entries.push({
+        path: relative(cwd, filePath),
+        language: result.language,
+        symbols: result.symbols.slice(0, maxSymbolsPerFile)
+      });
     }
   }
-  return result;
+  return {
+    cwd,
+    entries,
+    filesWalked: candidates.length,
+    cacheHits,
+    cacheMisses,
+    parseFailures
+  };
 }
-
-// src/ui/useModelSwitch.ts
-async function switchModel(newModel, session, setProvider, setModel, setCaps, setDisplayMessages) {
-  const config = loadConfig();
-  const isOpenRouter = newModel.includes("/");
-  let newProvider;
-  if (isOpenRouter) {
-    const or = new OpenRouterProvider();
-    await or.connect({ model: newModel, apiKey: config.openrouter.api_key });
-    newProvider = or;
-  } else {
-    const ollama = new OllamaProvider();
-    await ollama.connect({ model: newModel, baseUrl: config.ollama.base_url });
-    newProvider = ollama;
+function formatRepoMap(data, opts = {}) {
+  const maxLines = opts.maxLines ?? loadConfig().tuning.repomap_max_lines;
+  if (data.entries.length === 0) return "";
+  const lines = ["# repo map", ""];
+  let truncated = 0;
+  for (let i = 0; i < data.entries.length; i++) {
+    const entry = data.entries[i];
+    const block = [entry.path];
+    for (const sym of entry.symbols) {
+      const kind = sym.kind.replace(/_declaration$|_definition$/, "");
+      block.push(`  ${kind} ${sym.name}`);
+    }
+    if (lines.length + block.length + 1 > maxLines) {
+      truncated = data.entries.length - i;
+      break;
+    }
+    lines.push(...block);
+    lines.push("");
   }
-  setProvider(newProvider);
-  setModel(newModel);
-  setCaps(newProvider.getCapabilities());
-  session.model = newModel;
-  session.provider = newProvider.name;
-  saveSession(session);
-  setDisplayMessages((prev) => [...prev, { role: "tool_result", text: `switched to ${newModel}`, isError: false }]);
+  if (truncated > 0) {
+    lines.push(`...and ${truncated} more files (call Read or Grep to inspect)`);
+  }
+  return lines.join("\n").trimEnd();
+}
+function walkProject(cwd, ignore, supportedLangs, maxFiles) {
+  const results = [];
+  const stack = [cwd];
+  while (stack.length > 0 && results.length < maxFiles) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync7(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (ignore.has(name)) continue;
+      if (name.startsWith(".")) continue;
+      const path = join12(dir, name);
+      let s;
+      try {
+        s = lstatSync(path);
+      } catch {
+        continue;
+      }
+      if (s.isSymbolicLink()) continue;
+      if (s.isDirectory()) {
+        stack.push(path);
+      } else if (s.isFile()) {
+        const lang = detectLanguage2(name);
+        if (lang && supportedLangs.has(lang)) {
+          results.push(path);
+          if (results.length >= maxFiles) break;
+        }
+      }
+    }
+  }
+  return results;
 }
 
 // src/ui/App.tsx
@@ -4197,20 +5728,24 @@ function rebuildDisplayMessages(messages) {
   }
   return display;
 }
-function App({ provider: initProvider, model: initModel, tools: baseTools, capabilities: initCaps, session, initialMessages, projectContext: initProjectContext, memory }) {
+function App({ provider: initProvider, model: initModel, tools: baseTools, capabilities: initCaps, session, initialMessages, projectContext: initProjectContext, memory, repoMapOverride }) {
   const [provider, setProvider] = useState3(initProvider);
   const [model, setModel] = useState3(initModel);
   const [caps, setCaps] = useState3(initCaps);
   const { exit } = useApp();
   const [displayMessages, setDisplayMessages] = useState3(() => rebuildDisplayMessages(initialMessages));
   const [isLoading, setIsLoading] = useState3(false);
+  const submittingRef = useRef3(false);
   const [turnCount, setTurnCount] = useState3(0);
   const [tokenInfo, setTokenInfo] = useState3("");
+  const [spinnerPhase, setSpinnerPhase] = useState3("thinking");
+  const [spinnerTool, setSpinnerTool] = useState3(void 0);
   const [profile, setProfile] = useState3(() => loadProfile(model));
   const [pendingPermission, setPendingPermission] = useState3(null);
   const [abortController, setAbortController] = useState3(null);
   const [inPlanMode, setInPlanMode] = useState3(false);
   const [activeSkills, setActiveSkills] = useState3(/* @__PURE__ */ new Set());
+  const [repoMap, setRepoMap] = useState3("");
   const [projectContext] = useState3(() => initProjectContext ?? scanProject(process.cwd()));
   const [messages] = useState3(() => initialMessages ? [...initialMessages] : []);
   const [agentTool] = useState3(() => createAgentTool({
@@ -4235,6 +5770,25 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
     }
   }));
   const [skillTool] = useState3(() => createSkillTool(process.cwd()));
+  useEffect3(() => {
+    if (repoMapOverride?.skip) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const data = await extractRepoMap(process.cwd(), {
+          ...repoMapOverride?.maxFiles ? { maxFiles: repoMapOverride.maxFiles } : {}
+        });
+        const formatted = formatRepoMap(data, {
+          ...repoMapOverride?.maxLines ? { maxLines: repoMapOverride.maxLines } : {}
+        });
+        if (!cancelled) setRepoMap(formatted);
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
   const tools = useMemo2(() => [...baseTools, agentTool, skillTool], [baseTools, agentTool, skillTool]);
   const toolSchemas = useMemo2(() => tools.map((t) => toolToSchema(t)), [tools]);
   const getSystemPrompt = useCallback3(() => {
@@ -4250,9 +5804,10 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
       projectContext,
       memory,
       inPlanMode,
-      activeSkills
+      activeSkills,
+      repoMap
     });
-  }, [caps, toolSchemas, profile, memory, inPlanMode, activeSkills]);
+  }, [caps, toolSchemas, profile, memory, inPlanMode, activeSkills, repoMap]);
   useInput3((input, key) => {
     if (!isLoading && key.ctrl && input === "c") {
       exit();
@@ -4267,11 +5822,13 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
   const runModelLoop = useCallback3(async () => {
     setTurnCount((prev) => prev + 1);
     setIsLoading(true);
+    setSpinnerPhase("thinking");
+    setSpinnerTool(void 0);
     const controller = new AbortController();
     setAbortController(controller);
     const askPermission = (toolName, description, id) => {
-      return new Promise((resolve6) => {
-        setPendingPermission({ toolName, description, id, resolve: resolve6 });
+      return new Promise((resolve7) => {
+        setPendingPermission({ toolName, description, id, resolve: resolve7 });
       });
     };
     let currentText = "";
@@ -4301,9 +5858,13 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
             });
             break;
           case "tool_start":
+            setSpinnerPhase("running");
+            setSpinnerTool(event.name);
             setDisplayMessages((prev) => [...prev, { role: "tool_call", text: "", toolName: event.name }]);
             break;
           case "tool_end":
+            setSpinnerPhase("after-tool");
+            setSpinnerTool(event.name);
             setDisplayMessages((prev) => [...prev, { role: "tool_result", text: event.result, isError: event.isError }]);
             currentText = "";
             break;
@@ -4350,11 +5911,11 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
       messages.push({ role: "user", content: [{ type: "text", text: "the user interrupted the current operation. stop what you were doing and ask what they want instead." }] });
     }
     session.messages = messages;
-    saveSession(session);
     setTimeout(() => {
       setAbortController(null);
       setIsLoading(false);
     }, 0);
+    setTimeout(() => saveSession(session), 0);
   }, [provider, model, tools, messages, getSystemPrompt, session]);
   const triggerSyntheticTurn = useCallback3((hiddenMsg) => {
     messages.push({ role: "user", content: [{ type: "text", text: hiddenMsg }] });
@@ -4382,9 +5943,15 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
       });
       if (handled) return;
     }
-    setDisplayMessages((prev) => [...prev, { role: "user", text: input }]);
-    messages.push({ role: "user", content: [{ type: "text", text: input }] });
-    await runModelLoop();
+    if (submittingRef.current) return;
+    submittingRef.current = true;
+    try {
+      setDisplayMessages((prev) => [...prev, { role: "user", text: input }]);
+      messages.push({ role: "user", content: [{ type: "text", text: input }] });
+      await runModelLoop();
+    } finally {
+      submittingRef.current = false;
+    }
   }, [provider, model, tools, messages, getSystemPrompt, inPlanMode, triggerSyntheticTurn]);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
     /* @__PURE__ */ jsx8(
@@ -4419,7 +5986,9 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
         onSubmit: handleSubmit,
         isLoading,
         inPlanMode,
-        invokeSkills: invokeSkillSpecs
+        invokeSkills: invokeSkillSpecs,
+        phase: spinnerPhase,
+        currentTool: spinnerTool
       }
     )
   ] });
@@ -4427,8 +5996,49 @@ function App({ provider: initProvider, model: initModel, tools: baseTools, capab
 
 // src/tools/bash.ts
 import { z as z4 } from "zod";
-import { execSync as execSync5 } from "child_process";
-var MAX_OUTPUT2 = 512 * 1024;
+import { exec as exec2 } from "child_process";
+import { promisify } from "util";
+
+// src/tools/sensitivePaths.ts
+import { resolve, relative as relative2, isAbsolute, basename as basename6, join as join13 } from "path";
+import { homedir as homedir11 } from "os";
+import { realpathSync } from "fs";
+var SECRET_NAME = /^(\.env(\..+)?|\.netrc|\.git-credentials|\.npmrc|id_(rsa|ed25519|ecdsa|dsa)|credentials)$/i;
+var SECRET_EXT = /\.(pem|key|p12|pfx|keystore)$/i;
+function expandHome(p) {
+  if (p === "~") return homedir11();
+  if (p.startsWith("~/")) return join13(homedir11(), p.slice(2));
+  return p;
+}
+function realOrLexical(p) {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return p;
+  }
+}
+function classifyRead(targetPath, cwd) {
+  if (targetPath.startsWith("~") && targetPath !== "~" && !targetPath.startsWith("~/")) {
+    return { allow: false, reason: "outside-project" };
+  }
+  const expanded = expandHome(targetPath);
+  const abs = realOrLexical(isAbsolute(expanded) ? expanded : resolve(cwd, expanded));
+  const root = realOrLexical(resolve(cwd));
+  const rel = relative2(root, abs);
+  const outside = rel.split(/[\\/]/)[0] === ".." || isAbsolute(rel);
+  if (outside) return { allow: false, reason: "outside-project" };
+  const name = basename6(abs);
+  if (SECRET_NAME.test(name) || SECRET_EXT.test(name)) {
+    return { allow: false, reason: "secret-name" };
+  }
+  return { allow: true, reason: "in-project" };
+}
+function readAskMessage(targetPath, reason) {
+  return reason === "secret-name" ? `read possible secret file: ${targetPath}` : `read file outside the project: ${targetPath}`;
+}
+
+// src/tools/bash.ts
+var execAsync = promisify(exec2);
 var SAFE_COMMANDS = /* @__PURE__ */ new Set([
   "ls",
   "cat",
@@ -4478,6 +6088,14 @@ var DANGEROUS_PATTERNS = [
   /\bmkfs\b/,
   /\bkill\s+-9\b/
 ];
+var SHELL_METACHARS = /[;&|<>$`\n()]/;
+function isSimpleSafeCommand(command) {
+  const cmd = command.trim();
+  if (SHELL_METACHARS.test(cmd)) return false;
+  if (DANGEROUS_PATTERNS.some((p) => p.test(cmd))) return false;
+  const firstToken = cmd.split(/\s+/)[0] || "";
+  return SAFE_COMMANDS.has(firstToken) || SAFE_COMMANDS.has(cmd);
+}
 var inputSchema2 = z4.object({
   command: z4.string().describe("the shell command to execute"),
   description: z4.string().optional().describe("what this command does"),
@@ -4488,21 +6106,19 @@ var BashTool = buildTool({
   description: "Execute a shell command and return its output.",
   inputSchema: inputSchema2,
   async call(input, context) {
+    const maxOutput = loadConfig().tuning.bash_max_output_bytes;
     const timeout = Math.min(input.timeout || 12e4, 6e5);
     try {
-      const output = execSync5(input.command, {
+      const { stdout } = await execAsync(input.command, {
         cwd: context.cwd,
         timeout,
-        maxBuffer: MAX_OUTPUT2,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
+        maxBuffer: maxOutput,
         env: { ...process.env }
       });
-      const stderr = "";
-      const result = output.trim();
-      if (result.length > MAX_OUTPUT2) {
+      const result = stdout.trim();
+      if (result.length > maxOutput) {
         return {
-          content: result.slice(0, MAX_OUTPUT2) + "\n\n[output truncated]"
+          content: result.slice(0, maxOutput) + "\n\n[output truncated]"
         };
       }
       return { content: result || "(no output)" };
@@ -4510,7 +6126,7 @@ var BashTool = buildTool({
       const execError = error;
       const stdout = execError.stdout?.toString().trim() || "";
       const stderr = execError.stderr?.toString().trim() || "";
-      const exitCode = execError.status ?? 1;
+      const exitCode = execError.code ?? 1;
       let content = "";
       if (stdout) content += stdout + "\n";
       if (stderr) content += stderr + "\n";
@@ -4520,14 +6136,12 @@ Exit code: ${exitCode}`;
     }
   },
   isConcurrencySafe(input) {
-    const cmd = input.command.trim().split(/\s+/)[0] || "";
-    return SAFE_COMMANDS.has(cmd) || SAFE_COMMANDS.has(input.command.trim());
+    return isSimpleSafeCommand(input.command);
   },
   isReadOnly(input) {
-    const cmd = input.command.trim().split(/\s+/)[0] || "";
-    return SAFE_COMMANDS.has(cmd) || SAFE_COMMANDS.has(input.command.trim());
+    return isSimpleSafeCommand(input.command);
   },
-  checkPermissions(input) {
+  checkPermissions(input, context) {
     for (const pattern of DANGEROUS_PATTERNS) {
       if (pattern.test(input.command)) {
         return {
@@ -4536,7 +6150,14 @@ Exit code: ${exitCode}`;
         };
       }
     }
-    if (SAFE_COMMANDS.has(input.command.trim().split(/\s+/)[0] || "")) {
+    if (isSimpleSafeCommand(input.command)) {
+      const args = input.command.trim().split(/\s+/).slice(1);
+      for (const arg of args) {
+        if (arg.startsWith("-")) continue;
+        if (!classifyRead(arg, context.cwd).allow) {
+          return { behavior: "ask", message: `run: ${input.command}` };
+        }
+      }
       return { behavior: "allow" };
     }
     return { behavior: "ask", message: `run: ${input.command}` };
@@ -4545,11 +6166,11 @@ Exit code: ${exitCode}`;
 
 // src/tools/read.ts
 import { z as z5 } from "zod";
-import { readFileSync as readFileSync13, statSync as statSync2 } from "fs";
-import { resolve, isAbsolute, extname as extname3 } from "path";
+import { readFileSync as readFileSync16, statSync as statSync4 } from "fs";
+import { resolve as resolve2, isAbsolute as isAbsolute2, extname as extname4 } from "path";
 
 // src/parsers/pdf.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync } from "child_process";
 function parsePdf(filePath, pages) {
   const args = ["-layout"];
   if (pages) {
@@ -4558,7 +6179,7 @@ function parsePdf(filePath, pages) {
   }
   args.push(filePath, "-");
   try {
-    const output = execFileSync2("pdftotext", args, {
+    const output = execFileSync("pdftotext", args, {
       encoding: "utf-8",
       timeout: 3e4,
       maxBuffer: 5 * 1024 * 1024
@@ -4582,18 +6203,23 @@ function parsePageRange(range) {
 }
 
 // src/parsers/docx.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 async function parseDocx(filePath) {
   const mammoth = await import("mammoth");
-  const buffer = readFileSync10(filePath);
+  const buffer = readFileSync13(filePath);
   const result = await mammoth.extractRawText({ buffer });
   return result.value.trim() || "(no text content in document)";
 }
 
 // src/parsers/notebook.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
+function joinSource(s) {
+  if (Array.isArray(s)) return s.join("");
+  if (typeof s === "string") return s;
+  return "";
+}
 function parseNotebook(filePath) {
-  const raw = readFileSync11(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const notebook = JSON.parse(raw);
   if (!notebook.cells || notebook.cells.length === 0) {
     return "(empty notebook)";
@@ -4601,7 +6227,7 @@ function parseNotebook(filePath) {
   const parts = [];
   for (let i = 0; i < notebook.cells.length; i++) {
     const cell = notebook.cells[i];
-    const source = cell.source.join("");
+    const source = joinSource(cell.source);
     if (cell.cell_type === "markdown") {
       parts.push(`[cell ${i + 1} markdown]
 ${source}`);
@@ -4612,13 +6238,13 @@ ${source}`);
         for (const out of cell.outputs) {
           if (out.text) {
             parts.push(`[output]
-${out.text.join("")}`);
+${joinSource(out.text)}`);
           }
           if (out.data) {
             for (const [mime, content] of Object.entries(out.data)) {
               if (mime.startsWith("text/")) {
                 parts.push(`[output ${mime}]
-${content.join("")}`);
+${joinSource(content)}`);
               } else {
                 parts.push(`[output ${mime}] (binary content)`);
               }
@@ -4635,8 +6261,8 @@ ${source}`);
 }
 
 // src/parsers/image.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { extname as extname2 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { extname as extname3 } from "path";
 var MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -4647,9 +6273,9 @@ var MIME_TYPES = {
   ".bmp": "image/bmp"
 };
 function parseImage(filePath) {
-  const ext = extname2(filePath).toLowerCase();
+  const ext = extname3(filePath).toLowerCase();
   const mediaType = MIME_TYPES[ext] || "image/png";
-  const buffer = readFileSync12(filePath);
+  const buffer = readFileSync15(filePath);
   const base64 = buffer.toString("base64");
   const sizeKB = Math.round(buffer.length / 1024);
   return {
@@ -4659,7 +6285,7 @@ function parseImage(filePath) {
   };
 }
 function isImageFile(filePath) {
-  const ext = extname2(filePath).toLowerCase();
+  const ext = extname3(filePath).toLowerCase();
   return ext in MIME_TYPES;
 }
 
@@ -4676,16 +6302,16 @@ var ReadTool = buildTool({
   description: "Read a file from the filesystem. Supports text, PDF, Word (.docx), Jupyter notebooks (.ipynb), and images.",
   inputSchema: inputSchema3,
   async call(input, context) {
-    const filePath = isAbsolute(input.file_path) ? input.file_path : resolve(context.cwd, input.file_path);
+    const filePath = isAbsolute2(input.file_path) ? input.file_path : resolve2(context.cwd, input.file_path);
     try {
-      const stat = statSync2(filePath);
+      const stat = statSync4(filePath);
       if (stat.isDirectory()) {
         return { content: `error: "${filePath}" is a directory, not a file. use Bash with ls to list directory contents.`, isError: true };
       }
     } catch {
       return { content: `error: file not found: ${filePath}`, isError: true };
     }
-    const ext = extname3(filePath).toLowerCase();
+    const ext = extname4(filePath).toLowerCase();
     try {
       switch (ext) {
         case ".pdf":
@@ -4710,10 +6336,16 @@ var ReadTool = buildTool({
   },
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
-  checkPermissions: () => ({ behavior: "allow" })
+  // reads inside the project auto-allow; reads outside it (home dotfiles,
+  // ~/.ssh, /etc) and in-project secret files prompt, so an injected agent
+  // can't silently pull credentials into context.
+  checkPermissions: (input, context) => {
+    const c = classifyRead(input.file_path, context.cwd);
+    return c.allow ? { behavior: "allow" } : { behavior: "ask", message: readAskMessage(input.file_path, c.reason) };
+  }
 });
 function readTextFile(filePath, offset, limit) {
-  const content = readFileSync13(filePath, "utf-8");
+  const content = readFileSync16(filePath, "utf-8");
   const allLines = content.split("\n");
   const start = (offset ?? 1) - 1;
   const count = limit ?? MAX_LINES;
@@ -4730,8 +6362,8 @@ function readTextFile(filePath, offset, limit) {
 
 // src/tools/edit.ts
 import { z as z6 } from "zod";
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve2, isAbsolute as isAbsolute2 } from "path";
+import { readFile, writeFile } from "fs/promises";
+import { resolve as resolve3, isAbsolute as isAbsolute3 } from "path";
 var inputSchema4 = z6.object({
   file_path: z6.string().describe("absolute path to the file to edit"),
   old_string: z6.string().describe("the exact text to find and replace"),
@@ -4743,10 +6375,10 @@ var EditTool = buildTool({
   description: "Replace exact string matches in a file. old_string must match exactly including whitespace.",
   inputSchema: inputSchema4,
   async call(input, context) {
-    const filePath = isAbsolute2(input.file_path) ? input.file_path : resolve2(context.cwd, input.file_path);
+    const filePath = isAbsolute3(input.file_path) ? input.file_path : resolve3(context.cwd, input.file_path);
     let content;
     try {
-      content = readFileSync14(filePath, "utf-8");
+      content = await readFile(filePath, "utf-8");
     } catch {
       return { content: `error: file not found: ${filePath}`, isError: true };
     }
@@ -4770,7 +6402,7 @@ var EditTool = buildTool({
     }
     const updated = input.replace_all ? content.split(input.old_string).join(input.new_string) : content.replace(input.old_string, input.new_string);
     try {
-      writeFileSync6(filePath, updated, "utf-8");
+      await writeFile(filePath, updated, "utf-8");
       const replacements = input.replace_all ? content.split(input.old_string).length - 1 : 1;
       return { content: `edited ${filePath} (${replacements} replacement${replacements > 1 ? "s" : ""})` };
     } catch (error) {
@@ -4787,8 +6419,8 @@ var EditTool = buildTool({
 
 // src/tools/write.ts
 import { z as z7 } from "zod";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync10 } from "fs";
-import { resolve as resolve3, isAbsolute as isAbsolute3, dirname } from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync13 } from "fs";
+import { resolve as resolve4, isAbsolute as isAbsolute4, dirname as dirname2 } from "path";
 var inputSchema5 = z7.object({
   file_path: z7.string().describe("absolute path to the file to write"),
   content: z7.string().describe("the content to write to the file")
@@ -4798,11 +6430,11 @@ var WriteTool = buildTool({
   description: "Write content to a file. Creates the file if it does not exist. Overwrites if it does.",
   inputSchema: inputSchema5,
   async call(input, context) {
-    const filePath = isAbsolute3(input.file_path) ? input.file_path : resolve3(context.cwd, input.file_path);
+    const filePath = isAbsolute4(input.file_path) ? input.file_path : resolve4(context.cwd, input.file_path);
     try {
-      const dir = dirname(filePath);
-      if (!existsSync10(dir)) {
-        mkdirSync6(dir, { recursive: true });
+      const dir = dirname2(filePath);
+      if (!existsSync13(dir)) {
+        mkdirSync7(dir, { recursive: true });
       }
       writeFileSync7(filePath, input.content, "utf-8");
       const lineCount = input.content.split("\n").length;
@@ -4821,8 +6453,8 @@ var WriteTool = buildTool({
 
 // src/tools/glob.ts
 import { z as z8 } from "zod";
-import { execFileSync as execFileSync3 } from "child_process";
-import { resolve as resolve4, isAbsolute as isAbsolute4 } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import { resolve as resolve5, isAbsolute as isAbsolute5 } from "path";
 var inputSchema6 = z8.object({
   pattern: z8.string().describe('glob pattern to match files (e.g. "**/*.ts", "src/**/*.py")'),
   path: z8.string().optional().describe("directory to search in (default: cwd)")
@@ -4832,9 +6464,9 @@ var GlobTool = buildTool({
   description: "Find files matching a glob pattern. Returns file paths sorted by modification time.",
   inputSchema: inputSchema6,
   async call(input, context) {
-    const searchPath = input.path ? isAbsolute4(input.path) ? input.path : resolve4(context.cwd, input.path) : context.cwd;
+    const searchPath = input.path ? isAbsolute5(input.path) ? input.path : resolve5(context.cwd, input.path) : context.cwd;
     try {
-      const pattern = input.pattern.replace(/\*\*\//g, "");
+      const matchArgs = input.pattern.includes("/") ? ["-path", "*" + input.pattern.replace(/\*\*\//g, "").replace(/\*\*/g, "*")] : ["-name", input.pattern.replace(/\*\*\//g, "")];
       const excludeDirs = [
         "node_modules",
         ".git",
@@ -4855,9 +6487,9 @@ var GlobTool = buildTool({
       for (const d of excludeDirs) {
         excludeArgs.push("-not", "-path", `*/${d}/*`);
       }
-      const output = execFileSync3(
+      const output = execFileSync2(
         "find",
-        [searchPath, "-type", "f", "-name", pattern, ...excludeArgs],
+        [searchPath, "-type", "f", ...matchArgs, ...excludeArgs],
         {
           cwd: searchPath,
           encoding: "utf-8",
@@ -4886,13 +6518,18 @@ var GlobTool = buildTool({
   },
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
-  checkPermissions: () => ({ behavior: "allow" })
+  // enumerating a directory outside the project prompts: listing ~/.ssh or
+  // ~/.aws leaks the location of credentials even without reading them.
+  checkPermissions: (input, context) => {
+    const c = classifyRead(input.path ?? context.cwd, context.cwd);
+    return c.allow ? { behavior: "allow" } : { behavior: "ask", message: readAskMessage(input.path ?? context.cwd, c.reason) };
+  }
 });
 
 // src/tools/grep.ts
 import { z as z9 } from "zod";
-import { execFileSync as execFileSync4 } from "child_process";
-import { resolve as resolve5, isAbsolute as isAbsolute5 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import { resolve as resolve6, isAbsolute as isAbsolute6 } from "path";
 var inputSchema7 = z9.object({
   pattern: z9.string().describe("regex pattern to search for"),
   path: z9.string().optional().describe("file or directory to search in (default: cwd)"),
@@ -4904,7 +6541,7 @@ var useRipgrep = null;
 function hasRipgrep() {
   if (useRipgrep !== null) return useRipgrep;
   try {
-    execFileSync4("which", ["rg"], { stdio: "pipe" });
+    execFileSync3("which", ["rg"], { stdio: "pipe" });
     useRipgrep = true;
   } catch {
     useRipgrep = false;
@@ -4916,13 +6553,13 @@ var GrepTool = buildTool({
   description: "Search file contents for a regex pattern. Uses ripgrep if available.",
   inputSchema: inputSchema7,
   async call(input, context) {
-    const searchPath = input.path ? isAbsolute5(input.path) ? input.path : resolve5(context.cwd, input.path) : context.cwd;
+    const searchPath = input.path ? isAbsolute6(input.path) ? input.path : resolve6(context.cwd, input.path) : context.cwd;
     const mode = input.output_mode ?? "files_with_matches";
     try {
       const useRg = hasRipgrep();
       const bin = useRg ? "rg" : "grep";
       const args = useRg ? buildRgArgs(input.pattern, searchPath, mode, input.glob, input.context) : buildGrepArgs(input.pattern, searchPath, mode, input.glob, input.context);
-      const output = execFileSync4(bin, args, {
+      const output = execFileSync3(bin, args, {
         cwd: context.cwd,
         encoding: "utf-8",
         timeout: 3e4,
@@ -4953,7 +6590,12 @@ var GrepTool = buildTool({
   },
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
-  checkPermissions: () => ({ behavior: "allow" })
+  // searching outside the project (or a secret file) prompts: grep content mode
+  // returns file contents, so an unbounded search is a secret-read channel.
+  checkPermissions: (input, context) => {
+    const c = classifyRead(input.path ?? context.cwd, context.cwd);
+    return c.allow ? { behavior: "allow" } : { behavior: "ask", message: readAskMessage(input.path ?? context.cwd, c.reason) };
+  }
 });
 function buildRgArgs(pattern, path, mode, glob, ctx) {
   const args = [];
@@ -5002,6 +6644,7 @@ import TurndownService from "turndown";
 // src/net/safeFetch.ts
 import got from "got";
 import { lookup as dnsLookup } from "dns";
+import { isIP } from "net";
 
 // src/net/validate.ts
 import ipaddr from "ipaddr.js";
@@ -5132,9 +6775,17 @@ var strictPolicy = {
 
 // src/net/safeFetch.ts
 async function safeFetch(rawUrl, policy) {
-  const parsed = new URL(rawUrl);
-  validateScheme(rawUrl, parsed.protocol, policy.allowedSchemes);
-  validatePort(rawUrl, parsed.port, policy.allowedPorts);
+  const stripBrackets = (h) => h.startsWith("[") && h.endsWith("]") ? h.slice(1, -1) : h;
+  const assertUrlAllowed = (urlStr) => {
+    const u = new URL(urlStr);
+    validateScheme(urlStr, u.protocol, policy.allowedSchemes);
+    validatePort(urlStr, u.port, policy.allowedPorts);
+    const host = stripBrackets(u.hostname);
+    if (isIP(host) !== 0) {
+      validateIp(urlStr, host, policy.blockedIpRanges);
+    }
+  };
+  assertUrlAllowed(rawUrl);
   let lastResolvedIp = "";
   const pinningLookup = (hostname, options, cb) => {
     const optsArg = typeof options === "function" ? {} : options || {};
@@ -5167,7 +6818,18 @@ async function safeFetch(rawUrl, policy) {
       followRedirect: policy.maxRedirects > 0,
       dnsLookup: pinningLookup,
       headers: { "user-agent": policy.userAgent },
-      throwHttpErrors: true
+      throwHttpErrors: true,
+      hooks: {
+        // re-validate scheme, port, and any literal-IP target on every redirect
+        // hop. without this, a 302 to http://127.0.0.1:9/ or a forbidden port
+        // would be followed (got's internal redirect doesn't re-run these checks,
+        // and node skips the pinning lookup for IP literals).
+        beforeRedirect: [
+          (options) => {
+            assertUrlAllowed(options.url.toString());
+          }
+        ]
+      }
     });
   } catch (err) {
     if (err instanceof ForbiddenIpError || err instanceof ForbiddenSchemeError || err instanceof ForbiddenPortError) {
@@ -5209,20 +6871,20 @@ var turndown = new TurndownService({
   headingStyle: "atx",
   codeBlockStyle: "fenced"
 });
-var MAX_OUTPUT3 = 4e4;
+var MAX_OUTPUT = 4e4;
 function extractMarkdown(html) {
   const $ = cheerio.load(html);
   $("script, style, noscript, iframe").remove();
   const $container = $("article").first().length ? $("article").first() : $("main").first().length ? $("main").first() : $("body");
   $container.find("nav, footer, aside, [role=navigation], [role=banner], [role=contentinfo]").remove();
   let md = turndown.turndown($container.html() || "");
-  if (md.length > MAX_OUTPUT3) {
-    md = md.slice(0, MAX_OUTPUT3) + "\n\n[... content truncated ...]";
+  if (md.length > MAX_OUTPUT) {
+    md = md.slice(0, MAX_OUTPUT) + "\n\n[... content truncated ...]";
   }
   return md;
 }
 function truncate(s) {
-  return s.length > MAX_OUTPUT3 ? s.slice(0, MAX_OUTPUT3) + "\n\n[... content truncated ...]" : s;
+  return s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) + "\n\n[... content truncated ...]" : s;
 }
 var WebFetchTool = buildTool({
   name: "WebFetch",
@@ -5329,8 +6991,68 @@ var WebSearchTool = buildTool({
   checkPermissions: () => ({ behavior: "allow" })
 });
 
+// src/tools/verify.ts
+import { z as z12 } from "zod";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec3);
+var inputSchema9 = z12.object({
+  command: z12.string().describe("the verification command to run (e.g. `npx vitest run`, `pytest`, `cargo test`)"),
+  description: z12.string().optional().describe("one-line description of what is being verified"),
+  timeout: z12.number().optional().describe("timeout in milliseconds (default 60s, max 600s)")
+});
+var VerifyTool = buildTool({
+  name: "Verify",
+  description: "Run a project verification command (tests, typecheck, lint) and return its output. Derive the command from project scan and repo map. Use before claiming done after a non-trivial edit.",
+  inputSchema: inputSchema9,
+  async call(input, context) {
+    const maxOutput = loadConfig().tuning.bash_max_output_bytes;
+    const timeout = Math.min(input.timeout || 6e4, 6e5);
+    try {
+      const { stdout } = await execAsync2(input.command, {
+        cwd: context.cwd,
+        timeout,
+        maxBuffer: maxOutput,
+        env: { ...process.env }
+      });
+      const result = stdout.trim();
+      if (result.length > maxOutput) {
+        return { content: result.slice(0, maxOutput) + "\n\n[output truncated]" };
+      }
+      return { content: `verified: ${input.command}
+
+${result || "(no output)"}` };
+    } catch (error) {
+      const execError = error;
+      const stdout = execError.stdout?.toString().trim() || "";
+      const stderr = execError.stderr?.toString().trim() || "";
+      const exitCode = execError.code ?? 1;
+      const parts = [
+        `verification failed: ${input.command}`,
+        "",
+        stdout && stdout,
+        stderr && stderr,
+        `exit code: ${exitCode}`
+      ].filter(Boolean);
+      return { content: parts.join("\n"), isError: true };
+    }
+  },
+  // verification commands are observation, not mutation of the working tree.
+  // they may have incidental side effects (cache writes, coverage reports)
+  // but do not change source files the operator is authoring.
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  checkPermissions(input) {
+    return { behavior: "ask", message: `verify: ${input.command}` };
+  }
+});
+
 // src/cli.ts
-import { homedir as homedir11 } from "os";
+import { homedir as homedir13 } from "os";
 
 // src/completion/bash.ts
 function emitBash() {
@@ -5435,14 +7157,14 @@ compdef _prism prism
 }
 
 // src/completion/install.ts
-import { existsSync as existsSync11, readFileSync as readFileSync15, appendFileSync, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir10, platform } from "os";
-import { basename as basename5 } from "path";
-var FIRST_RUN_FLAG = join10(homedir10(), ".prism", ".completion-installed");
+import { existsSync as existsSync14, readFileSync as readFileSync17, appendFileSync, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir12, platform } from "os";
+import { basename as basename7 } from "path";
+var FIRST_RUN_FLAG = join14(homedir12(), ".prism", ".completion-installed");
 function detectShell() {
   const sh = process.env.SHELL || "";
-  const name = basename5(sh);
+  const name = basename7(sh);
   if (name === "zsh") return "zsh";
   if (name === "bash") return "bash";
   return null;
@@ -5450,13 +7172,13 @@ function detectShell() {
 function rcPathFor(shell) {
   if (shell === "zsh") {
     const zdotdir = process.env.ZDOTDIR;
-    return join10(zdotdir || homedir10(), ".zshrc");
+    return join14(zdotdir || homedir12(), ".zshrc");
   }
   if (platform() === "darwin") {
-    const profile = join10(homedir10(), ".bash_profile");
-    if (existsSync11(profile)) return profile;
+    const profile = join14(homedir12(), ".bash_profile");
+    if (existsSync14(profile)) return profile;
   }
-  return join10(homedir10(), ".bashrc");
+  return join14(homedir12(), ".bashrc");
 }
 var MARKER = "# prism shell completion";
 function evalLineFor(shell) {
@@ -5469,8 +7191,8 @@ function installCompletion(requested) {
   }
   const rcPath = rcPathFor(shell);
   const evalLine = evalLineFor(shell);
-  if (existsSync11(rcPath)) {
-    const contents = readFileSync15(rcPath, "utf-8");
+  if (existsSync14(rcPath)) {
+    const contents = readFileSync17(rcPath, "utf-8");
     if (contents.includes(evalLine)) {
       return { shell, rcPath, status: "already-installed" };
     }
@@ -5484,7 +7206,7 @@ ${evalLine}
 }
 function maybeAutoInstall() {
   if (process.env.PRISM_NO_AUTO_COMPLETION) return null;
-  if (existsSync11(FIRST_RUN_FLAG)) return null;
+  if (existsSync14(FIRST_RUN_FLAG)) return null;
   const shell = detectShell();
   if (!shell) {
     markFirstRunDone();
@@ -5500,24 +7222,26 @@ function maybeAutoInstall() {
 }
 function markFirstRunDone() {
   try {
-    const dir = join10(homedir10(), ".prism");
-    if (!existsSync11(dir)) mkdirSync7(dir, { recursive: true });
+    const dir = join14(homedir12(), ".prism");
+    if (!existsSync14(dir)) mkdirSync8(dir, { recursive: true });
     writeFileSync8(FIRST_RUN_FLAG, (/* @__PURE__ */ new Date()).toISOString(), "utf-8");
   } catch {
   }
 }
 
 // src/memory/lens.ts
-import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
-import { join as join11 } from "path";
-var MAX_LENS_BYTES = 64 * 1024;
+import { existsSync as existsSync15, readFileSync as readFileSync18 } from "fs";
+import { join as join15 } from "path";
 function loadLens(cwd) {
-  const path = join11(cwd, "lens.md");
-  if (!existsSync12(path)) return null;
+  const path = join15(cwd, "lens.md");
+  if (!existsSync15(path)) return null;
   try {
-    const content = readFileSync16(path, "utf-8");
-    if (content.length > MAX_LENS_BYTES) {
-      return content.slice(0, MAX_LENS_BYTES) + "\n\n[truncated: lens.md exceeds 64KB cap]";
+    const content = readFileSync18(path, "utf-8");
+    const maxBytes = loadConfig().tuning.lens_max_bytes;
+    if (content.length > maxBytes) {
+      return content.slice(0, maxBytes) + `
+
+[truncated: lens.md exceeds ${maxBytes} bytes]`;
     }
     return content.trim() || null;
   } catch {
@@ -5527,7 +7251,7 @@ function loadLens(cwd) {
 
 // src/cli.ts
 function shortenPath2(cwd) {
-  const home = homedir11();
+  const home = homedir13();
   let path = cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
   if (path.length > 50) {
     const parts = path.split("/").filter(Boolean);
@@ -5582,6 +7306,10 @@ async function main() {
     process.exit(0);
   }
   initConfig();
+  const migrated = migrateConfig();
+  if (migrated.length > 0) {
+    console.log(`\x1B[2mconfig migrated: added [${migrated.join("], [")}] to ${getConfigPath()}\x1B[0m`);
+  }
   const config = loadConfig();
   const KNOWN_FLAGS = /* @__PURE__ */ new Set([...allFlagTokens(), "--completion", "--complete", "--install-completion"]);
   if (args.includes("--help") || args.includes("-h")) {
@@ -5600,6 +7328,11 @@ async function main() {
   -c, --continue        resume last session in this directory
   -r, --resume <n|id>   resume the nth recent session, or by full id (see --sessions)
   --max-tokens <n>      max output tokens per response (default: 10000)
+  --max-files <n>       repo-map walk cap (override [tuning].repomap_max_files)
+  --max-lines <n>       repo-map render cap (override [tuning].repomap_max_lines)
+  --no-repomap          skip the repo-map retrieval pass entirely
+  --no-scan             skip the live project scan
+  --no-memory           skip lens.md + persistent memo
   --config              show config file path
   --sessions            list recent sessions
   -h, --help            show this help`);
@@ -5620,6 +7353,24 @@ async function main() {
     }
     maxTokens = parsed;
   }
+  const parseFlagNumber = (flag, label) => {
+    const idx = args.indexOf(flag);
+    if (idx === -1) return void 0;
+    const raw = args[idx + 1];
+    if (!raw || raw.startsWith("-")) {
+      console.error(`\x1B[31m${flag} requires a number (e.g. ${flag} ${label})\x1B[0m`);
+      process.exit(1);
+    }
+    const parsed = parseInt(raw, 10);
+    if (isNaN(parsed) || parsed <= 0) {
+      console.error(`\x1B[31m${flag} must be a positive number, got: ${raw}\x1B[0m`);
+      process.exit(1);
+    }
+    return parsed;
+  };
+  const maxFiles = parseFlagNumber("--max-files", "500");
+  const maxLines = parseFlagNumber("--max-lines", "200");
+  const skipRepoMap = args.includes("--no-repomap");
   const valueFlags = valueTakingFlagTokens();
   const isFlagValue = (i) => i > 0 && valueFlags.has(args[i - 1] || "");
   const unknownFlags = args.filter((a, i) => a.startsWith("-") && !KNOWN_FLAGS.has(a) && !isFlagValue(i));
@@ -5737,7 +7488,7 @@ async function main() {
     session = createSession(model, provider.name, cwd);
   }
   const capabilities = provider.getCapabilities();
-  const tools = [BashTool, ReadTool, EditTool, WriteTool, GlobTool, GrepTool, WebFetchTool, WebSearchTool];
+  const tools = [BashTool, ReadTool, EditTool, WriteTool, GlobTool, GrepTool, WebFetchTool, WebSearchTool, VerifyTool];
   const skipScan = args.includes("--no-scan");
   const skipMemory = args.includes("--no-memory");
   let projectContext;
@@ -5769,6 +7520,21 @@ async function main() {
   if (autoInstall) {
     console.log(`\x1B[2mshell completion installed to ${autoInstall.rcPath}. restart your shell or run \`exec ${autoInstall.shell}\` to enable tab completion.\x1B[0m`);
   }
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[>1u");
+    const popKeyboardMode = () => {
+      if (process.stdout.isTTY) process.stdout.write("\x1B[<u");
+    };
+    process.on("exit", popKeyboardMode);
+    process.on("SIGINT", () => {
+      popKeyboardMode();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      popKeyboardMode();
+      process.exit(143);
+    });
+  }
   const { waitUntilExit } = render(
     React4.createElement(App, {
       provider,
@@ -5778,7 +7544,8 @@ async function main() {
       session,
       initialMessages,
       projectContext,
-      memory
+      memory,
+      repoMapOverride: { maxFiles, maxLines, skip: skipRepoMap }
     })
   );
   await waitUntilExit();