tensor-cli 0.1.3-beta-lite → 0.1.4-beta-lite

package/dist/index.js

@@ -69212,7 +69212,7 @@ var textareaInputRef = {
 // src/tools/harness-orchestrator.ts
 import { existsSync } from "fs";
 import { mkdir } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 
 // src/constants/google-models-context-window.ts
 var DEFAULT_GOOGLE_CONTEXT_WINDOW = 32760;
@@ -329958,6 +329958,510 @@ var askJev = async (body) => {
 };
 var askJev_default = askJev;
 
+// src/tools/harness-core.ts
+import { dirname } from "path";
+
+// src/tools/harness-processes.ts
+import { spawn } from "child_process";
+import { EventEmitter as EventEmitter2 } from "events";
+var BG_TOOLS = new Set([
+  "bg_start",
+  "bg_list",
+  "bg_logs",
+  "bg_kill"
+]);
+var BG_READ_ONLY_TOOLS = new Set(["bg_list", "bg_logs"]);
+var isBgTool = (t2) => typeof t2 === "string" && BG_TOOLS.has(t2);
+var str = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
+function parseBgDecision(p) {
+  if (!isBgTool(p.tool))
+    return null;
+  const tool = p.tool;
+  const cmd = tool === "bg_start" ? str(p.cmd) ?? str(p.command) ?? str(p.content) : null;
+  const named = str(p.target) ?? str(p.name) ?? str(p.label) ?? str(p.id) ?? (typeof p.id === "number" ? String(p.id) : null);
+  const target = tool === "bg_start" ? named : named ?? str(p.targetFile) ?? str(p.content);
+  return {
+    tool,
+    cmd,
+    target,
+    reasoning: (str(p.reasoning) ?? "").slice(0, 1000),
+    needMoreSteps: Boolean(p.need_more_steps || p.needs_more_steps)
+  };
+}
+var LONG_RUNNING_SHELL_RE = new RegExp([
+  String.raw`\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|watch|preview)\b`,
+  String.raw`\bbun\s+(?:--hot|--watch)\b`,
+  String.raw`\bnext\s+(?:dev|start)\b`,
+  String.raw`\bvite(?:\s+(?:dev|preview|serve))?\s*(?:--\S+\s*)*$`,
+  String.raw`\bnodemon\b`,
+  String.raw`\bhttp\.server\b`,
+  String.raw`\brunserver\b`,
+  String.raw`\buvicorn\b`,
+  String.raw`\bflask\s+run\b`,
+  String.raw`\bnpx\s+serve\b`,
+  String.raw`(?:^|&&|;)\s*anvil\b`,
+  String.raw`\bhardhat\s+node\b`,
+  String.raw`\bsolana-test-validator\b`,
+  String.raw`\bngrok\b`,
+  String.raw`\bdocker(?:-|\s+)compose\s+up\b(?!.*\s-d\b)`,
+  String.raw`\btail\s+-f\b`,
+  String.raw`\s--watch\b`,
+  String.raw`(?<!&)&\s*$`
+].join("|"), "i");
+var BG_TOOL_RULES = `BACKGROUND PROCESS TOOLS \u2014 extra values for "tool", for servers, watchers and anything that doesn't exit on its own:
+- "bg_start": "cmd" = the literal command; "target" = optional short name (e.g. "web"). Returns the first few seconds of output (and any URL) so you can tell whether it came up.
+- "bg_list": no other fields.
+- "bg_logs": "target" = process id, name or port. Use it to see what a process is doing or why it died.
+- "bg_kill": "target" = process id, name or port, or "all".
+Rules:
+- NEVER run a server/watcher through "shell" (it blocks until it times out). Use "bg_start".
+- "start/run/launch the server" -> bg_start. If the user gave no command, "read" package.json (or pyproject.toml, manage.py, foundry.toml, Cargo.toml ...) to find the dev/start script, then bg_start it.
+- "stop/kill/shut down/turn off the server" -> bg_kill on the matching tracked process. This always means the tracked process, never the machine, and never "shell". "stop everything" -> target "all".
+- "restart X" -> bg_kill X, then bg_start with the same cmd (it is listed under BACKGROUND PROCESSES).
+- "what's running / is X up / what's X doing / why did X die" -> answer from BACKGROUND PROCESSES, or bg_list / bg_logs for real output. Never guess.
+- If the thing to stop is not tracked (started outside this session), say so; if the user gave a port, "shell" with lsof -ti :PORT can find the owner.
+- Never start a duplicate of a running process. After bg_start, if it crashed, bg_logs it, fix the cause, retry.
+- For bg_* tools leave "targetFile", "content", "target"/"cmd" not mentioned above as null.`;
+var GAP = String.raw`[^.!?\n]{0,40}?`;
+var LEAD = String.raw`(?<!\w)`;
+var TRAIL = String.raw`(?!\w)`;
+var NEG_RE = /\b(?:don'?t|do\s+not|never|no\s+need\s+to|without|instead\s+of|rather\s+than)\b[^.!?\n]{0,25}?\b(?:start|run|launch|stop|kill|shut|restart|spin|boot)/i;
+var STOP_V = String.raw`(?:stop|kill|terminate|shut\s*(?:it\s*|them\s*)?(?:down|off)|take\s+(?:it\s+|them\s+)?down|bring\s+(?:it\s+|them\s+)?down|turn\s+(?:it\s+|them\s+)?off|halt)`;
+var PROC_N = String.raw`(?:servers?|processes|process|watchers?|daemons?|services?|dev|backend|frontend|api|app|everything|all|bg|background|p\d+|ports?\s*\d+|:\d{2,5}|localhost|anvil|vite|django|flask|uvicorn)`;
+var STOP_RE = new RegExp(String.raw`\b${STOP_V}\b${GAP}${LEAD}${PROC_N}${TRAIL}`, "i");
+var STOP_PRONOUN_RE = /\b(?:stop|kill|terminate|shut\s*(?:it\s*|them\s*)?down|turn\s+(?:it|them)\s+off)\s+(?:it|that|this|them|those)\b/i;
+var STOP_BARE_RE = /^\s*(?:please\s+)?(?:shut\s*down|stop|kill|terminate)(?:\s+(?:now|please))?\s*[.!]*\s*$/i;
+var STOP_EXCLUDE_RE = /\bfrom\s+\w+ing\b|\busing\b|\bbeing\b/i;
+var START_V = String.raw`(?:start|run|launch|spin\s*up|boot(?:\s+up)?|fire\s*up|bring\s*up|kick\s*off|serve)`;
+var START_N = String.raw`(?:servers?|dev|watcher|backend|frontend|api|app|site|website|anvil|localhost|daemon|in\s+(?:the\s+)?(?:background|bg)|background|bg)`;
+var START_RE = new RegExp(String.raw`\b${START_V}\b${GAP}${LEAD}${START_N}${TRAIL}`, "i");
+var START_EXCLUDE_RE = /\b(?:tests?|specs?|lint|typecheck|build|compile|migrat\w*|install|seed|script|format|generate|check|review|read|look(?:ing)?|by\s+\w+ing)\b/i;
+var BACKGROUND_RE = /\bbackground\b|\bbg\b/i;
+var RESTART_RE = new RegExp(String.raw`\b(?:restart|reboot|relaunch|bounce|cycle)\b${GAP}${LEAD}(?:servers?|dev|watcher|process(?:es)?|backend|frontend|api|app|it|them|everything|p\d+)${TRAIL}`, "i");
+var RESTART_BARE_RE = /^\s*(?:please\s+)?(?:restart|reboot|relaunch)(?:\s+it)?\s*[.!]*\s*$/i;
+var LOGS_A_RE = new RegExp(String.raw`\b(?:logs?|output|stdout|stderr|tail|what'?s\s+(?:it\s+)?(?:doing|going\s+on|happening)|how(?:'s|\s+is))\b${GAP}${LEAD}(?:server|process|dev|backend|frontend|p\d+|it|anvil|watcher|bg|background)${TRAIL}`, "i");
+var LOGS_B_RE = /\b(?:is\s+(?:it|the\s+[\w-]+)\s+(?:up|running|working|alive|crashed|dead)|did\s+(?:it|the\s+[\w-]+)\s+(?:crash|start|fail|die|work))\b/i;
+var LIST_RE = new RegExp(String.raw`\b(?:what(?:'s|\s+is|\s+are)?|which|show|list|any|are\s+there|see)\b${GAP}${LEAD}(?:running|processes|servers|background|bg)${TRAIL}`, "i");
+var HEAD = "USER INTENT (detected from their message; it is a hint, use your judgment if it is wrong):";
+var STOP_NOTE = `${HEAD} the user wants to STOP background process(es). Call "bg_kill" now. "target" = the id from BACKGROUND PROCESSES that matches what they named (name, id or port), or "all" if they said everything/all/shut down. If they named nothing and exactly one is running, that one. This means the tracked process, never the machine, and never "shell". If they also asked for something else, do it after.`;
+var START_NOTE = `${HEAD} the user wants to START a server / long-running process. Call "bg_start" (never "shell"). If they gave a command, use it verbatim. Otherwise "read" package.json (or the project's equivalent) first, pick the dev/start script, then bg_start with the full runner command (e.g. "bun run dev"). Don't start a duplicate of something already running.`;
+var RESTART_NOTE = `${HEAD} the user wants to RESTART a background process. Call "bg_kill" on it first (its cmd is listed under BACKGROUND PROCESSES), then "bg_start" with the same cmd.`;
+var LOGS_NOTE = `${HEAD} the user is asking how a background process is doing. Call "bg_logs" for the real output and base your answer on it.`;
+var LIST_NOTE = `${HEAD} the user is asking what is running. Answer from BACKGROUND PROCESSES (or "bg_list").`;
+var NOTHING_RUNNING_NOTE = `${HEAD} the user wants to stop something, but no background process is running. Say so plainly. If they named a port, a process started outside this session can be found with "shell" lsof -ti :PORT.`;
+var NONE_TRACKED_NOTE = `${HEAD} no background processes are tracked in this session. If the user is asking about running servers, say none were started here.`;
+function detectBgIntent(task, running, known) {
+  const t2 = task.slice(0, 4000);
+  if (!t2.trim() || NEG_RE.test(t2))
+    return null;
+  const needs = [];
+  const notes = [];
+  if (RESTART_RE.test(t2) || RESTART_BARE_RE.test(t2)) {
+    if (running > 0)
+      needs.push("bg_kill");
+    needs.push("bg_start");
+    notes.push(RESTART_NOTE);
+  } else {
+    const stopM = STOP_RE.exec(t2);
+    const stopHit = stopM !== null && !STOP_EXCLUDE_RE.test(stopM[0]) || STOP_PRONOUN_RE.test(t2) || STOP_BARE_RE.test(t2);
+    if (stopHit) {
+      if (running > 0) {
+        needs.push("bg_kill");
+        notes.push(STOP_NOTE);
+      } else {
+        notes.push(NOTHING_RUNNING_NOTE);
+      }
+    }
+    const startM = START_RE.exec(t2);
+    if (startM && (!START_EXCLUDE_RE.test(startM[0]) || BACKGROUND_RE.test(startM[0]))) {
+      needs.push("bg_start");
+      notes.push(START_NOTE);
+    }
+  }
+  const strong = needs.includes("bg_start") || needs.includes("bg_kill");
+  if (!strong && notes.length === 0) {
+    const asksLogs = LOGS_A_RE.test(t2) || LOGS_B_RE.test(t2);
+    if (known > 0) {
+      if (asksLogs) {
+        needs.push("bg_logs");
+        notes.push(LOGS_NOTE);
+      } else if (LIST_RE.test(t2)) {
+        notes.push(LIST_NOTE);
+      }
+    } else if (asksLogs || LIST_RE.test(t2)) {
+      notes.push(NONE_TRACKED_NOTE);
+    }
+  }
+  if (notes.length === 0)
+    return null;
+  return { needs, strong, note: notes.join(`
+`) };
+}
+var LOG_CAP = 64000;
+var TAIL_CHAR_CAP = 6000;
+var MAX_RUNNING = 8;
+var MAX_FINISHED_KEPT = 10;
+var STARTUP_GRACE_MS = 4000;
+var KILL_GRACE_MS = 3000;
+var EXIT_DRAIN_MS = 120;
+var ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07]*\x07/g;
+var READY_RE = /\b(?:ready|listening|compiled|started|local:|on port)\b/i;
+var URL_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\]):\d+[^\s'")]*/gi;
+var PORT_RE = /\bport\s*:?\s*(\d{2,5})\b/gi;
+var ALL_RE = /^(?:all|everything|\*|all\s+(?:the\s+)?(?:servers|processes|background(?:\s+processes)?))$/;
+var GENERIC_RE = /^(?:the\s+|that\s+|this\s+|my\s+)?(?:dev\s+|web\s+|local\s+|background\s+)?(?:server|process|watcher|app|service|it)$/;
+var clip = (s2, n3) => s2.length > n3 ? `${s2.slice(0, n3 - 1)}\u2026` : s2;
+function fmtDur(ms) {
+  const s2 = Math.max(0, Math.floor(ms / 1000));
+  if (s2 < 60)
+    return `${s2}s`;
+  const m = Math.floor(s2 / 60);
+  if (m < 60)
+    return `${m}m${s2 % 60}s`;
+  return `${Math.floor(m / 60)}h${m % 60}m`;
+}
+function deriveLabel(cmd) {
+  const words = cmd.split(/\s+/).filter((w) => w && !/^\w+=/.test(w));
+  return clip(words.slice(0, 3).join(" "), 24);
+}
+var urlSuffix = (m) => m.urls.size ? ` \xB7 ${[...m.urls].join(", ")}` : "";
+
+class ProcessManager {
+  procs = new Map;
+  seq = 0;
+  constructor() {
+    process.once("exit", () => this.killAllSync());
+  }
+  count() {
+    return this.procs.size;
+  }
+  runningCount() {
+    let n3 = 0;
+    for (const p of this.procs.values())
+      if (p.status === "running")
+        n3++;
+    return n3;
+  }
+  async start(opts) {
+    const cmd = opts.cmd.trim().replace(/(?<!&)&\s*$/, "").trim();
+    if (!cmd)
+      throw new Error("empty command");
+    const dup = [...this.procs.values()].find((p) => p.status === "running" && p.cmd === cmd && p.cwd === opts.cwd);
+    if (dup) {
+      return {
+        kind: "duplicate",
+        id: dup.id,
+        report: `Already running as ${dup.id} "${dup.label}" (pid ${dup.pid}, up ${fmtDur(Date.now() - dup.startedAt)})` + `${urlSuffix(dup)}. Not starting a second copy; use bg_logs to inspect it or bg_kill to restart it.`
+      };
+    }
+    if (this.runningCount() >= MAX_RUNNING) {
+      throw new Error(`${MAX_RUNNING} background processes already running; kill one first`);
+    }
+    const id = `p${++this.seq}`;
+    const label = (opts.label ?? "").trim().slice(0, 24) || deriveLabel(cmd);
+    const child = spawn("bash", ["-lc", cmd], {
+      cwd: opts.cwd,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", BROWSER: "none" }
+    });
+    const m = {
+      id,
+      label,
+      cmd,
+      cwd: opts.cwd,
+      child,
+      pid: child.pid,
+      status: "running",
+      startedAt: Date.now(),
+      endedAt: null,
+      exitCode: null,
+      signal: null,
+      killRequested: false,
+      noticed: false,
+      buf: "",
+      totalChars: 0,
+      urls: new Set,
+      events: new EventEmitter2
+    };
+    this.procs.set(id, m);
+    const onData = (d2) => this.append(m, d2.toString("utf8"));
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => {
+      this.append(m, `[spawn error] ${err.message}
+`);
+      this.finish(m, null, null);
+    });
+    let drain;
+    child.on("exit", (code, signal) => {
+      drain = setTimeout(() => this.finish(m, code, signal), EXIT_DRAIN_MS);
+    });
+    child.on("close", (code, signal) => {
+      if (drain)
+        clearTimeout(drain);
+      this.finish(m, code, signal);
+    });
+    try {
+      child.unref();
+      for (const s2 of [child.stdout, child.stderr]) {
+        s2?.unref?.();
+      }
+    } catch {}
+    await this.waitForStartup(m, opts.graceMs ?? STARTUP_GRACE_MS);
+    if (m.status !== "running") {
+      return {
+        kind: "crashed",
+        id,
+        report: `${id} "${label}" exited ${m.exitCode !== null ? `with code ${m.exitCode}` : `(${m.signal ?? "unknown"})`} ` + `${fmtDur((m.endedAt ?? Date.now()) - m.startedAt)} after starting.
+Output:
+${this.tail(m, 30)}`
+      };
+    }
+    return {
+      kind: "started",
+      id,
+      report: `Started ${id} "${label}" (pid ${m.pid}) in the background: ${cmd}
+` + `Status: running${urlSuffix(m)}
+Initial output:
+${this.tail(m, 25)}
+` + `It keeps running after this turn. Refer to it as "${id}" with bg_logs / bg_kill.`
+    };
+  }
+  formatList() {
+    if (this.procs.size === 0)
+      return "No background processes.";
+    return [...this.procs.values()].map((m) => this.line(m)).join(`
+`);
+  }
+  logs(ref, lines = 60) {
+    const f2 = this.find(ref);
+    if ("error" in f2)
+      return f2.error;
+    const m = f2.m;
+    return `${m.id} "${m.label}" [${m.status}] \u2014 last ${lines} lines (${m.totalChars} chars emitted in total):
+${this.tail(m, lines)}`;
+  }
+  promptBlock() {
+    if (this.procs.size === 0)
+      return "";
+    const all3 = [...this.procs.values()];
+    const shown = [
+      ...all3.filter((p) => p.status === "running"),
+      ...all3.filter((p) => p.status !== "running").slice(-3)
+    ];
+    return `BACKGROUND PROCESSES (tracked by the harness; they keep running between turns):
+` + shown.map((m) => this.line(m)).join(`
+`) + `
+Use bg_logs with the id to see output, bg_kill to stop one. Never start a duplicate of a running process.`;
+  }
+  consumeExitNotices() {
+    const out = [];
+    for (const m of this.procs.values()) {
+      if (m.status === "running" || m.noticed)
+        continue;
+      m.noticed = true;
+      let s2 = `Background ${m.id} "${m.label}" ${m.status === "failed" ? `crashed (exit ${m.exitCode ?? m.signal})` : `exited (code ${m.exitCode ?? m.signal})`}`;
+      if (m.status === "failed") {
+        const last = m.buf.split(`
+`).map((l) => l.trim()).filter(Boolean).slice(-2).map((l) => clip(l, 160));
+        if (last.length)
+          s2 += `
+    ${last.join(`
+    `)}`;
+      }
+      out.push(s2);
+    }
+    return out;
+  }
+  async kill(ref) {
+    if (ALL_RE.test((ref ?? "").trim().toLowerCase()))
+      return this.killAll();
+    const f2 = this.find(ref);
+    if ("error" in f2)
+      return f2.error;
+    const m = f2.m;
+    if (m.status !== "running") {
+      return `${m.id} "${m.label}" is not running (${m.status}, exit ${m.exitCode ?? m.signal}).`;
+    }
+    const up = fmtDur(Date.now() - m.startedAt);
+    await this.terminate(m);
+    return `Killed ${m.id} "${m.label}" (pid ${m.pid}, was up ${up}).`;
+  }
+  async killAll() {
+    const running = [...this.procs.values()].filter((p) => p.status === "running");
+    if (running.length === 0)
+      return "No running background processes.";
+    await Promise.all(running.map((m) => this.terminate(m)));
+    return `Killed ${running.length} background process${running.length > 1 ? "es" : ""}: ${running.map((m) => m.id).join(", ")}.`;
+  }
+  line(m) {
+    const when = m.status === "running" ? `up ${fmtDur(Date.now() - m.startedAt)}` : `exit ${m.exitCode ?? m.signal}, ${fmtDur(Date.now() - (m.endedAt ?? Date.now()))} ago`;
+    return `${m.id} "${m.label}" [${m.status}] pid ${m.pid ?? "?"} \xB7 ${when}${urlSuffix(m)}
+    $ ${clip(m.cmd, 120)}`;
+  }
+  find(ref) {
+    const all3 = [...this.procs.values()];
+    if (all3.length === 0)
+      return { error: "Failed: no background processes exist." };
+    const known = all3.map((p) => `${p.id} "${p.label}" [${p.status}]`).join(", ");
+    const running = all3.filter((p) => p.status === "running");
+    const key = (ref ?? "").trim().replace(/^["']|["']$/g, "").toLowerCase();
+    if (!key) {
+      const only = running.length === 1 ? running[0] : all3.length === 1 ? all3[0] : undefined;
+      return only ? { m: only } : { error: `Failed: specify a process id. Known: ${known}` };
+    }
+    const byId = all3.find((p) => p.id === key);
+    if (byId)
+      return { m: byId };
+    const exact = [...all3].reverse().find((p) => p.label.toLowerCase() === key);
+    if (exact)
+      return { m: exact };
+    const pick2 = (cands) => {
+      if (cands.length === 0)
+        return null;
+      const live = cands.filter((p) => p.status === "running");
+      const pool = live.length > 0 ? live : cands;
+      if (pool.length === 1)
+        return { m: pool[0] };
+      return {
+        error: `Failed: "${ref}" is ambiguous. Candidates: ${pool.map((p) => `${p.id} "${p.label}" [${p.status}]`).join(", ")}`
+      };
+    };
+    const port = /^(?:.*?[:\s])?(\d{2,5})$/.exec(key)?.[1];
+    if (port) {
+      const portRe = new RegExp(`\\b${port}\\b`);
+      const hit = pick2(all3.filter((p) => [...p.urls].some((u) => u.includes(`:${port}`)) || portRe.test(p.cmd)));
+      if (hit)
+        return hit;
+    }
+    const partial2 = pick2(all3.filter((p) => {
+      const label = p.label.toLowerCase();
+      return label.length >= 3 && (label.includes(key) || key.includes(label)) || p.cmd.toLowerCase().includes(key);
+    }));
+    if (partial2)
+      return partial2;
+    if (GENERIC_RE.test(key) && running.length === 1)
+      return { m: running[0] };
+    return { error: `Failed: no process "${ref}". Known: ${known}` };
+  }
+  append(m, raw) {
+    const text = raw.replace(ANSI_RE, "").replace(/\r\n/g, `
+`).replace(/[^\n]*\r/g, "");
+    if (!text)
+      return;
+    m.totalChars += text.length;
+    m.buf += text;
+    if (m.buf.length > LOG_CAP) {
+      m.buf = m.buf.slice(-LOG_CAP);
+      m.buf = m.buf.slice(m.buf.indexOf(`
+`) + 1);
+    }
+    for (const u of text.match(URL_RE) ?? []) {
+      if (m.urls.size < 5)
+        m.urls.add(u.replace(/[.,;/]+$/, ""));
+    }
+    for (const pm of text.matchAll(PORT_RE)) {
+      const p = pm[1];
+      if (p && m.urls.size < 5 && ![...m.urls].some((u) => u.includes(`:${p}`))) {
+        m.urls.add(`http://localhost:${p}`);
+      }
+    }
+    if (m.urls.size > 0 || READY_RE.test(text))
+      m.events.emit("ready");
+  }
+  tail(m, lines) {
+    const out = m.buf.split(`
+`).slice(-lines).join(`
+`).trim();
+    if (!out)
+      return "(no output yet)";
+    return out.length > TAIL_CHAR_CAP ? `\u2026${out.slice(-TAIL_CHAR_CAP)}` : out;
+  }
+  finish(m, code, signal) {
+    if (m.status !== "running")
+      return;
+    m.endedAt = Date.now();
+    m.exitCode = code;
+    m.signal = signal;
+    m.status = m.killRequested ? "killed" : code === 0 ? "exited" : "failed";
+    m.noticed = m.killRequested;
+    m.events.emit("exit");
+    this.prune();
+  }
+  prune() {
+    const finished2 = [...this.procs.values()].filter((p) => p.status !== "running");
+    for (const p of finished2.slice(0, Math.max(0, finished2.length - MAX_FINISHED_KEPT))) {
+      this.procs.delete(p.id);
+    }
+  }
+  waitForStartup(m, ms) {
+    return new Promise((resolve) => {
+      if (m.status !== "running")
+        return resolve();
+      let settle3;
+      const done = () => {
+        clearTimeout(timer);
+        if (settle3)
+          clearTimeout(settle3);
+        m.events.off("ready", onReady);
+        m.events.off("exit", done);
+        resolve();
+      };
+      const onReady = () => {
+        if (!settle3)
+          settle3 = setTimeout(done, 300);
+      };
+      const timer = setTimeout(done, ms);
+      m.events.on("ready", onReady);
+      m.events.once("exit", done);
+    });
+  }
+  waitForExit(m, ms) {
+    return new Promise((resolve) => {
+      if (m.status !== "running")
+        return resolve(true);
+      const onExit = () => {
+        clearTimeout(timer);
+        resolve(true);
+      };
+      const timer = setTimeout(() => {
+        m.events.off("exit", onExit);
+        resolve(false);
+      }, ms);
+      m.events.once("exit", onExit);
+    });
+  }
+  signalGroup(m, sig) {
+    try {
+      if (process.platform !== "win32" && m.pid)
+        process.kill(-m.pid, sig);
+      else
+        m.child.kill(sig);
+    } catch {
+      try {
+        m.child.kill(sig);
+      } catch {}
+    }
+  }
+  async terminate(m) {
+    m.killRequested = true;
+    this.signalGroup(m, "SIGTERM");
+    if (await this.waitForExit(m, KILL_GRACE_MS + EXIT_DRAIN_MS))
+      return;
+    this.signalGroup(m, "SIGKILL");
+    await this.waitForExit(m, 1000 + EXIT_DRAIN_MS);
+  }
+  killAllSync() {
+    for (const m of this.procs.values()) {
+      if (m.status === "running") {
+        m.killRequested = true;
+        this.signalGroup(m, "SIGTERM");
+      }
+    }
+  }
+}
+
 // src/tools/harness-core.ts
 var MAX_JSON_RETRIES = 3;
 var MAX_WRITES_PER_FILE = 10;
@@ -330146,6 +330650,408 @@ async function isConversational(message) {
     return false;
   }
 }
+var DEBUG_TRACE = Boolean(process.env.BASECODE_DEBUG);
+var CLEAR_LINE = "\r\x1B[2K";
+var WEB_SEARCH_FAILED_RE = /^\[Web search results[^\n]*\n(?:REJECTED|SEARCH FAILED):/;
+var TOOL_OUTPUT_CHAR_CAP = 16000;
+var SHELL_OUTPUT_BYTE_CAP = 256000;
+var RESULT_TAIL_CHARS = 8000;
+var INIT_PER_FILE_CHAR_CAP = 8000;
+var INIT_TOTAL_DUMP_CHAR_CAP = 200000;
+var HEAVY_KEEP_CHARS = 40000;
+var REPO_MAP_CHAR_CAP = 12000;
+var JEV_REPO_MAP_CHAR_CAP = 4000;
+var JEV_TASK_CHAR_CAP = 3000;
+var JEV_TAIL_MSGS = 3;
+var JEV_TAIL_CHARS = 1500;
+var PRIOR_MSG_CHAR_CAP = 2500;
+var SYNTHESIS_OVERVIEW_CHARS = 6000;
+var NOTICE_POLL_MS = 250;
+var VISION_MODEL_ID = "gemini-2.5-flash";
+var VISION_MAX_TOKENS = 1200;
+var VISION_TIMEOUT_MS = 60000;
+var VISION_MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+var VISION_CONCURRENCY = 3;
+var VISION_SYSTEM_PROMPT = "You describe images for a coding agent that cannot see them. " + "Transcribe all visible text, code, error messages and numbers verbatim. " + "Then describe layout, UI elements, colours, diagrams and anything relevant to a software task. " + "Be factual and compact (under 400 words) and do not speculate about intent. " + "Reply with the description only.";
+var DECISION_JSON_START_RE = /\{\s*"(?:tool|reasoning|need_more_steps|requires_confirmation)"\s*:/;
+var DECISION_JSON_PREFIX_RE = /^\{\s*(?:"[a-z_]{0,24}"?\s*:?)?$/;
+var DECISION_JSON_FENCE_TAIL_RE = /```(?:json)?\s*$/i;
+var DECISION_JSON_PARTIAL_FENCE_RE = /(?:`{1,2}|```(?:j(?:s(?:o(?:n)?)?)?)?\s*)$/i;
+var DECISION_JSON_HOLD_CHARS = 40;
+var isDecisionShaped = (v) => isRecord2(v) && (("tool" in v) && (v.tool === null || typeof v.tool === "string") || ("reasoning" in v) && (("need_more_steps" in v) || ("needs_more_steps" in v) || ("requires_confirmation" in v)));
+function jsonObjectEnd(s2, start) {
+  let depth = 0;
+  let inStr = false;
+  let esc2 = false;
+  for (let i2 = start;i2 < s2.length; i2++) {
+    const c2 = s2[i2];
+    if (inStr) {
+      if (esc2)
+        esc2 = false;
+      else if (c2 === "\\")
+        esc2 = true;
+      else if (c2 === '"')
+        inStr = false;
+      continue;
+    }
+    if (c2 === '"')
+      inStr = true;
+    else if (c2 === "{")
+      depth++;
+    else if (c2 === "}") {
+      depth--;
+      if (depth === 0)
+        return i2 + 1;
+    }
+  }
+  return -1;
+}
+function salvageReasoning(partial2) {
+  const raw = /"reasoning"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(partial2)?.[1];
+  if (raw === undefined)
+    return "";
+  try {
+    return String(JSON.parse(`"${raw}"`)).trim();
+  } catch {
+    return raw.trim();
+  }
+}
+function decisionPackageText(json3) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json3);
+  } catch {
+    return salvageReasoning(json3);
+  }
+  if (!isDecisionShaped(parsed))
+    return json3;
+  return typeof parsed.reasoning === "string" ? parsed.reasoning.trim() : "";
+}
+function decisionJsonHoldFrom(s2) {
+  let hold = s2.length;
+  const open3 = s2.lastIndexOf("{");
+  if (open3 >= 0 && s2.length - open3 <= DECISION_JSON_HOLD_CHARS && DECISION_JSON_PREFIX_RE.test(s2.slice(open3))) {
+    hold = open3;
+  }
+  const fence = DECISION_JSON_PARTIAL_FENCE_RE.exec(s2.slice(0, hold));
+  if (fence && fence.index >= hold - DECISION_JSON_HOLD_CHARS)
+    hold = fence.index;
+  return hold;
+}
+async function* guardDecisionJson(source) {
+  let pending = "";
+  let inPackage = false;
+  let dropCloseFence = false;
+  for await (const chunk of source) {
+    const d2 = chunk.delta;
+    if (!d2)
+      continue;
+    pending += d2;
+    for (;; ) {
+      if (inPackage) {
+        const end = jsonObjectEnd(pending, 0);
+        if (end < 0)
+          break;
+        const text = decisionPackageText(pending.slice(0, end));
+        pending = pending.slice(end);
+        inPackage = false;
+        if (text)
+          yield { delta: text };
+        continue;
+      }
+      if (dropCloseFence) {
+        const t2 = pending.trimStart();
+        if (t2 === "" || /^`{1,2}$/.test(t2))
+          break;
+        dropCloseFence = false;
+        if (t2.startsWith("```"))
+          pending = t2.slice(3);
+      }
+      const hit = DECISION_JSON_START_RE.exec(pending);
+      if (hit) {
+        const head = pending.slice(0, hit.index);
+        const fenced = DECISION_JSON_FENCE_TAIL_RE.test(head);
+        pending = pending.slice(hit.index);
+        inPackage = true;
+        dropCloseFence = fenced;
+        const keep = fenced ? head.replace(DECISION_JSON_FENCE_TAIL_RE, "") : head;
+        if (keep)
+          yield { delta: keep };
+        continue;
+      }
+      const hold = decisionJsonHoldFrom(pending);
+      const out = pending.slice(0, hold);
+      pending = pending.slice(hold);
+      if (out)
+        yield { delta: out };
+      break;
+    }
+  }
+  if (inPackage) {
+    const text = salvageReasoning(pending);
+    if (text)
+      yield { delta: text };
+  } else if (dropCloseFence && /^[\s`]*$/.test(pending)) {} else if (pending) {
+    yield { delta: pending };
+  }
+}
+var BASECODE_POINTER = "BASECODE.md exists at the repo root (architecture, conventions, commands) but is NOT inlined, to save tokens. " + 'Read it once with the "read" tool if the task needs project background; skip it for self-contained tasks.';
+var NO_BASECODE_NOTE = "No BASECODE.md yet (the user can run /init to generate one).";
+var GIT_INTENT = /\b(git|commit|committed|merge|push|pull|rebase|branch|branches|checkout|stash|tag|cherry-?pick|reset|revert|amend)\b/i;
+var NO_INLINE_CONTENT_RULE = {
+  role: "system",
+  content: `OUTPUT REMINDER: "write"/"append": set "content" to "" (the file is generated in a separate step; never inline source). ` + `"edit": "target" and "replacement" are REQUIRED, copied verbatim from file contents shown in context, kept small. ` + `"shell": "cmd" is REQUIRED (the literal command). "web_search": "content" is REQUIRED \u2014 a short, specific query ` + `(3-10 words) with no secrets, local paths or code; other fields null. "reasoning": ONE short sentence. ` + `"bg_start": "cmd" REQUIRED (the literal command), "target" = optional short name; "bg_logs"/"bg_kill": "target" = ` + `process id, name or port ("bg_kill" accepts "all"); "bg_list": nothing else. Never run servers/watchers via "shell". ` + `Your whole JSON must fit in ${DECISION_MAX_TOKENS} tokens or the step is wasted. ` + `For project background read BASECODE.md (not inlined); if none exists, tell the user to run /init.`
+};
+var BG_RULES_MESSAGE = { role: "system", content: BG_TOOL_RULES };
+var MAX_ASKS_PER_TASK = 2;
+var ASK_MAX_QUESTIONS = 4;
+var ASK_MAX_OPTIONS = 4;
+var ASK_MAX_QUESTION_CHARS = 400;
+var ASK_MAX_OPTION_CHARS = 120;
+var PENDING_BLOCKED_TOOLS = new Set([
+  "write",
+  "edit",
+  "append",
+  "shell",
+  "bg_start"
+]);
+var QUESTION_CONTEXT_RE = /^\[(?:USER ANSWER\vert{}QUESTIONS ASKED)\]|^[System] QUESTIONS:/;
+var QUESTION_BLOCK_RE = /\? Questions for you \(\d+\):\n(?: {2}\d+\. .*\n)+\n?/g;
+var clipText = (s2, n3) => s2.length > n3 ? `${s2.slice(0, n3 - 1)}\u2026` : s2;
+function cleanAskOptions(v) {
+  if (!Array.isArray(v))
+    return [];
+  const seen = new Set;
+  const out = [];
+  for (const o2 of v) {
+    if (typeof o2 !== "string")
+      continue;
+    const t2 = o2.replace(/\s+/g, " ").trim().slice(0, ASK_MAX_OPTION_CHARS);
+    const key = t2.toLowerCase();
+    if (!t2 || seen.has(key))
+      continue;
+    seen.add(key);
+    out.push(t2);
+    if (out.length >= ASK_MAX_OPTIONS)
+      break;
+  }
+  return out;
+}
+function parseAskDecision(parsed) {
+  if (!isRecord2(parsed) || parsed.tool !== "ask_user_question")
+    return null;
+  const rawItems = [];
+  if (Array.isArray(parsed.questions))
+    rawItems.push(...parsed.questions);
+  else if (typeof parsed.question === "string") {
+    rawItems.push({ question: parsed.question, options: parsed.options });
+  }
+  const questions = [];
+  const seen = new Set;
+  for (const item of rawItems) {
+    let text = "";
+    let options = [];
+    if (typeof item === "string") {
+      text = item;
+    } else if (isRecord2(item) && typeof item.question === "string") {
+      text = item.question;
+      options = cleanAskOptions(item.options);
+    }
+    text = text.replace(/\s+/g, " ").trim().slice(0, ASK_MAX_QUESTION_CHARS);
+    const key = text.toLowerCase();
+    if (!text || seen.has(key))
+      continue;
+    seen.add(key);
+    questions.push({ question: text, options });
+    if (questions.length >= ASK_MAX_QUESTIONS)
+      break;
+  }
+  return {
+    questions,
+    ignore: parsed.ignore === true,
+    reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning.slice(0, 1000) : ""
+  };
+}
+var QUESTIONS_RULE = {
+  role: "system",
+  content: `ASK TOOL: to ask the user something, return {"tool":"ask_user_question","questions":[{"question":"...","options":["...","..."]}],` + `"reasoning":"...","need_more_steps":true}. 1-${ASK_MAX_QUESTIONS} questions, each self-contained, with 2-${ASK_MAX_OPTIONS} mutually ` + `exclusive options (recommended first) or an empty options array for an open question. A single {"question","options"} pair is also accepted. ` + `All other fields null. The questions are shown to the user as a questionnaire; after asking you MUST stop and wait. ` + `Never ask while questions are pending, never re-ask something already answered (the answers are listed under "USER ANSWERS" in the task), ` + `at most ${MAX_ASKS_PER_TASK} asks per task. To drop the pending questions because the user's message makes them moot, return ` + `{"tool":"ask_user_question","ignore":true,"reasoning":"..."}.`
+};
+var JEV_BYPASS = {
+  unavailable: true,
+  tool: "none",
+  needMoreSteps: false,
+  confidence: 0,
+  reasoning: ""
+};
+var MEMORY_CHAR_CAP = 6000;
+var MEMORY_MAX_NEW_ENTRIES = 3;
+var MEMORY_MAX_ENTRY_CHARS = 250;
+var MEMORY_HEADER = `# BASECODE MEMORY
+Project-specific preferences and fixes learned from past sessions. Newest last.
+`;
+var MEMORY_SIGNAL = /\b(always|never|don'?t|do not|instead|prefer|from now on|remember|actually|wrong|incorrect|not what i|should(?:n'?t)?|stop (?:using|doing)|use \S+ (?:not|instead))\b/i;
+var MEMORY_SECRET_PATTERN = /(?:sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{20,}|api[_-]?key\s*[:=]|password\s*[:=]|secret\s*[:=]|token\s*[:=]|-----BEGIN)/i;
+var MEMORY_LEARNER_PROMPT = `You maintain a small long-term memory file for a coding agent working in one project.
+From the exchange below, extract ONLY durable, reusable lessons:
+- a way the user wants things done (style, tooling, conventions, workflow), or
+- a non-obvious fix / root cause in THIS project that would save time if it came up again.
+
+Rules:
+- Each entry is ONE short imperative sentence (max 200 chars) that makes sense with no other context.
+- Do NOT record one-off task details, lists of files changed, or anything already in EXISTING MEMORY (including paraphrases).
+- Do NOT record secrets, API keys, tokens, or personal data.
+- If the user contradicts an existing entry, put the corrected entry in "add" and the old entry's exact text in "remove".
+- Most exchanges contain nothing worth saving. In that case respond with {"add":[],"remove":[]}.
+
+Respond with ONE raw JSON object and nothing else: {"add": string[], "remove": string[]} DO NOT NOTIFY THE USER WHEN YOU UPDATE THIS FILE`;
+var memNorm = (s2) => s2.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+var memEntryText = (line) => line.replace(/^-\s*(?:\[\d{4}-\d{2}-\d{2}\]\s*)?/, "").trim();
+var CHARS_PER_TOKEN = 3.5;
+var TOKENIZE_EXACT_MAX_CHARS = 1e5;
+var estimateTextTokens = (text) => {
+  if (!text)
+    return 0;
+  return text.length > TOKENIZE_EXACT_MAX_CHARS ? Math.ceil(text.length / CHARS_PER_TOKEN) : countTokens(text);
+};
+var MEDIA_PART_TOKENS = 1000;
+var MESSAGE_OVERHEAD_TOKENS = 4;
+function hasText(part) {
+  return typeof part === "object" && part !== null && typeof part.text === "string";
+}
+function countLines(text) {
+  const len = text.length;
+  if (len === 0)
+    return 0;
+  let n3 = 1;
+  for (let i2 = 0;i2 < len; i2++) {
+    if (text.charCodeAt(i2) === 10)
+      n3++;
+  }
+  if (text.charCodeAt(len - 1) === 10)
+    n3--;
+  return n3 === 0 ? 1 : n3;
+}
+function clipMiddle2(text, max) {
+  if (text.length <= max)
+    return text;
+  const head = Math.floor(max * 0.4);
+  const tail = max - head;
+  return `${text.slice(0, head)}
+\u2026[clipped ${text.length - max} chars]\u2026
+${text.slice(-tail)}`;
+}
+var repoMapMemo = new Map;
+function compactRepoMap(repoMap, cap) {
+  const hit = repoMapMemo.get(cap);
+  if (hit && hit.src === repoMap)
+    return hit.out;
+  let out;
+  try {
+    const paths = flattenRepoMap(repoMap);
+    if (paths.length === 0) {
+      out = repoMap.slice(0, cap);
+    } else {
+      const byDir = new Map;
+      for (const p of paths) {
+        const d2 = dirname(p);
+        const base = d2 === "." ? p : p.slice(d2.length + 1);
+        const list = byDir.get(d2);
+        if (list)
+          list.push(base);
+        else
+          byDir.set(d2, [base]);
+      }
+      const lines = [];
+      let total = 0;
+      let listed = 0;
+      for (const [d2, files] of [...byDir].sort(([a2], [b]) => a2 < b ? -1 : a2 > b ? 1 : 0)) {
+        const line = `${d2 === "." ? "./" : `${d2}/`} ${files.join(" ")}`;
+        if (total + line.length > cap)
+          break;
+        lines.push(line);
+        total += line.length + 1;
+        listed += files.length;
+      }
+      const omitted = paths.length - listed;
+      out = lines.join(`
+`) + (omitted > 0 ? `
+(+${omitted} more files not listed; use find/grep to explore)` : "");
+    }
+  } catch {
+    out = repoMap.slice(0, cap);
+  }
+  repoMapMemo.set(cap, { src: repoMap, out });
+  return out;
+}
+async function readCappedStream(stream4, cap = SHELL_OUTPUT_BYTE_CAP) {
+  if (!stream4)
+    return "";
+  const reader = stream4.getReader();
+  const decoder2 = new TextDecoder;
+  const parts = [];
+  let size = 0;
+  let truncated = false;
+  try {
+    while (size < cap) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!value)
+        continue;
+      size += value.byteLength;
+      parts.push(decoder2.decode(value, { stream: true }));
+    }
+    if (size >= cap)
+      truncated = true;
+  } catch {} finally {
+    try {
+      await reader.cancel();
+    } catch {}
+  }
+  let out = parts.join("");
+  parts.length = 0;
+  if (out.length > cap)
+    out = out.slice(0, cap);
+  return truncated ? `${out}
+\u2026[output truncated at ${cap} bytes]` : out;
+}
+function buildAttachmentPart(provider, mimeType, output2) {
+  const key = provider.toUpperCase();
+  const isText = mimeType.startsWith("text/");
+  if (key === "GOOGLE") {
+    return isText ? { text: output2 } : { inlineData: { mimeType, data: output2 } };
+  }
+  if (key === "ANTHROPIC") {
+    return {
+      type: mimeType.startsWith("image/") ? "image" : "document",
+      source: { type: "base64", media_type: mimeType, data: output2 }
+    };
+  }
+  if (key === "OPENAI" || key === "GROQ" || key === "VENICE") {
+    return isText ? { type: "text", text: output2 } : { type: "image_url", image_url: { url: `data:${mimeType};base64,${output2}` } };
+  }
+  return { type: "text", text: output2 };
+}
+function foldMediaParts(messages) {
+  let hasMedia = false;
+  for (const m of messages) {
+    if (m && Array.isArray(m.mediaParts) && m.mediaParts.length > 0) {
+      hasMedia = true;
+      break;
+    }
+  }
+  if (!hasMedia)
+    return messages;
+  return messages.map((m) => {
+    if (!m || !Array.isArray(m.mediaParts) || m.mediaParts.length === 0)
+      return m;
+    const { mediaParts, ...rest } = m;
+    const text = typeof rest.content === "string" ? rest.content : "";
+    const parts = [...text ? [{ type: "text", text }] : [], ...mediaParts];
+    return { ...rest, content: parts };
+  });
+}
+var TOOL_HISTORY_CAP = 20;
 
 // src/tools/harness-jev.ts
 function truncate(text, maxChars) {
@@ -330209,7 +331115,7 @@ async function classifyShellRisk(cmd) {
 
 // src/tools/harness-jev-next-step-prompt.ts
 var DEFAULT_JEV_MODEL = "jev-latest";
-function clip(s2, max) {
+function clip2(s2, max) {
   if (!s2)
     return "";
   return s2.length <= max ? s2 : `${s2.slice(0, max)}
@@ -330230,18 +331136,18 @@ async function classifyNextStep(input2) {
   } = input2;
   const state = [
     `TASK:
-${clip(taskDescription, 1200)}`,
+${clip2(taskDescription, 1200)}`,
     `STEP: ${step}/${maxSteps}`,
     `PLAN_MODE: ${isPlanMode}`,
     `ON_TASK_BRANCH: ${onTaskBranch}`,
     `PROGRESS:
-${clip(progressSummary, 800) || "(none)"}`,
+${clip2(progressSummary, 800) || "(none)"}`,
     `RECENT_CONTEXT:
-${clip(recentContextTail, 1500) || "(none)"}`,
+${clip2(recentContextTail, 1500) || "(none)"}`,
     `REPO_MAP (paths):
-${clip(repoMap, 2500) || "(empty)"}`,
+${clip2(repoMap, 2500) || "(empty)"}`,
     repoContext ? `REPO_CONTEXT:
-${clip(repoContext, 800)}` : ""
+${clip2(repoContext, 800)}` : ""
   ].filter(Boolean).join(`
 
 `);
@@ -330441,507 +331347,6 @@ function buildShortReasoning(p) {
   return `Next: ${p.tool} (git phase ${p.gitPhase}).`;
 }
 
-// src/tools/harness-processes.ts
-import { spawn } from "child_process";
-import { EventEmitter as EventEmitter2 } from "events";
-var BG_TOOLS = new Set([
-  "bg_start",
-  "bg_list",
-  "bg_logs",
-  "bg_kill"
-]);
-var BG_READ_ONLY_TOOLS = new Set(["bg_list", "bg_logs"]);
-var isBgTool = (t2) => typeof t2 === "string" && BG_TOOLS.has(t2);
-var str = (v) => typeof v === "string" && v.trim() ? v.trim() : null;
-function parseBgDecision(p) {
-  if (!isBgTool(p.tool))
-    return null;
-  const tool = p.tool;
-  const cmd = tool === "bg_start" ? str(p.cmd) ?? str(p.command) ?? str(p.content) : null;
-  const named = str(p.target) ?? str(p.name) ?? str(p.label) ?? str(p.id) ?? (typeof p.id === "number" ? String(p.id) : null);
-  const target = tool === "bg_start" ? named : named ?? str(p.targetFile) ?? str(p.content);
-  return {
-    tool,
-    cmd,
-    target,
-    reasoning: (str(p.reasoning) ?? "").slice(0, 1000),
-    needMoreSteps: Boolean(p.need_more_steps || p.needs_more_steps)
-  };
-}
-var LONG_RUNNING_SHELL_RE = new RegExp([
-  String.raw`\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|watch|preview)\b`,
-  String.raw`\bbun\s+(?:--hot|--watch)\b`,
-  String.raw`\bnext\s+(?:dev|start)\b`,
-  String.raw`\bvite(?:\s+(?:dev|preview|serve))?\s*(?:--\S+\s*)*$`,
-  String.raw`\bnodemon\b`,
-  String.raw`\bhttp\.server\b`,
-  String.raw`\brunserver\b`,
-  String.raw`\buvicorn\b`,
-  String.raw`\bflask\s+run\b`,
-  String.raw`\bnpx\s+serve\b`,
-  String.raw`(?:^|&&|;)\s*anvil\b`,
-  String.raw`\bhardhat\s+node\b`,
-  String.raw`\bsolana-test-validator\b`,
-  String.raw`\bngrok\b`,
-  String.raw`\bdocker(?:-|\s+)compose\s+up\b(?!.*\s-d\b)`,
-  String.raw`\btail\s+-f\b`,
-  String.raw`\s--watch\b`,
-  String.raw`(?<!&)&\s*$`
-].join("|"), "i");
-var BG_TOOL_RULES = `BACKGROUND PROCESS TOOLS \u2014 extra values for "tool", for servers, watchers and anything that doesn't exit on its own:
-- "bg_start": "cmd" = the literal command; "target" = optional short name (e.g. "web"). Returns the first few seconds of output (and any URL) so you can tell whether it came up.
-- "bg_list": no other fields.
-- "bg_logs": "target" = process id, name or port. Use it to see what a process is doing or why it died.
-- "bg_kill": "target" = process id, name or port, or "all".
-Rules:
-- NEVER run a server/watcher through "shell" (it blocks until it times out). Use "bg_start".
-- "start/run/launch the server" -> bg_start. If the user gave no command, "read" package.json (or pyproject.toml, manage.py, foundry.toml, Cargo.toml ...) to find the dev/start script, then bg_start it.
-- "stop/kill/shut down/turn off the server" -> bg_kill on the matching tracked process. This always means the tracked process, never the machine, and never "shell". "stop everything" -> target "all".
-- "restart X" -> bg_kill X, then bg_start with the same cmd (it is listed under BACKGROUND PROCESSES).
-- "what's running / is X up / what's X doing / why did X die" -> answer from BACKGROUND PROCESSES, or bg_list / bg_logs for real output. Never guess.
-- If the thing to stop is not tracked (started outside this session), say so; if the user gave a port, "shell" with lsof -ti :PORT can find the owner.
-- Never start a duplicate of a running process. After bg_start, if it crashed, bg_logs it, fix the cause, retry.
-- For bg_* tools leave "targetFile", "content", "target"/"cmd" not mentioned above as null.`;
-var GAP = String.raw`[^.!?\n]{0,40}?`;
-var LEAD = String.raw`(?<!\w)`;
-var TRAIL = String.raw`(?!\w)`;
-var NEG_RE = /\b(?:don'?t|do\s+not|never|no\s+need\s+to|without|instead\s+of|rather\s+than)\b[^.!?\n]{0,25}?\b(?:start|run|launch|stop|kill|shut|restart|spin|boot)/i;
-var STOP_V = String.raw`(?:stop|kill|terminate|shut\s*(?:it\s*|them\s*)?(?:down|off)|take\s+(?:it\s+|them\s+)?down|bring\s+(?:it\s+|them\s+)?down|turn\s+(?:it\s+|them\s+)?off|halt)`;
-var PROC_N = String.raw`(?:servers?|processes|process|watchers?|daemons?|services?|dev|backend|frontend|api|app|everything|all|bg|background|p\d+|ports?\s*\d+|:\d{2,5}|localhost|anvil|vite|django|flask|uvicorn)`;
-var STOP_RE = new RegExp(String.raw`\b${STOP_V}\b${GAP}${LEAD}${PROC_N}${TRAIL}`, "i");
-var STOP_PRONOUN_RE = /\b(?:stop|kill|terminate|shut\s*(?:it\s*|them\s*)?down|turn\s+(?:it|them)\s+off)\s+(?:it|that|this|them|those)\b/i;
-var STOP_BARE_RE = /^\s*(?:please\s+)?(?:shut\s*down|stop|kill|terminate)(?:\s+(?:now|please))?\s*[.!]*\s*$/i;
-var STOP_EXCLUDE_RE = /\bfrom\s+\w+ing\b|\busing\b|\bbeing\b/i;
-var START_V = String.raw`(?:start|run|launch|spin\s*up|boot(?:\s+up)?|fire\s*up|bring\s*up|kick\s*off|serve)`;
-var START_N = String.raw`(?:servers?|dev|watcher|backend|frontend|api|app|site|website|anvil|localhost|daemon|in\s+(?:the\s+)?(?:background|bg)|background|bg)`;
-var START_RE = new RegExp(String.raw`\b${START_V}\b${GAP}${LEAD}${START_N}${TRAIL}`, "i");
-var START_EXCLUDE_RE = /\b(?:tests?|specs?|lint|typecheck|build|compile|migrat\w*|install|seed|script|format|generate|check|review|read|look(?:ing)?|by\s+\w+ing)\b/i;
-var BACKGROUND_RE = /\bbackground\b|\bbg\b/i;
-var RESTART_RE = new RegExp(String.raw`\b(?:restart|reboot|relaunch|bounce|cycle)\b${GAP}${LEAD}(?:servers?|dev|watcher|process(?:es)?|backend|frontend|api|app|it|them|everything|p\d+)${TRAIL}`, "i");
-var RESTART_BARE_RE = /^\s*(?:please\s+)?(?:restart|reboot|relaunch)(?:\s+it)?\s*[.!]*\s*$/i;
-var LOGS_A_RE = new RegExp(String.raw`\b(?:logs?|output|stdout|stderr|tail|what'?s\s+(?:it\s+)?(?:doing|going\s+on|happening)|how(?:'s|\s+is))\b${GAP}${LEAD}(?:server|process|dev|backend|frontend|p\d+|it|anvil|watcher|bg|background)${TRAIL}`, "i");
-var LOGS_B_RE = /\b(?:is\s+(?:it|the\s+[\w-]+)\s+(?:up|running|working|alive|crashed|dead)|did\s+(?:it|the\s+[\w-]+)\s+(?:crash|start|fail|die|work))\b/i;
-var LIST_RE = new RegExp(String.raw`\b(?:what(?:'s|\s+is|\s+are)?|which|show|list|any|are\s+there|see)\b${GAP}${LEAD}(?:running|processes|servers|background|bg)${TRAIL}`, "i");
-var HEAD = "USER INTENT (detected from their message; it is a hint, use your judgment if it is wrong):";
-var STOP_NOTE = `${HEAD} the user wants to STOP background process(es). Call "bg_kill" now. "target" = the id from BACKGROUND PROCESSES that matches what they named (name, id or port), or "all" if they said everything/all/shut down. If they named nothing and exactly one is running, that one. This means the tracked process, never the machine, and never "shell". If they also asked for something else, do it after.`;
-var START_NOTE = `${HEAD} the user wants to START a server / long-running process. Call "bg_start" (never "shell"). If they gave a command, use it verbatim. Otherwise "read" package.json (or the project's equivalent) first, pick the dev/start script, then bg_start with the full runner command (e.g. "bun run dev"). Don't start a duplicate of something already running.`;
-var RESTART_NOTE = `${HEAD} the user wants to RESTART a background process. Call "bg_kill" on it first (its cmd is listed under BACKGROUND PROCESSES), then "bg_start" with the same cmd.`;
-var LOGS_NOTE = `${HEAD} the user is asking how a background process is doing. Call "bg_logs" for the real output and base your answer on it.`;
-var LIST_NOTE = `${HEAD} the user is asking what is running. Answer from BACKGROUND PROCESSES (or "bg_list").`;
-var NOTHING_RUNNING_NOTE = `${HEAD} the user wants to stop something, but no background process is running. Say so plainly. If they named a port, a process started outside this session can be found with "shell" lsof -ti :PORT.`;
-var NONE_TRACKED_NOTE = `${HEAD} no background processes are tracked in this session. If the user is asking about running servers, say none were started here.`;
-function detectBgIntent(task, running, known) {
-  const t2 = task.slice(0, 4000);
-  if (!t2.trim() || NEG_RE.test(t2))
-    return null;
-  const needs = [];
-  const notes = [];
-  if (RESTART_RE.test(t2) || RESTART_BARE_RE.test(t2)) {
-    if (running > 0)
-      needs.push("bg_kill");
-    needs.push("bg_start");
-    notes.push(RESTART_NOTE);
-  } else {
-    const stopM = STOP_RE.exec(t2);
-    const stopHit = stopM !== null && !STOP_EXCLUDE_RE.test(stopM[0]) || STOP_PRONOUN_RE.test(t2) || STOP_BARE_RE.test(t2);
-    if (stopHit) {
-      if (running > 0) {
-        needs.push("bg_kill");
-        notes.push(STOP_NOTE);
-      } else {
-        notes.push(NOTHING_RUNNING_NOTE);
-      }
-    }
-    const startM = START_RE.exec(t2);
-    if (startM && (!START_EXCLUDE_RE.test(startM[0]) || BACKGROUND_RE.test(startM[0]))) {
-      needs.push("bg_start");
-      notes.push(START_NOTE);
-    }
-  }
-  const strong = needs.includes("bg_start") || needs.includes("bg_kill");
-  if (!strong && notes.length === 0) {
-    const asksLogs = LOGS_A_RE.test(t2) || LOGS_B_RE.test(t2);
-    if (known > 0) {
-      if (asksLogs) {
-        needs.push("bg_logs");
-        notes.push(LOGS_NOTE);
-      } else if (LIST_RE.test(t2)) {
-        notes.push(LIST_NOTE);
-      }
-    } else if (asksLogs || LIST_RE.test(t2)) {
-      notes.push(NONE_TRACKED_NOTE);
-    }
-  }
-  if (notes.length === 0)
-    return null;
-  return { needs, strong, note: notes.join(`
-`) };
-}
-var LOG_CAP = 64000;
-var TAIL_CHAR_CAP = 6000;
-var MAX_RUNNING = 8;
-var MAX_FINISHED_KEPT = 10;
-var STARTUP_GRACE_MS = 4000;
-var KILL_GRACE_MS = 3000;
-var EXIT_DRAIN_MS = 120;
-var ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07]*\x07/g;
-var READY_RE = /\b(?:ready|listening|compiled|started|local:|on port)\b/i;
-var URL_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\]):\d+[^\s'")]*/gi;
-var PORT_RE = /\bport\s*:?\s*(\d{2,5})\b/gi;
-var ALL_RE = /^(?:all|everything|\*|all\s+(?:the\s+)?(?:servers|processes|background(?:\s+processes)?))$/;
-var GENERIC_RE = /^(?:the\s+|that\s+|this\s+|my\s+)?(?:dev\s+|web\s+|local\s+|background\s+)?(?:server|process|watcher|app|service|it)$/;
-var clip2 = (s2, n3) => s2.length > n3 ? `${s2.slice(0, n3 - 1)}\u2026` : s2;
-function fmtDur(ms) {
-  const s2 = Math.max(0, Math.floor(ms / 1000));
-  if (s2 < 60)
-    return `${s2}s`;
-  const m = Math.floor(s2 / 60);
-  if (m < 60)
-    return `${m}m${s2 % 60}s`;
-  return `${Math.floor(m / 60)}h${m % 60}m`;
-}
-function deriveLabel(cmd) {
-  const words = cmd.split(/\s+/).filter((w) => w && !/^\w+=/.test(w));
-  return clip2(words.slice(0, 3).join(" "), 24);
-}
-var urlSuffix = (m) => m.urls.size ? ` \xB7 ${[...m.urls].join(", ")}` : "";
-
-class ProcessManager {
-  procs = new Map;
-  seq = 0;
-  constructor() {
-    process.once("exit", () => this.killAllSync());
-  }
-  count() {
-    return this.procs.size;
-  }
-  runningCount() {
-    let n3 = 0;
-    for (const p of this.procs.values())
-      if (p.status === "running")
-        n3++;
-    return n3;
-  }
-  async start(opts) {
-    const cmd = opts.cmd.trim().replace(/(?<!&)&\s*$/, "").trim();
-    if (!cmd)
-      throw new Error("empty command");
-    const dup = [...this.procs.values()].find((p) => p.status === "running" && p.cmd === cmd && p.cwd === opts.cwd);
-    if (dup) {
-      return {
-        kind: "duplicate",
-        id: dup.id,
-        report: `Already running as ${dup.id} "${dup.label}" (pid ${dup.pid}, up ${fmtDur(Date.now() - dup.startedAt)})` + `${urlSuffix(dup)}. Not starting a second copy; use bg_logs to inspect it or bg_kill to restart it.`
-      };
-    }
-    if (this.runningCount() >= MAX_RUNNING) {
-      throw new Error(`${MAX_RUNNING} background processes already running; kill one first`);
-    }
-    const id = `p${++this.seq}`;
-    const label = (opts.label ?? "").trim().slice(0, 24) || deriveLabel(cmd);
-    const child = spawn("bash", ["-lc", cmd], {
-      cwd: opts.cwd,
-      detached: process.platform !== "win32",
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", BROWSER: "none" }
-    });
-    const m = {
-      id,
-      label,
-      cmd,
-      cwd: opts.cwd,
-      child,
-      pid: child.pid,
-      status: "running",
-      startedAt: Date.now(),
-      endedAt: null,
-      exitCode: null,
-      signal: null,
-      killRequested: false,
-      noticed: false,
-      buf: "",
-      totalChars: 0,
-      urls: new Set,
-      events: new EventEmitter2
-    };
-    this.procs.set(id, m);
-    const onData = (d2) => this.append(m, d2.toString("utf8"));
-    child.stdout?.on("data", onData);
-    child.stderr?.on("data", onData);
-    child.on("error", (err) => {
-      this.append(m, `[spawn error] ${err.message}
-`);
-      this.finish(m, null, null);
-    });
-    let drain;
-    child.on("exit", (code, signal) => {
-      drain = setTimeout(() => this.finish(m, code, signal), EXIT_DRAIN_MS);
-    });
-    child.on("close", (code, signal) => {
-      if (drain)
-        clearTimeout(drain);
-      this.finish(m, code, signal);
-    });
-    try {
-      child.unref();
-      for (const s2 of [child.stdout, child.stderr]) {
-        s2?.unref?.();
-      }
-    } catch {}
-    await this.waitForStartup(m, opts.graceMs ?? STARTUP_GRACE_MS);
-    if (m.status !== "running") {
-      return {
-        kind: "crashed",
-        id,
-        report: `${id} "${label}" exited ${m.exitCode !== null ? `with code ${m.exitCode}` : `(${m.signal ?? "unknown"})`} ` + `${fmtDur((m.endedAt ?? Date.now()) - m.startedAt)} after starting.
-Output:
-${this.tail(m, 30)}`
-      };
-    }
-    return {
-      kind: "started",
-      id,
-      report: `Started ${id} "${label}" (pid ${m.pid}) in the background: ${cmd}
-` + `Status: running${urlSuffix(m)}
-Initial output:
-${this.tail(m, 25)}
-` + `It keeps running after this turn. Refer to it as "${id}" with bg_logs / bg_kill.`
-    };
-  }
-  formatList() {
-    if (this.procs.size === 0)
-      return "No background processes.";
-    return [...this.procs.values()].map((m) => this.line(m)).join(`
-`);
-  }
-  logs(ref, lines = 60) {
-    const f2 = this.find(ref);
-    if ("error" in f2)
-      return f2.error;
-    const m = f2.m;
-    return `${m.id} "${m.label}" [${m.status}] \u2014 last ${lines} lines (${m.totalChars} chars emitted in total):
-${this.tail(m, lines)}`;
-  }
-  promptBlock() {
-    if (this.procs.size === 0)
-      return "";
-    const all3 = [...this.procs.values()];
-    const shown = [
-      ...all3.filter((p) => p.status === "running"),
-      ...all3.filter((p) => p.status !== "running").slice(-3)
-    ];
-    return `BACKGROUND PROCESSES (tracked by the harness; they keep running between turns):
-` + shown.map((m) => this.line(m)).join(`
-`) + `
-Use bg_logs with the id to see output, bg_kill to stop one. Never start a duplicate of a running process.`;
-  }
-  consumeExitNotices() {
-    const out = [];
-    for (const m of this.procs.values()) {
-      if (m.status === "running" || m.noticed)
-        continue;
-      m.noticed = true;
-      let s2 = `Background ${m.id} "${m.label}" ${m.status === "failed" ? `crashed (exit ${m.exitCode ?? m.signal})` : `exited (code ${m.exitCode ?? m.signal})`}`;
-      if (m.status === "failed") {
-        const last = m.buf.split(`
-`).map((l) => l.trim()).filter(Boolean).slice(-2).map((l) => clip2(l, 160));
-        if (last.length)
-          s2 += `
-    ${last.join(`
-    `)}`;
-      }
-      out.push(s2);
-    }
-    return out;
-  }
-  async kill(ref) {
-    if (ALL_RE.test((ref ?? "").trim().toLowerCase()))
-      return this.killAll();
-    const f2 = this.find(ref);
-    if ("error" in f2)
-      return f2.error;
-    const m = f2.m;
-    if (m.status !== "running") {
-      return `${m.id} "${m.label}" is not running (${m.status}, exit ${m.exitCode ?? m.signal}).`;
-    }
-    const up = fmtDur(Date.now() - m.startedAt);
-    await this.terminate(m);
-    return `Killed ${m.id} "${m.label}" (pid ${m.pid}, was up ${up}).`;
-  }
-  async killAll() {
-    const running = [...this.procs.values()].filter((p) => p.status === "running");
-    if (running.length === 0)
-      return "No running background processes.";
-    await Promise.all(running.map((m) => this.terminate(m)));
-    return `Killed ${running.length} background process${running.length > 1 ? "es" : ""}: ${running.map((m) => m.id).join(", ")}.`;
-  }
-  line(m) {
-    const when = m.status === "running" ? `up ${fmtDur(Date.now() - m.startedAt)}` : `exit ${m.exitCode ?? m.signal}, ${fmtDur(Date.now() - (m.endedAt ?? Date.now()))} ago`;
-    return `${m.id} "${m.label}" [${m.status}] pid ${m.pid ?? "?"} \xB7 ${when}${urlSuffix(m)}
-    $ ${clip2(m.cmd, 120)}`;
-  }
-  find(ref) {
-    const all3 = [...this.procs.values()];
-    if (all3.length === 0)
-      return { error: "Failed: no background processes exist." };
-    const known = all3.map((p) => `${p.id} "${p.label}" [${p.status}]`).join(", ");
-    const running = all3.filter((p) => p.status === "running");
-    const key = (ref ?? "").trim().replace(/^["']|["']$/g, "").toLowerCase();
-    if (!key) {
-      const only = running.length === 1 ? running[0] : all3.length === 1 ? all3[0] : undefined;
-      return only ? { m: only } : { error: `Failed: specify a process id. Known: ${known}` };
-    }
-    const byId = all3.find((p) => p.id === key);
-    if (byId)
-      return { m: byId };
-    const exact = [...all3].reverse().find((p) => p.label.toLowerCase() === key);
-    if (exact)
-      return { m: exact };
-    const pick2 = (cands) => {
-      if (cands.length === 0)
-        return null;
-      const live = cands.filter((p) => p.status === "running");
-      const pool = live.length > 0 ? live : cands;
-      if (pool.length === 1)
-        return { m: pool[0] };
-      return {
-        error: `Failed: "${ref}" is ambiguous. Candidates: ${pool.map((p) => `${p.id} "${p.label}" [${p.status}]`).join(", ")}`
-      };
-    };
-    const port = /^(?:.*?[:\s])?(\d{2,5})$/.exec(key)?.[1];
-    if (port) {
-      const portRe = new RegExp(`\\b${port}\\b`);
-      const hit = pick2(all3.filter((p) => [...p.urls].some((u) => u.includes(`:${port}`)) || portRe.test(p.cmd)));
-      if (hit)
-        return hit;
-    }
-    const partial2 = pick2(all3.filter((p) => {
-      const label = p.label.toLowerCase();
-      return label.length >= 3 && (label.includes(key) || key.includes(label)) || p.cmd.toLowerCase().includes(key);
-    }));
-    if (partial2)
-      return partial2;
-    if (GENERIC_RE.test(key) && running.length === 1)
-      return { m: running[0] };
-    return { error: `Failed: no process "${ref}". Known: ${known}` };
-  }
-  append(m, raw) {
-    const text = raw.replace(ANSI_RE, "").replace(/\r\n/g, `
-`).replace(/[^\n]*\r/g, "");
-    if (!text)
-      return;
-    m.totalChars += text.length;
-    m.buf += text;
-    if (m.buf.length > LOG_CAP) {
-      m.buf = m.buf.slice(-LOG_CAP);
-      m.buf = m.buf.slice(m.buf.indexOf(`
-`) + 1);
-    }
-    for (const u of text.match(URL_RE) ?? []) {
-      if (m.urls.size < 5)
-        m.urls.add(u.replace(/[.,;/]+$/, ""));
-    }
-    for (const pm of text.matchAll(PORT_RE)) {
-      const p = pm[1];
-      if (p && m.urls.size < 5 && ![...m.urls].some((u) => u.includes(`:${p}`))) {
-        m.urls.add(`http://localhost:${p}`);
-      }
-    }
-    if (m.urls.size > 0 || READY_RE.test(text))
-      m.events.emit("ready");
-  }
-  tail(m, lines) {
-    const out = m.buf.split(`
-`).slice(-lines).join(`
-`).trim();
-    if (!out)
-      return "(no output yet)";
-    return out.length > TAIL_CHAR_CAP ? `\u2026${out.slice(-TAIL_CHAR_CAP)}` : out;
-  }
-  finish(m, code, signal) {
-    if (m.status !== "running")
-      return;
-    m.endedAt = Date.now();
-    m.exitCode = code;
-    m.signal = signal;
-    m.status = m.killRequested ? "killed" : code === 0 ? "exited" : "failed";
-    m.noticed = m.killRequested;
-    m.events.emit("exit");
-    this.prune();
-  }
-  prune() {
-    const finished2 = [...this.procs.values()].filter((p) => p.status !== "running");
-    for (const p of finished2.slice(0, Math.max(0, finished2.length - MAX_FINISHED_KEPT))) {
-      this.procs.delete(p.id);
-    }
-  }
-  waitForStartup(m, ms) {
-    return new Promise((resolve) => {
-      if (m.status !== "running")
-        return resolve();
-      let settle3;
-      const done = () => {
-        clearTimeout(timer);
-        if (settle3)
-          clearTimeout(settle3);
-        m.events.off("ready", onReady);
-        m.events.off("exit", done);
-        resolve();
-      };
-      const onReady = () => {
-        if (!settle3)
-          settle3 = setTimeout(done, 300);
-      };
-      const timer = setTimeout(done, ms);
-      m.events.on("ready", onReady);
-      m.events.once("exit", done);
-    });
-  }
-  waitForExit(m, ms) {
-    return new Promise((resolve) => {
-      if (m.status !== "running")
-        return resolve(true);
-      const onExit = () => {
-        clearTimeout(timer);
-        resolve(true);
-      };
-      const timer = setTimeout(() => {
-        m.events.off("exit", onExit);
-        resolve(false);
-      }, ms);
-      m.events.once("exit", onExit);
-    });
-  }
-  signalGroup(m, sig) {
-    try {
-      if (process.platform !== "win32" && m.pid)
-        process.kill(-m.pid, sig);
-      else
-        m.child.kill(sig);
-    } catch {
-      try {
-        m.child.kill(sig);
-      } catch {}
-    }
-  }
-  async terminate(m) {
-    m.killRequested = true;
-    this.signalGroup(m, "SIGTERM");
-    if (await this.waitForExit(m, KILL_GRACE_MS + EXIT_DRAIN_MS))
-      return;
-    this.signalGroup(m, "SIGKILL");
-    await this.waitForExit(m, 1000 + EXIT_DRAIN_MS);
-  }
-  killAllSync() {
-    for (const m of this.procs.values()) {
-      if (m.status === "running") {
-        m.killRequested = true;
-        this.signalGroup(m, "SIGTERM");
-      }
-    }
-  }
-}
-
 // src/tools/pipe.ts
 var defaultIsRetryable = (err) => {
   const msg = err instanceof Error ? err.message : String(err);
@@ -340389,268 +340794,6 @@ async function webSearch(query, budget, limit = DEFAULT_LIMIT) {
 }
 
 // src/tools/harness-orchestrator.ts
-var DEBUG_TRACE = Boolean(process.env.BASECODE_DEBUG);
-var CLEAR_LINE = "\r\x1B[2K";
-var WEB_SEARCH_FAILED_RE = /^\[Web search results[^\n]*\n(?:REJECTED|SEARCH FAILED):/;
-var TOOL_OUTPUT_CHAR_CAP = 16000;
-var SHELL_OUTPUT_BYTE_CAP = 256000;
-var RESULT_TAIL_CHARS = 8000;
-var INIT_PER_FILE_CHAR_CAP = 8000;
-var INIT_TOTAL_DUMP_CHAR_CAP = 200000;
-var HEAVY_KEEP_CHARS = 40000;
-var REPO_MAP_CHAR_CAP = 12000;
-var JEV_REPO_MAP_CHAR_CAP = 4000;
-var JEV_TASK_CHAR_CAP = 3000;
-var JEV_TAIL_MSGS = 3;
-var JEV_TAIL_CHARS = 1500;
-var PRIOR_MSG_CHAR_CAP = 2500;
-var SYNTHESIS_OVERVIEW_CHARS = 6000;
-var NOTICE_POLL_MS = 250;
-var VISION_MODEL_ID = "gemini-2.5-flash";
-var VISION_MAX_TOKENS = 1200;
-var VISION_TIMEOUT_MS = 60000;
-var VISION_MAX_IMAGE_BYTES = 8 * 1024 * 1024;
-var VISION_CONCURRENCY = 3;
-var VISION_SYSTEM_PROMPT = "You describe images for a coding agent that cannot see them. " + "Transcribe all visible text, code, error messages and numbers verbatim. " + "Then describe layout, UI elements, colours, diagrams and anything relevant to a software task. " + "Be factual and compact (under 400 words) and do not speculate about intent. " + "Reply with the description only.";
-var DECISION_JSON_START_RE = /\{\s*"(?:tool|reasoning|need_more_steps|requires_confirmation)"\s*:/;
-var DECISION_JSON_PREFIX_RE = /^\{\s*(?:"[a-z_]{0,24}"?\s*:?)?$/;
-var DECISION_JSON_FENCE_TAIL_RE = /```(?:json)?\s*$/i;
-var DECISION_JSON_PARTIAL_FENCE_RE = /(?:`{1,2}|```(?:j(?:s(?:o(?:n)?)?)?)?\s*)$/i;
-var DECISION_JSON_HOLD_CHARS = 40;
-var isDecisionShaped = (v) => isRecord2(v) && (("tool" in v) && (v.tool === null || typeof v.tool === "string") || ("reasoning" in v) && (("need_more_steps" in v) || ("needs_more_steps" in v) || ("requires_confirmation" in v)));
-function jsonObjectEnd(s2, start) {
-  let depth = 0;
-  let inStr = false;
-  let esc2 = false;
-  for (let i2 = start;i2 < s2.length; i2++) {
-    const c2 = s2[i2];
-    if (inStr) {
-      if (esc2)
-        esc2 = false;
-      else if (c2 === "\\")
-        esc2 = true;
-      else if (c2 === '"')
-        inStr = false;
-      continue;
-    }
-    if (c2 === '"')
-      inStr = true;
-    else if (c2 === "{")
-      depth++;
-    else if (c2 === "}") {
-      depth--;
-      if (depth === 0)
-        return i2 + 1;
-    }
-  }
-  return -1;
-}
-function salvageReasoning(partial2) {
-  const raw = /"reasoning"\s*:\s*"((?:[^"\\]|\\.)*)"/.exec(partial2)?.[1];
-  if (raw === undefined)
-    return "";
-  try {
-    return String(JSON.parse(`"${raw}"`)).trim();
-  } catch {
-    return raw.trim();
-  }
-}
-function decisionPackageText(json3) {
-  let parsed;
-  try {
-    parsed = JSON.parse(json3);
-  } catch {
-    return salvageReasoning(json3);
-  }
-  if (!isDecisionShaped(parsed))
-    return json3;
-  return typeof parsed.reasoning === "string" ? parsed.reasoning.trim() : "";
-}
-function decisionJsonHoldFrom(s2) {
-  let hold = s2.length;
-  const open3 = s2.lastIndexOf("{");
-  if (open3 >= 0 && s2.length - open3 <= DECISION_JSON_HOLD_CHARS && DECISION_JSON_PREFIX_RE.test(s2.slice(open3))) {
-    hold = open3;
-  }
-  const fence = DECISION_JSON_PARTIAL_FENCE_RE.exec(s2.slice(0, hold));
-  if (fence && fence.index >= hold - DECISION_JSON_HOLD_CHARS)
-    hold = fence.index;
-  return hold;
-}
-async function* guardDecisionJson(source) {
-  let pending2 = "";
-  let inPackage = false;
-  let dropCloseFence = false;
-  for await (const chunk of source) {
-    const d2 = chunk.delta;
-    if (!d2)
-      continue;
-    pending2 += d2;
-    for (;; ) {
-      if (inPackage) {
-        const end = jsonObjectEnd(pending2, 0);
-        if (end < 0)
-          break;
-        const text = decisionPackageText(pending2.slice(0, end));
-        pending2 = pending2.slice(end);
-        inPackage = false;
-        if (text)
-          yield { delta: text };
-        continue;
-      }
-      if (dropCloseFence) {
-        const t2 = pending2.trimStart();
-        if (t2 === "" || /^`{1,2}$/.test(t2))
-          break;
-        dropCloseFence = false;
-        if (t2.startsWith("```"))
-          pending2 = t2.slice(3);
-      }
-      const hit = DECISION_JSON_START_RE.exec(pending2);
-      if (hit) {
-        const head = pending2.slice(0, hit.index);
-        const fenced = DECISION_JSON_FENCE_TAIL_RE.test(head);
-        pending2 = pending2.slice(hit.index);
-        inPackage = true;
-        dropCloseFence = fenced;
-        const keep = fenced ? head.replace(DECISION_JSON_FENCE_TAIL_RE, "") : head;
-        if (keep)
-          yield { delta: keep };
-        continue;
-      }
-      const hold = decisionJsonHoldFrom(pending2);
-      const out = pending2.slice(0, hold);
-      pending2 = pending2.slice(hold);
-      if (out)
-        yield { delta: out };
-      break;
-    }
-  }
-  if (inPackage) {
-    const text = salvageReasoning(pending2);
-    if (text)
-      yield { delta: text };
-  } else if (dropCloseFence && /^[\s`]*$/.test(pending2)) {} else if (pending2) {
-    yield { delta: pending2 };
-  }
-}
-var BASECODE_POINTER = "BASECODE.md exists at the repo root (architecture, conventions, commands) but is NOT inlined, to save tokens. " + 'Read it once with the "read" tool if the task needs project background; skip it for self-contained tasks.';
-var NO_BASECODE_NOTE = "No BASECODE.md yet (the user can run /init to generate one).";
-var GIT_INTENT = /\b(git|commit|committed|merge|push|pull|rebase|branch|branches|checkout|stash|tag|cherry-?pick|reset|revert|amend)\b/i;
-var NO_INLINE_CONTENT_RULE = {
-  role: "system",
-  content: `OUTPUT REMINDER: "write"/"append": set "content" to "" (the file is generated in a separate step; never inline source). ` + `"edit": "target" and "replacement" are REQUIRED, copied verbatim from file contents shown in context, kept small. ` + `"shell": "cmd" is REQUIRED (the literal command). "web_search": "content" is REQUIRED \u2014 a short, specific query ` + `(3-10 words) with no secrets, local paths or code; other fields null. "reasoning": ONE short sentence. ` + `"bg_start": "cmd" REQUIRED (the literal command), "target" = optional short name; "bg_logs"/"bg_kill": "target" = ` + `process id, name or port ("bg_kill" accepts "all"); "bg_list": nothing else. Never run servers/watchers via "shell". ` + `Your whole JSON must fit in ${DECISION_MAX_TOKENS} tokens or the step is wasted. ` + `For project background read BASECODE.md (not inlined); if none exists, tell the user to run /init.`
-};
-var BG_RULES_MESSAGE = { role: "system", content: BG_TOOL_RULES };
-var MAX_ASKS_PER_TASK = 2;
-var ASK_MAX_QUESTIONS = 4;
-var ASK_MAX_OPTIONS = 4;
-var ASK_MAX_QUESTION_CHARS = 400;
-var ASK_MAX_OPTION_CHARS = 120;
-var PENDING_BLOCKED_TOOLS = new Set(["write", "edit", "append", "shell", "bg_start"]);
-var QUESTION_CONTEXT_RE = /^\[(?:USER ANSWER|QUESTIONS ASKED)\]|^\[System\] QUESTIONS:/;
-var QUESTION_BLOCK_RE = /\? Questions for you \(\d+\):\n(?: {2}\d+\. .*\n)+\n?/g;
-var clipText = (s2, n3) => s2.length > n3 ? `${s2.slice(0, n3 - 1)}\u2026` : s2;
-function cleanAskOptions(v) {
-  if (!Array.isArray(v))
-    return [];
-  const seen = new Set;
-  const out = [];
-  for (const o2 of v) {
-    if (typeof o2 !== "string")
-      continue;
-    const t2 = o2.replace(/\s+/g, " ").trim().slice(0, ASK_MAX_OPTION_CHARS);
-    const key = t2.toLowerCase();
-    if (!t2 || seen.has(key))
-      continue;
-    seen.add(key);
-    out.push(t2);
-    if (out.length >= ASK_MAX_OPTIONS)
-      break;
-  }
-  return out;
-}
-function parseAskDecision(parsed) {
-  if (!isRecord2(parsed) || parsed.tool !== "ask_user_question")
-    return null;
-  const rawItems = [];
-  if (Array.isArray(parsed.questions))
-    rawItems.push(...parsed.questions);
-  else if (typeof parsed.question === "string") {
-    rawItems.push({ question: parsed.question, options: parsed.options });
-  }
-  const questions = [];
-  const seen = new Set;
-  for (const item of rawItems) {
-    let text = "";
-    let options = [];
-    if (typeof item === "string") {
-      text = item;
-    } else if (isRecord2(item) && typeof item.question === "string") {
-      text = item.question;
-      options = cleanAskOptions(item.options);
-    }
-    text = text.replace(/\s+/g, " ").trim().slice(0, ASK_MAX_QUESTION_CHARS);
-    const key = text.toLowerCase();
-    if (!text || seen.has(key))
-      continue;
-    seen.add(key);
-    questions.push({ question: text, options });
-    if (questions.length >= ASK_MAX_QUESTIONS)
-      break;
-  }
-  return {
-    questions,
-    ignore: parsed.ignore === true,
-    reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning.slice(0, 1000) : ""
-  };
-}
-var QUESTIONS_RULE = {
-  role: "system",
-  content: `ASK TOOL: to ask the user something, return {"tool":"ask_user_question","questions":[{"question":"...","options":["...","..."]}],` + `"reasoning":"...","need_more_steps":true}. 1-${ASK_MAX_QUESTIONS} questions, each self-contained, with 2-${ASK_MAX_OPTIONS} mutually ` + `exclusive options (recommended first) or an empty options array for an open question. A single {"question","options"} pair is also accepted. ` + `All other fields null. The questions are shown to the user as a questionnaire; after asking you MUST stop and wait. ` + `Never ask while questions are pending, never re-ask something already answered (the answers are listed under "USER ANSWERS" in the task), ` + `at most ${MAX_ASKS_PER_TASK} asks per task. To drop the pending questions because the user's message makes them moot, return ` + `{"tool":"ask_user_question","ignore":true,"reasoning":"..."}.`
-};
-var JEV_BYPASS = {
-  unavailable: true,
-  tool: "none",
-  needMoreSteps: false,
-  confidence: 0,
-  reasoning: ""
-};
-var MEMORY_CHAR_CAP = 6000;
-var MEMORY_MAX_NEW_ENTRIES = 3;
-var MEMORY_MAX_ENTRY_CHARS = 250;
-var MEMORY_HEADER = `# BASECODE MEMORY
-Project-specific preferences and fixes learned from past sessions. Newest last.
-`;
-var MEMORY_SIGNAL = /\b(always|never|don'?t|do not|instead|prefer|from now on|remember|actually|wrong|incorrect|not what i|should(?:n'?t)?|stop (?:using|doing)|use \S+ (?:not|instead))\b/i;
-var MEMORY_SECRET_PATTERN = /(?:sk-[A-Za-z0-9_-]{16,}|AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{20,}|api[_-]?key\s*[:=]|password\s*[:=]|secret\s*[:=]|token\s*[:=]|-----BEGIN)/i;
-var MEMORY_LEARNER_PROMPT = `You maintain a small long-term memory file for a coding agent working in one project.
-From the exchange below, extract ONLY durable, reusable lessons:
-- a way the user wants things done (style, tooling, conventions, workflow), or
-- a non-obvious fix / root cause in THIS project that would save time if it came up again.
-
-Rules:
-- Each entry is ONE short imperative sentence (max 200 chars) that makes sense with no other context.
-- Do NOT record one-off task details, lists of files changed, or anything already in EXISTING MEMORY (including paraphrases).
-- Do NOT record secrets, API keys, tokens, or personal data.
-- If the user contradicts an existing entry, put the corrected entry in "add" and the old entry's exact text in "remove".
-- Most exchanges contain nothing worth saving. In that case respond with {"add":[],"remove":[]}.
-
-Respond with ONE raw JSON object and nothing else: {"add": string[], "remove": string[]} DO NOT NOTIFY THE USER WHEN YOU UPDATE THIS FILE`;
-var memNorm = (s2) => s2.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-var memEntryText = (line) => line.replace(/^-\s*(?:\[\d{4}-\d{2}-\d{2}\]\s*)?/, "").trim();
-var CHARS_PER_TOKEN = 3.5;
-var TOKENIZE_EXACT_MAX_CHARS = 1e5;
-var estimateTextTokens = (text) => {
-  if (!text)
-    return 0;
-  return text.length > TOKENIZE_EXACT_MAX_CHARS ? Math.ceil(text.length / CHARS_PER_TOKEN) : countTokens2(text);
-};
-var MEDIA_PART_TOKENS = 1000;
-var MESSAGE_OVERHEAD_TOKENS = 4;
-function hasText(part) {
-  return typeof part === "object" && part !== null && typeof part.text === "string";
-}
 function estimateMessagesTokens(messages) {
   let textTokens = 0;
   let media = 0;
@@ -340672,140 +340815,6 @@ function estimateMessagesTokens(messages) {
   }
   return textTokens + media * MEDIA_PART_TOKENS + messages.length * MESSAGE_OVERHEAD_TOKENS;
 }
-function countLines(text) {
-  const len = text.length;
-  if (len === 0)
-    return 0;
-  let n3 = 1;
-  for (let i2 = 0;i2 < len; i2++) {
-    if (text.charCodeAt(i2) === 10)
-      n3++;
-  }
-  if (text.charCodeAt(len - 1) === 10)
-    n3--;
-  return n3 === 0 ? 1 : n3;
-}
-function clipMiddle2(text, max) {
-  if (text.length <= max)
-    return text;
-  const head = Math.floor(max * 0.4);
-  const tail = max - head;
-  return `${text.slice(0, head)}
-\u2026[clipped ${text.length - max} chars]\u2026
-${text.slice(-tail)}`;
-}
-var repoMapMemo = new Map;
-function compactRepoMap(repoMap, cap) {
-  const hit = repoMapMemo.get(cap);
-  if (hit && hit.src === repoMap)
-    return hit.out;
-  let out;
-  try {
-    const paths = flattenRepoMap(repoMap);
-    if (paths.length === 0) {
-      out = repoMap.slice(0, cap);
-    } else {
-      const byDir = new Map;
-      for (const p of paths) {
-        const d2 = dirname(p);
-        const base = d2 === "." ? p : p.slice(d2.length + 1);
-        const list = byDir.get(d2);
-        if (list)
-          list.push(base);
-        else
-          byDir.set(d2, [base]);
-      }
-      const lines = [];
-      let total = 0;
-      let listed = 0;
-      for (const [d2, files] of [...byDir].sort(([a2], [b]) => a2 < b ? -1 : a2 > b ? 1 : 0)) {
-        const line = `${d2 === "." ? "./" : `${d2}/`} ${files.join(" ")}`;
-        if (total + line.length > cap)
-          break;
-        lines.push(line);
-        total += line.length + 1;
-        listed += files.length;
-      }
-      const omitted = paths.length - listed;
-      out = lines.join(`
-`) + (omitted > 0 ? `
-(+${omitted} more files not listed; use find/grep to explore)` : "");
-    }
-  } catch {
-    out = repoMap.slice(0, cap);
-  }
-  repoMapMemo.set(cap, { src: repoMap, out });
-  return out;
-}
-async function readCappedStream(stream4, cap = SHELL_OUTPUT_BYTE_CAP) {
-  if (!stream4)
-    return "";
-  const reader = stream4.getReader();
-  const decoder3 = new TextDecoder;
-  const parts = [];
-  let size = 0;
-  let truncated = false;
-  try {
-    while (size < cap) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (!value)
-        continue;
-      size += value.byteLength;
-      parts.push(decoder3.decode(value, { stream: true }));
-    }
-    if (size >= cap)
-      truncated = true;
-  } catch {} finally {
-    try {
-      await reader.cancel();
-    } catch {}
-  }
-  let out = parts.join("");
-  parts.length = 0;
-  if (out.length > cap)
-    out = out.slice(0, cap);
-  return truncated ? `${out}
-\u2026[output truncated at ${cap} bytes]` : out;
-}
-function buildAttachmentPart(provider, mimeType, output2) {
-  const key = provider.toUpperCase();
-  const isText = mimeType.startsWith("text/");
-  if (key === "GOOGLE") {
-    return isText ? { text: output2 } : { inlineData: { mimeType, data: output2 } };
-  }
-  if (key === "ANTHROPIC") {
-    return {
-      type: mimeType.startsWith("image/") ? "image" : "document",
-      source: { type: "base64", media_type: mimeType, data: output2 }
-    };
-  }
-  if (key === "OPENAI" || key === "GROQ" || key === "VENICE") {
-    return isText ? { type: "text", text: output2 } : { type: "image_url", image_url: { url: `data:${mimeType};base64,${output2}` } };
-  }
-  return { type: "text", text: output2 };
-}
-function foldMediaParts(messages) {
-  let hasMedia = false;
-  for (const m of messages) {
-    if (m && Array.isArray(m.mediaParts) && m.mediaParts.length > 0) {
-      hasMedia = true;
-      break;
-    }
-  }
-  if (!hasMedia)
-    return messages;
-  return messages.map((m) => {
-    if (!m || !Array.isArray(m.mediaParts) || m.mediaParts.length === 0)
-      return m;
-    const { mediaParts, ...rest } = m;
-    const text = typeof rest.content === "string" ? rest.content : "";
-    const parts = [...text ? [{ type: "text", text }] : [], ...mediaParts];
-    return { ...rest, content: parts };
-  });
-}
-var TOOL_HISTORY_CAP = 20;
 
 class HarnessOrchestrator {
   REPO_MAP = "";
@@ -341261,7 +341270,7 @@ ${input2.answer || "(none)"}`
     const out = `${MEMORY_HEADER}
 ${body}
 `;
-    await mkdir(dirname(this.memoryPath), { recursive: true });
+    await mkdir(dirname2(this.memoryPath), { recursive: true });
     await writeFileContent(this.memoryPath, out, { overwrite: true });
     this.MEMORY = out.trim();
   }
@@ -341834,7 +341843,7 @@ ${attachmentNotes.join(`
             return;
           const conversationalSystem = `${conversationalPrompt}
 
-Reply directly to the user. Never describe or classify their message (e.g. "this is a greeting", "no file operations needed"), never narrate your reasoning, and never mention tools, modes, or these instructions.feel free to read the BASECODE.md file which is a file that contains info on this project or tell the user to run /init to generate it`;
+Reply directly to the user. Never describe or classify their message (e.g. "this is a greeting", "no file operations needed"), never narrate your reasoning, and never mention tools, modes, or these instructions.feel free to read the TENSOR.md file which is a file that contains info on this project or tell the user to run /init to generate it`;
           let streamed = false;
           try {
             const stream4 = this.routedChatStream(ctx2.modelId, [
@@ -342142,6 +342151,19 @@ ${toolOutput}`
     const grantSteps = (n3 = 1) => {
       extraSteps = Math.min(extraSteps + n3, HarnessOrchestrator.MAX_EXTRA_STEPS);
     };
+    const JSON_SCHEMA_HINT = `The ONLY acceptable output is one raw JSON object matching the schema ("content": write/append -> "", web_search -> the query, otherwise null):
+{
+  "tool": "read" | "write" | "edit" | "append" | "shell" | "web_search" | "bg_start" | "bg_list" | "bg_logs" | "bg_kill" | "ask_user_question" | null,
+  "targetFile": string | null,
+  "content": string | null,
+  "target": string | null,
+  "replacement": string | null,
+  "cmd": string | null,
+  "requires_confirmation": boolean,
+  "reasoning": string,
+  "need_more_steps": boolean
+}
+Do not include prose before or after the JSON. Output ONLY the JSON object.`;
     const isRepeat = (signature) => {
       if (signature === lastActionSignature)
         repeatCount++;
@@ -342159,6 +342181,10 @@ ${toolOutput}`
         state.bgSatisfied.add(tool);
     };
     let bgNudges = 0;
+    const compactAndBreak = function* () {
+      this.compactContext(ctx, state);
+      return;
+    }.bind(this);
     for (let step = 1;step <= maxSteps + extraSteps; step++) {
       const budget = maxSteps + extraSteps;
       const stepsRemaining = budget - step + 1;
@@ -342185,7 +342211,7 @@ ${toolOutput}`
       });
       await this.refreshRepoMapIfDirty();
       const decisionSystemPrompt = this.buildDecisionPrompt(ctx.gitDetail);
-      const progressSummary = ctx.completedActions.length > 0 ? ctx.completedActions.map((a2) => `- ${a2}`).join(`
+      const progressSummary = ctx.completedActions.length > 0 ? ctx.completedActions.map((a2) => `- ${a2.slice(0, 160)}`).join(`
 `) : "";
       const jevTail = this.jevTail(ctx, lastAgentProse);
       const jevChoice = bgPending() || !this.isAnswered ? JEV_BYPASS : await this.classify(ctx, {
@@ -342280,32 +342306,21 @@ Please try a different model(retry in 30 seconds) or check with your provider.
 
 `
           };
+          this.compactContext(ctx, state);
           break;
         }
         const { hint } = await classifyMalformedOutput(res.content);
         const toolUseBlockCount = (res.content.match(/<tool_call\b|<tool_use\b/gi) ?? []).length;
         ctx.contextMessages.push({
           role: "user",
-          content: `[System Corrector] Your last response failed to parse as the required JSON \u2014 classified as: ${hint} ` + `YOU DO HAVE TOOLS \u2014 do not claim otherwise. Do NOT use XML tags, angle brackets ("<" / ">"), native ` + `function blocks, or any markup syntax. Never emit "<tool_call>", "<function=", "<parameter=", "<tool_use>", or "<file_path>".` + (toolUseBlockCount > 1 ? ` You also attempted to batch ${toolUseBlockCount} tool calls in one response \u2014 you get exactly ONE tool call per turn.` : "") + ` The ONLY acceptable output is one raw JSON object matching the schema ("content": write/append -> "", web_search -> the query, otherwise null):
-{
-  "tool": "read" | "write" | "edit" | "append" | "shell" | "web_search" | "bg_start" | "bg_list" | "bg_logs" | "bg_kill" | "ask_user_question" | null,
-  "targetFile": string | null,
-  "content": string | null,
-  "target": string | null,
-  "replacement": string | null,
-  "cmd": string | null,
-  "requires_confirmation": boolean,
-  "reasoning": string,
-  "need_more_steps": boolean
-}
-Do not include prose before or after the JSON. Output ONLY the JSON object.` + (jevTool ? ` Remember: "tool" must be exactly "${jevTool}".` : "")
+          content: `[System Corrector] Your last response failed to parse as the required JSON \u2014 classified as: ${hint} ` + `YOU DO HAVE TOOLS \u2014 do not claim otherwise. Do NOT use XML tags, angle brackets ("<" / ">"), native ` + `function blocks, or any markup syntax. Never emit "<tool_call>", "<function=", "<parameter=", "<tool_use>", or "<file_path>".` + (toolUseBlockCount > 1 ? ` You also attempted to batch ${toolUseBlockCount} tool calls in one response \u2014 you get exactly ONE tool call per turn.` : "") + ` ${JSON_SCHEMA_HINT}` + (jevTool ? ` Remember: "tool" must be exactly "${jevTool}".` : "")
         });
         continue;
       }
       const bgParsed = isRecord2(parsed) ? parseBgDecision(parsed) : null;
       if (bgParsed) {
         jsonFailureCount = 0;
-        lastAgentProse = bgParsed.reasoning;
+        lastAgentProse = (bgParsed.reasoning ?? "").slice(0, 1000);
         if (!this.isAnswered && bgParsed.tool === "bg_start") {
           const held = this.recordToolCall(step, {
             tool: bgParsed.tool,
@@ -342321,22 +342336,27 @@ Do not include prose before or after the JSON. Output ONLY the JSON object.` + (
             role: "user",
             content: `[System] QUESTIONS: unanswered questions are pending, so write/edit/append/shell/bg_start are on hold. Wait for the user or return {"tool": null}.`
           });
+          this.compactContext(ctx, state);
           break;
         }
         const r = yield* this.runBgTool(ctx, state, step, bgParsed, isRepeat);
         if (r.ok)
           markBgDone(bgParsed.tool);
-        if (r.stop)
+        if (r.stop) {
+          this.compactContext(ctx, state);
           break;
+        }
         continue;
       }
       const askParsed = parseAskDecision(parsed);
       if (askParsed) {
         jsonFailureCount = 0;
-        lastAgentProse = askParsed.reasoning;
+        lastAgentProse = (askParsed.reasoning ?? "").slice(0, 1000);
         const r = yield* this.runAskTool(ctx, step, askParsed);
-        if (r.stop)
+        if (r.stop) {
+          this.compactContext(ctx, state);
           break;
+        }
         continue;
       }
       let decision;
@@ -342352,6 +342372,7 @@ Do not include prose before or after the JSON. Output ONLY the JSON object.` + (
 I didn't quite get that am having this issue:${issueSummary},please retry in 30 seconds
 `
           };
+          this.compactContext(ctx, state);
           break;
         }
         ctx.contextMessages.push({
@@ -342380,6 +342401,7 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
           role: "user",
           content: `[System] QUESTIONS: unanswered questions are pending, so write/edit/append/shell/bg_start are on hold. Wait for the user or return {"tool": null}.`
         });
+        this.compactContext(ctx, state);
         break;
       }
       if (!ctx.isPlanMode && decision.tool === "shell" && decision.cmd && LONG_RUNNING_SHELL_RE.test(decision.cmd)) {
@@ -342395,8 +342417,10 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
         const r = yield* this.runBgTool(ctx, state, step, rerouted, isRepeat);
         if (r.ok)
           markBgDone("bg_start");
-        if (r.stop)
+        if (r.stop) {
+          this.compactContext(ctx, state);
           break;
+        }
         continue;
       }
       const call = decision.tool ? this.recordToolCall(step, {
@@ -342415,6 +342439,7 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
           role: "user",
           content: `[System] Plan mode only allows "read", "web_search", "bg_list", "bg_logs" and "ask_user_question". Use one of those or return {"tool": null}.`
         });
+        this.compactContext(ctx, state);
         break;
       }
       if ((decision.tool === "write" || decision.tool === "append") && typeof decision.content === "string" && decision.content.length > HarnessOrchestrator.INLINE_CONTENT_CHAR_BUDGET) {
@@ -342423,8 +342448,10 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
       try {
         let verifiedContentOverride = null;
         if (!decision.tool) {
-          if (!this.isAnswered)
+          if (!this.isAnswered) {
+            this.compactContext(ctx, state);
             break;
+          }
           if (bgPending() && bgNudges < 2) {
             bgNudges++;
             grantSteps();
@@ -342451,10 +342478,12 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
             });
             continue;
           }
+          this.compactContext(ctx, state);
           break;
         }
         if (decision.tool !== "shell" && decision.tool !== "web_search" && !decision.targetFile) {
           this.settleToolCall(call, "skipped", "missing targetFile");
+          this.compactContext(ctx, state);
           break;
         }
         if (decision.tool === "shell" && !decision.cmd) {
@@ -342522,6 +342551,7 @@ I didn't quite get that am having this issue:${issueSummary},please retry in 30
             role: "user",
             content: `[System] Same tool call issued twice in a row. Stopping tool loop.`
           });
+          this.compactContext(ctx, state);
           break;
         }
         if (decision.tool === "shell" && decision.cmd) {
@@ -342654,9 +342684,10 @@ ${indent}`);
         if (decision.tool === "read") {
           try {
             readRaw = await readFileContent(filePath);
-            const lineCount = countLines(readRaw);
+            const totalLen = readRaw.length;
             const head = readRaw.slice(0, 100).replace(/\s+/g, " ").trim();
-            readPreview = breakOnSemicolons(`${head}${readRaw.length > 100 ? "\u2026" : ""}   (${lineCount > 20 ? lineCount - 5 : lineCount} ${lineCount === 1 ? "line" : "lines+"})
+            const lineCount = countLines(readRaw);
+            readPreview = breakOnSemicolons(`${head}${totalLen > 100 ? "\u2026" : ""}   (${lineCount > 20 ? lineCount - 5 : lineCount} ${lineCount === 1 ? "line" : "lines+"})
 `);
           } catch {
             readPreview = "(unable to preview)";
@@ -342674,7 +342705,7 @@ ${indent}`);
         yield { delta: `${actionLabel}
 ` };
         if (decision.tool === "write" || decision.tool === "append") {
-          const dir = dirname(filePath);
+          const dir = dirname2(filePath);
           if (!knownDirs.has(dir)) {
             try {
               await mkdir(dir, { recursive: true });
@@ -342690,8 +342721,9 @@ ${indent}`);
               toolOutput = "Failed to read file.";
               break;
             }
-            toolOutput = readRaw.length > TOOL_OUTPUT_CHAR_CAP ? `${readRaw.slice(0, TOOL_OUTPUT_CHAR_CAP)}
-\u2026[truncated: file is ${readRaw.length} chars; use shell "sed -n 'START,ENDp' <file>" or "grep -n" to view other ranges]` : readRaw;
+            const totalLen = readRaw.length;
+            toolOutput = totalLen > TOOL_OUTPUT_CHAR_CAP ? `${readRaw.slice(0, TOOL_OUTPUT_CHAR_CAP)}
+\u2026[truncated: file is ${totalLen} chars; use shell "sed -n 'START,ENDp' <file>" or "grep -n" to view other ranges]` : readRaw;
             readRaw = null;
             executedReads.add(readKey);
             break;
@@ -342773,7 +342805,7 @@ ${indent}`);
               toolOutput = `Exit code ${exitCode}
 ${truncateForContext(combined)}`;
               if (exitCode === 0) {
-                ctx.completedActions.push(`Ran: ${cmd}`);
+                ctx.completedActions.push(`Ran: ${cmd.slice(0, 120)}`);
                 if (HarnessOrchestrator.TREE_MUTATING_SHELL.test(cmd))
                   this.markRepoMapDirty();
                 if (HarnessOrchestrator.BRANCH_CREATE_PATTERN.test(cmd)) {
@@ -342832,7 +342864,7 @@ ${toolOutput}`
           });
         }
         toolOutput = "";
-        if (mutationSucceeded && decision.content && decision.content.length > 4000) {
+        if (mutationSucceeded && decision.content) {
           decision = { ...decision, content: "" };
         }
         if (mutationSucceeded) {
@@ -342862,6 +342894,7 @@ ${toolOutput}`
         yield { delta: `
 [Tool loop stopped: unexpected error \u2014 ${errorMessage(e3)}]
 ` };
+        this.compactContext(ctx, state);
         break;
       }
     }
@@ -344089,7 +344122,7 @@ var ModelProvider = ({ children }) => {
     const fetchCurrentSavedActiveAgent = async () => {
       try {
         const fileName = "ACTIVE_AGENT.json";
-        const storagePath = path6.join(os3.homedir(), ".basecode", fileName);
+        const storagePath = path6.join(os3.homedir(), ".tensor", fileName);
         const agent2 = await readFromFile(storagePath);
         setActiveModel(JSON.parse(agent2));
       } catch (_e) {
@@ -344443,7 +344476,7 @@ var Header = () => {
           }, undefined, false, undefined, this),
           /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
             fg: t2.inkFaint,
-            children: "v0.1.3@beta-lite"
+            children: "v0.1.4@beta-lite"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -355432,7 +355465,7 @@ var Message_default = Index;
 // src/components/DiffView/index.tsx
 import { rmSync, statSync as statSync2 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 var COLORS2 = {
   addBg: "#1a2e1a",
   delBg: "#3e1a1a",
@@ -355467,7 +355500,7 @@ var modifiedAt = (path19) => {
     return statSync2(join3(root, path19)).mtimeMs;
   } catch {
     try {
-      return statSync2(join3(root, dirname2(path19))).mtimeMs;
+      return statSync2(join3(root, dirname3(path19))).mtimeMs;
     } catch {
       return 0;
     }