@livx.cc/agentx 0.99.46 → 0.99.48

package/dist/cli.js

@@ -1509,6 +1509,394 @@ var init_tools = __esm({
   }
 });
 
+// src/tools.jobs.ts
+function formatJobNotice(n) {
+  return `[job ${n.id} ${n.status}${n.reason ? `: ${n.reason}` : ""}] ${n.kind}${n.label ? ` \`${n.label}\`` : ""}
+` + (n.tail ? `${n.tail.replace(/\n+$/, "")}
+` : "(no output)\n") + `Read the full output with JobOutput({id:"${n.id}"}).`;
+}
+function makeJobTools(registry, opts = {}) {
+  const maxWaitMs = opts.maxWaitMs ?? 12e4;
+  return [
+    {
+      name: "JobOutput",
+      description: "Read a job's output by id. Without `offset`: the buffered tail. With `offset` (the `next` value from a previous read): only what arrived since.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" }, offset: { type: "number", description: "return output after this position (from a previous read's `next`)" } } },
+      async run({ id, offset }) {
+        const r = registry.read(String(id), Number(offset) || 0);
+        if (!r) return NO_JOB(String(id));
+        const st = registry.status(String(id));
+        return `[${st.status}${st.reason ? `: ${st.reason}` : ""}] next=${r.next}${r.truncated ? " (older output dropped)" : ""}
+${r.text.replace(/\n+$/, "") || "(no new output)"}`;
+      }
+    },
+    {
+      name: "JobStatus",
+      description: "Status of a job (running/done/error/killed, age, last activity). Omit `id` to list all jobs.",
+      parameters: { type: "object", properties: { id: { type: "string" } } },
+      async run({ id }) {
+        const now4 = registry.options.now();
+        if (!id) {
+          const all = registry.list();
+          return all.length ? all.map((j2) => describe(j2, now4)).join("\n") : "(no background jobs)";
+        }
+        const j = registry.get(String(id));
+        return j ? describe(j, now4) : NO_JOB(String(id));
+      }
+    },
+    {
+      name: "JobKill",
+      description: "Stop a running job by id (sandbox jobs are cancelled without committing; processes get SIGTERM; MCP calls are cancelled).",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return registry.kill(String(id), "killed by JobKill") ? `Killed job ${id}.` : NO_JOB(String(id));
+      }
+    },
+    {
+      name: "JobWait",
+      description: `Block until a job finishes or \`timeoutMs\` passes (max ${maxWaitMs}ms), then return its status and output tail. Prefer this over sleeping.`,
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" }, timeoutMs: { type: "number" } } },
+      async run({ id, timeoutMs }) {
+        const j = await registry.wait(String(id), Math.min(Number(timeoutMs) || maxWaitMs, maxWaitMs));
+        if (!j) return NO_JOB(String(id));
+        const tail = (registry.output(j.id) ?? "").slice(-4e3).replace(/\n+$/, "");
+        return `${describe(j, registry.options.now())}
+${tail || "(no output)"}`;
+      }
+    }
+  ];
+}
+var log5, JobRegistryOptions, secs, JobRegistry, NO_JOB, describe;
+var init_tools_jobs = __esm({
+  "src/tools.jobs.ts"() {
+    "use strict";
+    init_logging();
+    log5 = forComponent("jobs");
+    JobRegistryOptions = class {
+      /** Tail buffer cap per job (chars). */
+      maxBuffer = 256 * 1024;
+      /** Idle window per kind: no output/progress/CPU for this long ⇒ stuck. Kinds without an activity channel
+       *  (host, native) are absent on purpose — silence is all they can ever show, so it proves nothing; their
+       *  bound is the hard cap. Explicit `background:true` shell jobs opt out per job (a quiet server is healthy). */
+      idleMs = { shell: 10 * 6e4, mcp: 10 * 6e4 };
+      /** Absolute ceiling per kind (0/absent = none). */
+      hardCapMs = { mcp: 30 * 6e4 };
+      /** Soft foreground timeout per kind: past it the caller stops waiting and gets a job id instead. */
+      foregroundMs = { mcp: 3e4 };
+      /** How often the reaper runs while reapable jobs exist. */
+      sweepMs = 15e3;
+      /** Grace between the kill signal and a forced kill (producers that escalate read this). */
+      killGraceMs = 5e3;
+      /** Finished jobs kept for inspection; older finished ones are pruned (every delegated tool call is a job). */
+      keepFinished = 200;
+      /** Clock (injectable for tests). Late-bound so a patched Date.now is honoured. */
+      now = () => Date.now();
+      /** Terminal-state notification for jobs with `notify` (the Agent wires this to `inject`). */
+      onExit;
+    };
+    secs = (ms) => `${Math.round(ms / 1e3)}s`;
+    JobRegistry = class {
+      options;
+      jobs = /* @__PURE__ */ new Map();
+      seq = 0;
+      timer;
+      constructor(options) {
+        this.options = { ...new JobRegistryOptions(), ...options };
+      }
+      /** Register externally-driven work (a process, a request, a native tool) and get a handle to feed it. */
+      track(opts = {}) {
+        const o = this.options;
+        const kind = opts.kind ?? "task";
+        const now4 = o.now();
+        let settle;
+        const done = new Promise((r) => {
+          settle = r;
+        });
+        const job = {
+          id: `job-${++this.seq}`,
+          kind,
+          label: opts.label ?? "",
+          status: "running",
+          startedAt: now4,
+          lastActivityAt: now4,
+          bytes: 0,
+          holds: !!opts.holds,
+          buf: "",
+          dropped: 0,
+          idleMs: opts.idleMs ?? o.idleMs[kind] ?? 0,
+          hardCapMs: opts.hardCapMs ?? o.hardCapMs[kind] ?? 0,
+          drain: !!opts.drain,
+          notify: !!opts.notify,
+          idleAfterActivity: !!opts.idleAfterActivity,
+          active: false,
+          cpuTime: opts.cpuTime,
+          onKill: opts.onKill,
+          onExit: opts.onExit,
+          done,
+          settle
+        };
+        this.jobs.set(job.id, job);
+        if (opts.seed) this.append(job, opts.seed);
+        this.arm();
+        return {
+          id: job.id,
+          chunk: (s) => {
+            if (s) {
+              this.append(job, s);
+              job.lastActivityAt = o.now();
+              job.active = true;
+            }
+          },
+          touch: () => {
+            job.lastActivityAt = o.now();
+            job.active = true;
+          },
+          finish: (status, result, reason) => this.end(job, status, result, reason),
+          detach: () => {
+            job.holds = false;
+            job.notify = true;
+            job.drain = true;
+          },
+          get status() {
+            return job.status;
+          }
+        };
+      }
+      /** Start `fn` in the background and return a job id immediately (sandbox/subagent semantics: drained at turn end). */
+      start(fn, opts = {}) {
+        return this.run(fn, { drain: true, ...opts }).handle.id;
+      }
+      /**
+       * Run `fn` in the FOREGROUND with a soft timeout: resolves `{done:true,value}` if it settles in time, else
+       * `{done:false,id}` — the work keeps going as a detached job whose completion is reported via `onExit`.
+       * A rejection before the timeout is rethrown (the caller's normal error path). `softTimeoutMs` ≤ 0 waits forever.
+       */
+      async runForeground(fn, opts = {}) {
+        const { handle, promise } = this.run(fn, opts);
+        const soft = opts.softTimeoutMs ?? this.options.foregroundMs[opts.kind ?? "task"] ?? 0;
+        let t;
+        const late = soft > 0 ? new Promise((r) => {
+          t = setTimeout(() => r("late"), soft);
+        }) : new Promise(() => {
+        });
+        try {
+          const r = await Promise.race([promise.then((v) => ({ v }), (e) => ({ e })), late]);
+          if (r !== "late" && handle.status !== "running") this.jobs.delete(handle.id);
+          if (r === "late") {
+            if (handle.status === "running") {
+              handle.detach();
+              return { done: false, id: handle.id };
+            }
+            const settled = await promise.then((v) => ({ v }), (e) => ({ e }));
+            if ("e" in settled) throw settled.e;
+            return { done: true, value: settled.v };
+          }
+          if ("e" in r) throw r.e;
+          return { done: true, value: r.v };
+        } finally {
+          if (t) clearTimeout(t);
+        }
+      }
+      run(fn, opts) {
+        const ctl = new AbortController();
+        const handle = this.track({ ...opts, onKill: (reason) => {
+          ctl.abort(Object.assign(new Error(reason), { name: "AbortError", code: "job_killed" }));
+          opts.onKill?.(reason);
+        } });
+        let promise;
+        try {
+          promise = fn({ signal: ctl.signal, onChunk: handle.chunk, touch: handle.touch });
+        } catch (e) {
+          promise = Promise.reject(e);
+        }
+        promise.then(
+          (res) => {
+            if (handle.status === "running" && typeof res === "string" && res) handle.chunk(res);
+            handle.finish("done", res);
+          },
+          (e) => {
+            if (handle.status === "running") handle.chunk(`
+[error] ${e?.message ?? e}`);
+            handle.finish("error", void 0, e?.message ?? String(e));
+          }
+        );
+        return { handle, promise };
+      }
+      append(job, s) {
+        job.buf += s;
+        const over = job.buf.length - this.options.maxBuffer;
+        if (over > 0) {
+          job.buf = job.buf.slice(over);
+          job.dropped += over;
+        }
+        job.bytes = job.buf.length;
+      }
+      end(job, status, result, reason) {
+        if (job.status !== "running") return;
+        job.status = status;
+        job.endedAt = this.options.now();
+        job.result = result;
+        if (reason && status !== "done") job.reason = reason;
+        job.holds = false;
+        job.settle();
+        this.prune();
+        const onExit = job.onExit ?? this.options.onExit;
+        if (job.notify && onExit) {
+          try {
+            onExit({ id: job.id, kind: job.kind, label: job.label, status, reason: job.reason, tail: job.buf.slice(-4e3), result });
+          } catch (e) {
+            log5.warn(`job onExit handler threw for ${job.id}: ${e}`);
+          }
+        }
+      }
+      prune() {
+        const finished = [...this.jobs.values()].filter((j) => j.status !== "running");
+        for (const j of finished.slice(0, Math.max(0, finished.length - this.options.keepFinished))) this.jobs.delete(j.id);
+      }
+      /** Current tail output (null = no such job). */
+      output(id) {
+        return this.jobs.get(id)?.buf ?? null;
+      }
+      /** Incremental read: output from absolute char `offset` (clamped to what the ring still holds). */
+      read(id, offset = 0) {
+        const j = this.jobs.get(id);
+        if (!j) return null;
+        const start = Math.max(0, offset - j.dropped);
+        return { text: j.buf.slice(start), next: j.dropped + j.buf.length, truncated: offset < j.dropped };
+      }
+      get(id) {
+        const j = this.jobs.get(id);
+        return j ? this.info(j) : null;
+      }
+      status(id) {
+        const j = this.jobs.get(id);
+        return j ? { status: j.status, bytes: j.bytes, ...j.reason ? { reason: j.reason } : {} } : null;
+      }
+      list() {
+        return [...this.jobs.values()].map((j) => this.info(j));
+      }
+      info(j) {
+        const { id, kind, label, status, startedAt, lastActivityAt, endedAt, reason, bytes, holds, result } = j;
+        return { id, kind, label, status, startedAt, lastActivityAt, endedAt, reason, bytes, holds, result };
+      }
+      /** Wait (bounded) for a job to settle. Resolves the job's info either way; null for an unknown id. */
+      async wait(id, timeoutMs) {
+        const j = this.jobs.get(id);
+        if (!j) return null;
+        let t;
+        await Promise.race([j.done, new Promise((r) => {
+          t = setTimeout(r, Math.max(0, timeoutMs));
+        })]);
+        if (t) clearTimeout(t);
+        return this.info(j);
+      }
+      /** Stop a job: runs its `onKill` (abort/SIGTERM) and marks it killed with `reason`. */
+      kill(id, reason = "killed by request") {
+        const j = this.jobs.get(id);
+        if (!j) return false;
+        if (j.status === "running") {
+          this.end(j, "killed", void 0, reason);
+          try {
+            j.onKill?.(reason);
+          } catch (e) {
+            log5.warn(`onKill for ${id} threw: ${e}`);
+          }
+        }
+        return true;
+      }
+      /** Kill every running job — or, with `onlyDrainable`, only turn-scoped ones (sandbox/sub-agent/handed-off MCP),
+       *  leaving jobs meant to outlive a run (a background dev server) alone. */
+      killAll(reason = "run ended", onlyDrainable = false) {
+        for (const j of this.jobs.values()) if (!onlyDrainable || j.drain) this.kill(j.id, reason);
+      }
+      /** Jobs something is synchronously waiting on (see `JobTrackOptions.holds`) that are still running. */
+      holding() {
+        return [...this.jobs.values()].filter((j) => j.status === "running" && j.holds).map((j) => this.info(j));
+      }
+      /** Await every drainable running job (turn end). Returns the ids that were still running when drain began. */
+      async drain(signal) {
+        const pending = [...this.jobs.values()].filter((j) => j.status === "running" && j.drain);
+        const all = Promise.all(pending.map((j) => j.done));
+        await (signal ? Promise.race([all, new Promise((r) => signal.aborted ? r() : signal.addEventListener("abort", () => r(), { once: true }))]) : all);
+        return pending.map((j) => j.id);
+      }
+      /**
+       * The stuck-job decision, synchronous part: kill every running job past its hard cap, or past its idle
+       * window when it has no CPU probe to argue otherwise. Cheap — the stall watchdog calls it on every tick.
+       * Returns the killed ids. Jobs WITH a probe are left to `sweep()`.
+       */
+      reap() {
+        const now4 = this.options.now();
+        const killed = [];
+        for (const j of this.jobs.values()) {
+          if (j.status !== "running") continue;
+          const verdict = this.verdict(j, now4);
+          if (!verdict || verdict.idle && j.cpuTime) continue;
+          this.stuck(j, verdict.reason, now4);
+          killed.push(j.id);
+        }
+        return killed;
+      }
+      /** Full sweep: sample CPU probes (advancing CPU = activity), then `reap()` including probed jobs. */
+      async sweep() {
+        const now4 = this.options.now();
+        for (const j of [...this.jobs.values()]) {
+          if (j.status !== "running" || !j.cpuTime || !j.idleMs) continue;
+          let cpu;
+          try {
+            cpu = await j.cpuTime();
+          } catch (e) {
+            log5.debug(`cpu probe for ${j.id} failed: ${e}`);
+          }
+          if (cpu != null && j.lastCpu != null && cpu > j.lastCpu) j.lastActivityAt = this.options.now();
+          const prev = j.lastCpu;
+          if (cpu != null) j.lastCpu = cpu;
+          const verdict = this.verdict(j, now4);
+          if (!verdict?.idle || j.status !== "running") continue;
+          if (cpu == null) {
+            log5.debug(`not reaping ${j.id}: ${verdict.reason} but CPU unknown`);
+            continue;
+          }
+          if (prev == null) continue;
+          this.stuck(j, `${verdict.reason}, no CPU progress (${prev}s \u2192 ${cpu}s)`, now4);
+        }
+        return this.reap();
+      }
+      verdict(j, now4) {
+        if (j.hardCapMs && now4 - j.startedAt >= j.hardCapMs) return { reason: `stuck: exceeded hard cap ${secs(j.hardCapMs)}`, idle: false };
+        if (j.idleMs && (!j.idleAfterActivity || j.active) && now4 - j.lastActivityAt >= j.idleMs) return { reason: `stuck: idle ${secs(now4 - j.lastActivityAt)}`, idle: true };
+        return null;
+      }
+      stuck(j, reason, now4) {
+        log5.warn(`reaping ${j.id} (${j.kind} "${j.label}"): ${reason} \u2014 age ${secs(now4 - j.startedAt)}, last activity ${secs(now4 - j.lastActivityAt)} ago, idleMs=${j.idleMs}, hardCapMs=${j.hardCapMs}, ${j.bytes} byte(s) output`);
+        if (j.onKill) j.notify = true;
+        this.kill(j.id, reason);
+      }
+      /** Keep a reaper interval alive only while a reapable job is running (unref'd: never holds the process open). */
+      arm() {
+        if (this.timer || !this.options.sweepMs) return;
+        this.timer = setInterval(() => {
+          const live = [...this.jobs.values()].some((j) => j.status === "running" && (j.idleMs || j.hardCapMs));
+          if (!live) {
+            clearInterval(this.timer);
+            this.timer = void 0;
+            return;
+          }
+          void this.sweep().catch((e) => log5.warn(`job sweep failed: ${e}`));
+        }, this.options.sweepMs);
+        this.timer.unref?.();
+      }
+      /** Stop the reaper timer (tests / teardown). */
+      dispose() {
+        if (this.timer) clearInterval(this.timer);
+        this.timer = void 0;
+      }
+    };
+    NO_JOB = (id) => `Error: no background job '${id}'. Use JobStatus with no id to list jobs.`;
+    describe = (j, now4) => `${j.id}  ${j.status}${j.reason ? ` (${j.reason})` : ""}  ${j.kind}${j.label ? "  " + j.label : ""}  \xB7 ${secs((j.endedAt ?? now4) - j.startedAt)} old \xB7 last activity ${secs(now4 - j.lastActivityAt)} ago \xB7 ${j.bytes} byte(s)`;
+  }
+});
+
 // src/worktree.ts
 var worktree_exports = {};
 __export(worktree_exports, {
@@ -2118,7 +2506,10 @@ __export(tools_shell_exports, {
   ShellJobRegistry: () => ShellJobRegistry,
   formatJobExit: () => formatJobExit,
   makeRealShellTool: () => makeRealShellTool,
-  makeShellJobTools: () => makeShellJobTools
+  makeShellJobTools: () => makeShellJobTools,
+  parsePsTime: () => parsePsTime,
+  psGroupCpuSeconds: () => psGroupCpuSeconds,
+  sumTreeCpu: () => sumTreeCpu
 });
 function killGroup(proc, signal) {
   if (!proc?.pid) return false;
@@ -2148,10 +2539,39 @@ async function nodeSpawn() {
   return _spawn;
 }
 function formatJobExit(n) {
-  return `[background job ${n.id} ${n.status}${n.exitCode != null ? ` exit ${n.exitCode}` : ""}] \`${n.command}\`
+  return `[background job ${n.id} ${n.status}${n.exitCode != null ? ` exit ${n.exitCode}` : ""}${n.reason ? `: ${n.reason}` : ""}] \`${n.command}\`
 ` + (n.tail ? `${n.tail}
 ` : "(no output)\n") + `Read the full output with ShellOutput({id:"${n.id}"}).`;
 }
+function parsePsTime(t) {
+  const m = t.trim().match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/);
+  if (!m) return void 0;
+  return Number(m[1] ?? 0) * 86400 + Number(m[2] ?? 0) * 3600 + Number(m[3]) * 60 + Number(m[4]);
+}
+async function psGroupCpuSeconds(pgid) {
+  try {
+    const { execFile: execFile4 } = await import("child_process");
+    const out = await new Promise((res, rej) => execFile4("ps", ["-A", "-o", "pid=,ppid=,pgid=,time="], { timeout: 5e3, env: { ...process.env, LC_ALL: "C" } }, (e, so) => e ? rej(e) : res(String(so))));
+    return sumTreeCpu(out, pgid);
+  } catch (e) {
+    log17.debug(`ps cpu probe failed for group ${pgid}: ${e}`);
+    return void 0;
+  }
+}
+function sumTreeCpu(psOut, root) {
+  const rows = psOut.split("\n").map((l) => l.trim().split(/\s+/)).filter((r) => r.length >= 4).map(([pid, ppid, pgid, time]) => ({ pid: Number(pid), ppid: Number(ppid), pgid: Number(pgid), sec: parsePsTime(time) }));
+  const inJob = new Set(rows.filter((r) => r.pgid === root || r.pid === root).map((r) => r.pid));
+  for (let grew = true; grew; ) {
+    grew = false;
+    for (const r of rows) if (!inJob.has(r.pid) && inJob.has(r.ppid)) {
+      inJob.add(r.pid);
+      grew = true;
+    }
+  }
+  let total;
+  for (const r of rows) if (inJob.has(r.pid) && r.sec != null) total = (total ?? 0) + r.sec;
+  return total;
+}
 function makeRealShellTool(options) {
   const defaultTimeoutMs = options.timeoutMs ?? 12e4;
   const maxTimeoutMs = Math.max(options.maxTimeoutMs ?? 6e5, defaultTimeoutMs);
@@ -2282,7 +2702,7 @@ function makeRealShellTool(options) {
           proc.stderr?.on("data", collect);
           proc.on("error", (err2) => {
             if (err2?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
-            log16.debug("shell spawn error", err2);
+            log17.debug("shell spawn error", err2);
             finish(`[exit 1] ${err2?.message ?? err2}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -2302,7 +2722,7 @@ function makeRealShellTool(options) {
   };
 }
 function handoffFor(timeoutMs, id, body, notifies) {
-  const head = `[still running] exceeded ${timeoutMs}ms, so it was handed to background job ${id} \u2014 NOT killed, it is still going. Check on it with ShellOutput({id:"${id}"}) / ShellStatus({id:"${id}"}), stop it with ShellKill({id:"${id}"}). ` + (notifies ? "Its completion will be reported to you, so you may continue with other work meanwhile." : "Nothing will tell you when it finishes \u2014 poll it yourself before you rely on its result.");
+  const head = `[still running] exceeded ${timeoutMs}ms, so it was handed to background job ${id} \u2014 NOT killed, it is still going (it is only stopped if it goes silent with no CPU activity for a long time, and then you are told why). Check on it with ShellOutput({id:"${id}"}) / ShellStatus({id:"${id}"}), stop it with ShellKill({id:"${id}"}). ` + (notifies ? "Its completion will be reported to you, so you may continue with other work meanwhile." : "Nothing will tell you when it finishes \u2014 poll it yourself before you rely on its result.");
   return body ? `${head}
 Output so far:
 ${body}` : head;
@@ -2326,7 +2746,7 @@ function makeShellJobTools(registry) {
         const out = registry.output(String(id));
         if (out == null) return NO_JOB2(String(id));
         const st = registry.status(String(id));
-        return `[${st.status}${st.exitCode != null ? ` exit ${st.exitCode}` : ""}]
+        return `[${st.status}${st.exitCode != null ? ` exit ${st.exitCode}` : ""}${st.reason ? `: ${st.reason}` : ""}]
 ${clean(out) || "(no output yet)"}`;
       }
     },
@@ -2341,13 +2761,13 @@ ${clean(out) || "(no output yet)"}`;
           return jobs.length ? jobs.map((j) => `${j.id}  ${j.status}  ${j.command}`).join("\n") : "(no background jobs)";
         }
         const st = registry.status(String(id));
-        return st ? `${st.status}${st.exitCode != null ? ` (exit ${st.exitCode})` : ""} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB2(String(id));
+        return st ? `${st.status}${st.exitCode != null ? ` (exit ${st.exitCode})` : ""}${st.reason ? ` \u2014 ${st.reason}` : ""} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB2(String(id));
       }
     },
     {
       ...dropOnRebind,
       name: "ShellKill",
-      description: "Stop a running background Shell job by id (SIGTERM).",
+      description: "Stop a running background Shell job by id (SIGTERM to its process group, SIGKILL if it ignores that).",
       parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
       async run({ id }) {
         return registry.kill(String(id)) ? `Killed job ${id}.` : NO_JOB2(String(id));
@@ -2355,7 +2775,7 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log16, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log17, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, shellStatus, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
@@ -2363,62 +2783,94 @@ var init_tools_shell = __esm({
     init_redact();
     init_logging();
     init_shell_sandbox();
-    log16 = forComponent("shell");
+    init_tools_jobs();
+    log17 = forComponent("shell");
     clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
     DETACHED = { stdio: ["ignore", "pipe", "pipe"], detached: true };
     SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
     ShellJobRegistry = class {
       constructor(cfg) {
         this.cfg = cfg;
+        this.jobs = cfg.jobs ?? new JobRegistry(cfg.maxBuffer ? { maxBuffer: cfg.maxBuffer } : {});
         if (cfg.killOnExit && typeof process !== "undefined") process.once("exit", () => this.killAll());
       }
       cfg;
-      jobs = /* @__PURE__ */ new Map();
-      seq = 0;
+      jobs;
+      meta = /* @__PURE__ */ new Map();
       async start(command) {
-        const id = `job-${++this.seq}`;
-        const max = this.cfg.maxBuffer ?? 256 * 1024;
-        const job = { command, buf: "", status: "running" };
-        const append = (chunk) => {
-          const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
-          job.buf = (job.buf + s).slice(-max);
-        };
+        const h = this.track(command, { idleMs: 0 });
         try {
           const spawn4 = this.cfg.spawn ?? await nodeSpawn();
           const argv = this.cfg.osSandbox ? await spawnArgvFor(command, this.cfg.cwd, this.cfg.osSandbox) : { bin: "/bin/sh", args: ["-c", command] };
-          const proc = spawn4(argv.bin, argv.args, { cwd: this.cfg.cwd, env: childEnv(this.cfg), ...DETACHED });
-          job.proc = proc;
-          proc.stdout?.on("data", append);
-          proc.stderr?.on("data", append);
-          proc.on("error", (err2) => {
-            if (job.status === "running") {
-              job.status = "error";
-              append(`
-[error] ${err2?.message ?? err2}`);
-              this.notifyExit(id, job);
-            }
-          });
-          proc.on("close", (code) => {
-            if (job.status === "running") {
-              job.status = "exited";
-              job.exitCode = code ?? void 0;
-              this.notifyExit(id, job);
-            }
-          });
+          this.attach(h, spawn4(argv.bin, argv.args, { cwd: this.cfg.cwd, env: childEnv(this.cfg), ...DETACHED }));
         } catch (e) {
-          job.status = "error";
-          job.buf = `failed to spawn: ${e?.message ?? e}`;
+          h.chunk(`failed to spawn: ${e?.message ?? e}`);
+          h.finish("error", void 0, e?.message ?? String(e));
         }
-        this.jobs.set(id, job);
-        return id;
-      }
-      /** Fire `onExit` at most once per job, with the tail so the model can act without a second round-trip. */
-      notified = /* @__PURE__ */ new Set();
-      notifyExit(id, job) {
-        if (this.notified.has(id) || !this.cfg.onExit) return;
-        this.notified.add(id);
+        return h.id;
+      }
+      track(command, extra) {
+        const meta = { command };
+        let id = "";
+        const h = this.jobs.track({
+          kind: "shell",
+          label: command,
+          seed: extra.seed,
+          idleMs: extra.idleMs,
+          cpuTime: extra.cpu ? async () => meta.proc?.pid ? (this.cfg.cpuTime ?? psGroupCpuSeconds)(meta.proc.pid) : void 0 : void 0,
+          onKill: () => this.signal(meta),
+          onExit: (n) => this.notifyExit(id, meta, n.status, n.reason),
+          notify: true
+        });
+        id = h.id;
+        this.meta.set(id, meta);
+        return h;
+      }
+      attach(h, proc) {
+        const meta = this.meta.get(h.id);
+        meta.proc = proc;
+        const append = (chunk) => h.chunk(typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "");
+        proc.stdout?.on("data", append);
+        proc.stderr?.on("data", append);
+        proc.on("error", (err2) => {
+          if (h.status === "running") {
+            append(`
+[error] ${err2?.message ?? err2}`);
+            h.finish("error", void 0, err2?.message ?? String(err2));
+          }
+        });
+        proc.on("close", (code) => {
+          if (h.status === "running") {
+            meta.exitCode = code ?? void 0;
+            h.finish("done");
+          }
+        });
+      }
+      /** SIGTERM the whole group (bg children are detached group leaders — /bin/sh alone would orphan a forked
+       *  server), then SIGKILL after the grace period if it is still there. Falls back to the pid for fakes. */
+      signal(meta) {
+        const proc = meta.proc;
+        if (!killGroup(proc, "SIGTERM")) {
+          try {
+            proc?.kill("SIGTERM");
+          } catch {
+          }
+        }
+        if (!proc?.pid) return;
+        let closed = false;
+        proc.on("close", () => {
+          closed = true;
+        });
+        const t = setTimeout(() => {
+          if (!closed) killGroup(proc, "SIGKILL");
+        }, this.jobs.options.killGraceMs);
+        t.unref?.();
+      }
+      /** Fire `onExit` at most once per job (the registry guarantees one terminal state), with the tail so the model can act without a second round-trip. */
+      notifyExit(id, meta, status, reason) {
+        if (!this.cfg.onExit || status === "killed" && !reason?.startsWith("stuck")) return;
         try {
-          this.cfg.onExit({ id, command: job.command, status: job.status, exitCode: job.exitCode, tail: clean(job.buf).slice(-4e3) });
+          this.cfg.onExit({ id, command: meta.command, status: shellStatus(status), exitCode: meta.exitCode, tail: clean(this.jobs.output(id) ?? "").slice(-4e3), ...reason && status !== "done" ? { reason } : {} });
         } catch {
         }
       }
@@ -2437,14 +2889,20 @@ var init_tools_shell = __esm({
       }
       /** Current tail output for a job (null = no such job). */
       output(id) {
-        return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
+        return this.meta.has(id) ? this.jobs.output(id) : null;
       }
+      // null too once the shared registry pruned it
       status(id) {
-        const j = this.jobs.get(id);
-        return j ? { status: j.status, exitCode: j.exitCode, bytes: j.buf.length } : null;
+        const m = this.meta.get(id);
+        const j = m && this.jobs.get(id);
+        if (!m || !j) {
+          this.meta.delete(id);
+          return null;
+        }
+        return { status: shellStatus(j.status), exitCode: m.exitCode, bytes: j.bytes, ...j.reason ? { reason: j.reason } : {} };
       }
       list() {
-        return [...this.jobs].map(([id, j]) => ({ id, command: j.command, status: j.status }));
+        return [...this.meta].filter(([id]) => this.jobs.get(id)).map(([id, m]) => ({ id, command: m.command, status: shellStatus(this.jobs.get(id).status) }));
       }
       /**
        * Take over an ALREADY-RUNNING child as a background job. A foreground command that outruns its
@@ -2452,53 +2910,22 @@ var init_tools_shell = __esm({
        * worse, a launcher that spawned its own detached worker leaves that worker running with nothing
        * tracking it. Adopting hands the model a handle instead: the command keeps going, its completion
        * is reported like any other job, and `seed` carries the output produced before the handoff.
+       * Unlike an explicit background job it IS liveness-checked (idle window + CPU probe): nobody asked for
+       * a long-lived process here, so one that goes silent and CPU-idle is stuck, not serving.
        */
       adopt(command, proc, seed = "") {
-        const id = `job-${++this.seq}`;
-        const max = this.cfg.maxBuffer ?? 256 * 1024;
-        const job = { command, buf: seed.slice(-max), status: "running", proc };
-        const append = (chunk) => {
-          const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
-          job.buf = (job.buf + s).slice(-max);
-        };
-        proc.stdout?.on("data", append);
-        proc.stderr?.on("data", append);
-        proc.on("error", (err2) => {
-          if (job.status === "running") {
-            job.status = "error";
-            append(`
-[error] ${err2?.message ?? err2}`);
-            this.notifyExit(id, job);
-          }
-        });
-        proc.on("close", (code) => {
-          if (job.status === "running") {
-            job.status = "exited";
-            job.exitCode = code ?? void 0;
-            this.notifyExit(id, job);
-          }
-        });
-        this.jobs.set(id, job);
-        return id;
+        const h = this.track(command, { seed, cpu: true });
+        this.attach(h, proc);
+        return h.id;
       }
-      kill(id) {
-        const j = this.jobs.get(id);
-        if (!j) return false;
-        if (j.status === "running") {
-          if (!killGroup(j.proc, "SIGTERM")) {
-            try {
-              j.proc?.kill("SIGTERM");
-            } catch {
-            }
-          }
-          j.status = "killed";
-        }
-        return true;
+      kill(id, reason = "killed by ShellKill") {
+        return this.meta.has(id) && this.jobs.kill(id, reason);
       }
       killAll() {
-        for (const id of this.jobs.keys()) this.kill(id);
+        for (const id of this.meta.keys()) this.jobs.kill(id, "agent exiting");
       }
     };
+    shellStatus = (s) => s === "done" ? "exited" : s === "running" ? "running" : s === "killed" ? "killed" : "error";
     NO_JOB2 = (id) => `Error: no background job '${id}'. Use ShellStatus with no id to list jobs, or start one with Shell({background:true}).`;
   }
 });
@@ -2580,111 +3007,7 @@ import { AIClient, listModels, listProviders, getProviderFromModel, getModelInfo
 // src/Agent.ts
 init_llm();
 init_tools();
-
-// src/tools.jobs.ts
-var SandboxJobRegistry = class {
-  constructor(maxBuffer = 256 * 1024) {
-    this.maxBuffer = maxBuffer;
-  }
-  maxBuffer;
-  jobs = /* @__PURE__ */ new Map();
-  seq = 0;
-  /** Start `fn` in the background and return a job id immediately (does not await completion). */
-  start(fn, opts = {}) {
-    const id = `job-${++this.seq}`;
-    const ctl = new AbortController();
-    const onChunk = (s) => {
-      job.buf = (job.buf + s).slice(-this.maxBuffer);
-    };
-    const job = { kind: opts.kind ?? "task", label: opts.label ?? "", status: "running", buf: "", ctl, promise: Promise.resolve() };
-    job.promise = fn({ signal: ctl.signal, onChunk }).then(
-      (res) => {
-        if (job.status === "running") {
-          job.status = "done";
-          if (res) onChunk(res);
-        }
-      },
-      (e) => {
-        if (job.status === "running") {
-          job.status = "error";
-          onChunk(`
-[error] ${e?.message ?? e}`);
-        }
-      }
-    );
-    this.jobs.set(id, job);
-    return id;
-  }
-  /** Tail output for a job (null = no such job, '' = job exists but no output yet). */
-  output(id) {
-    return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
-  }
-  status(id) {
-    const j = this.jobs.get(id);
-    return j ? { status: j.status, bytes: j.buf.length } : null;
-  }
-  list() {
-    return [...this.jobs].map(([id, j]) => ({ id, kind: j.kind, label: j.label, status: j.status }));
-  }
-  /** Signal cancel (the producer decides what abort means — e.g. skip the overlay commit). */
-  kill(id) {
-    const j = this.jobs.get(id);
-    if (!j) return false;
-    if (j.status === "running") {
-      j.ctl.abort();
-      j.status = "killed";
-    }
-    return true;
-  }
-  killAll() {
-    for (const id of this.jobs.keys()) this.kill(id);
-  }
-  /** Await every still-running job. Called at turn end so a job's committed writes aren't lost from view
-   *  just because the model didn't poll it. Returns the ids that were still running when drain began. */
-  async drain() {
-    const pending = [...this.jobs].filter(([, j]) => j.status === "running").map(([id]) => id);
-    await Promise.all([...this.jobs.values()].map((j) => j.promise));
-    return pending;
-  }
-};
-var NO_JOB = (id) => `Error: no background job '${id}'. Use JobStatus with no id to list jobs, or start one with bash({background:true}).`;
-function makeJobTools(registry) {
-  return [
-    {
-      name: "JobOutput",
-      description: "Read the accumulated output (tail) of a background job by id (from bash({background:true})).",
-      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
-      async run({ id }) {
-        const out = registry.output(String(id));
-        if (out == null) return NO_JOB(String(id));
-        const st = registry.status(String(id));
-        return `[${st.status}]
-${out.replace(/\n+$/, "") || "(no output yet)"}`;
-      }
-    },
-    {
-      name: "JobStatus",
-      description: "Status of a background job (running/done/killed/error). Omit `id` to list all jobs.",
-      parameters: { type: "object", properties: { id: { type: "string" } } },
-      async run({ id }) {
-        if (!id) {
-          const jobs = registry.list();
-          return jobs.length ? jobs.map((j) => `${j.id}  ${j.status}  ${j.kind}${j.label ? "  " + j.label : ""}`).join("\n") : "(no background jobs)";
-        }
-        const st = registry.status(String(id));
-        return st ? `${st.status} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB(String(id));
-      }
-    },
-    {
-      name: "JobKill",
-      description: "Stop a running background job by id (the job is cancelled; its overlay writes are NOT committed).",
-      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
-      async run({ id }) {
-        return registry.kill(String(id)) ? `Killed job ${id}.` : NO_JOB(String(id));
-      }
-    }
-  ];
-}
+init_tools_jobs();
 
 // src/host.ts
 var askUserQuestionTool = {
@@ -3243,7 +3566,7 @@ init_OverlayFilesystem();
 init_worktree();
 init_NodeDiskFilesystem();
 init_logging();
-var log5 = forComponent("subagent");
+var log6 = forComponent("subagent");
 async function boundedPool(items, limit, fn) {
   const out = new Array(items.length);
   let next = 0;
@@ -3317,7 +3640,7 @@ function traceFileFor(dir, label, depth) {
     const id = `${Date.now().toString(36)}-${(traceSeq++).toString(36)}`;
     return join4(dir, `${id}-d${depth}-${sanitizeSlug(label) || "sub"}.json`);
   } catch (e) {
-    log5.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
+    log6.warn(`subagent trace dir unavailable (${dir}) \u2014 running without a trace: ${e instanceof Error ? e.message : String(e)}`);
     return void 0;
   }
 }
@@ -3325,7 +3648,7 @@ function flushTrace(file, meta, messages, status) {
   try {
     writeFileSync2(file, JSON.stringify({ ...meta, status, updated: Date.now(), messages }, null, 2));
   } catch (e) {
-    log5.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
+    log6.warn(`subagent trace flush failed (${file}): ${e instanceof Error ? e.message : String(e)}`);
   }
 }
 function installTrace(child, file, meta) {
@@ -3366,7 +3689,7 @@ async function runChildTraced(args) {
   if (file) flushTrace(file, meta, child.transcript, wc.timedOut() ? "deadline" : res.finishReason);
   let result = res.finishReason === "stop" ? res.text || `(child '${label}' finished with no summary; finishReason=${res.finishReason})` : abortHint(label, res, file);
   if (wc.timedOut()) {
-    log5.warn(`sub-task '${label}' hit its ${deadlineMs}ms wall-clock deadline (steps=${res.steps})`);
+    log6.warn(`sub-task '${label}' hit its ${deadlineMs}ms wall-clock deadline (steps=${res.steps})`);
     result += deadlineNote(deadlineMs);
   }
   await opts.hooks?.onSubagentStop?.(result, { label, agentType });
@@ -3820,7 +4143,7 @@ function reasoningToChatFragment(model, effort) {
 }
 
 // src/Agent.ts
-var log6 = forComponent("Agent");
+var log7 = forComponent("Agent");
 function envInt(key, fallback) {
   const n = typeof process !== "undefined" ? Number(process.env?.[key]) : NaN;
   return Number.isFinite(n) && n >= 0 ? n : fallback;
@@ -3972,6 +4295,12 @@ var AgentOptions = class {
   /** Enable `bash({background:true})` + JobOutput/JobStatus/JobKill — sandbox background jobs (overlay-isolated,
    *  committed on completion, drained at turn end). Useful when the VFS backend is slow (remote) or for sub-agents. */
   backgroundJobs = false;
+  /** The job registry every long-lived tool call lives in (MCP calls past their soft timeout, delegated host/native
+   *  tools, and — when the host shares it with its `ShellJobRegistry` — shell jobs). Its liveness is what the stall
+   *  watchdog and the stuck-job reaper decide from. Default: a fresh registry per Agent. Knobs (idle windows, hard
+   *  caps, MCP soft timeout) live on `JobRegistryOptions`. Completion notices reach the model via `inject` unless
+   *  the host set its own `onExit`. */
+  jobs;
   /** Plan mode: block mutating tools until the agent calls `ExitPlanMode` (host-approved). */
   planMode = false;
   /** Permission policy gating each tool call (allow / ask / deny). */
@@ -4038,12 +4367,18 @@ var Agent = class _Agent {
   /** Per-run ground truth: every tool name actually INVOKED this run (native dispatch + delegated
    *  runtime activity). The ledger that makes a fabricated tool claim provable. Reset per run. */
   invokedTools = /* @__PURE__ */ new Set();
-  /** Delegated-runtime HOST tools currently executing (cursor toolExecutor). While > 0 the provider is
-   *  not silent — it is waiting on US — so the idle-stall watchdog must not fire (see armStallWatchdog). */
-  hostToolsInFlight = 0;
-  /** The hold is bounded by the transport tool deadline: a host tool that never settles (the helper already gave
-   *  up on it) must not disable stall protection for the rest of the request — or this instance. */
-  hostToolHoldUntil = 0;
+  /** Every long-lived tool call is a job here (see AgentOptions.jobs). Delegated-runtime HOST tools (cursor
+   *  toolExecutor) and NATIVE tools (cursor's own shell/mcp/task, `running` → `completed`) are tracked as
+   *  `holds` jobs: while one runs the provider is not silent — it is waiting on a tool — so the idle-stall
+   *  watchdog must not fire. Each is bounded by the transport tool deadline (`hardCapMs = toolHoldMs`), so a
+   *  tool that never settles (or a lost `completed` event) is reaped and cannot disable stall protection. */
+  jobs;
+  /** Native delegated tool activity id → its job (per step attempt). */
+  nativeJobs = /* @__PURE__ */ new Map();
+  toolHoldMs = 0;
+  /** A tool (host or native) already executed in the current step attempt: a stall retry replays the step
+   *  from the pre-step transcript, which would re-run it — so such a stall is not retried. */
+  toolRanThisAttempt = false;
   /** Resets the active request's stall timer; a host tool's completion restarts the model's idle window. */
   stallPoke;
   /** Advertised tools this run's text claimed to have used while the ledger showed zero calls. */
@@ -4088,6 +4423,7 @@ var Agent = class _Agent {
   addTools(tools) {
     this.injectedTools.push(...tools);
     this.activeTools.push(...tools);
+    if (this.prepared && tools.some(isMcpTool) && !this.activeTools.some((t) => t.name === "JobWait")) this.activeTools.push(...makeJobTools(this.jobs));
   }
   /** Remove tools by name from a running agent. Returns the count removed. Also filters
    *  `options.tools` — otherwise a constructor-passed tool resurrects on the next prepare()
@@ -4139,6 +4475,11 @@ var Agent = class _Agent {
   }
   constructor(options) {
     this.options = { ...new AgentOptions(), ...options };
+    this.jobs = this.options.jobs ?? new JobRegistry();
+    this.jobs.options.onExit ??= (n) => {
+      const imgs = n.result?.images;
+      this.inject(imgs?.length ? [{ type: "text", text: formatJobNotice(n) }, ...imgs.map((i) => imagePart(`data:${i.mimeType};base64,${i.data}`))] : formatJobNotice(n));
+    };
     if (this.options.fs) this.buildCtx();
   }
   /** Build the tool context from the resolved fs + options. Idempotent-safe: called once (ctor or ensureFs). */
@@ -4150,7 +4491,8 @@ var Agent = class _Agent {
     this.ctx.ai = this.options.ai;
     this.ctx.model = this.options.model;
     this.ctx.parkHuman = (p) => this.park(p);
-    if (this.options.backgroundJobs) this.ctx.jobs = new SandboxJobRegistry();
+    this.ctx.toolJobs = this.jobs;
+    if (this.options.backgroundJobs) this.ctx.jobs = this.jobs;
   }
   /**
    * Resolve the filesystem + build the tool context if the ctor couldn't (no `fs` was passed). The disk
@@ -4166,7 +4508,7 @@ var Agent = class _Agent {
       const disk = new NodeDiskFilesystem2(process.cwd());
       await disk.init();
       this.options.fs = new JailedFilesystem2(disk);
-      log6.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
+      log7.info(`no fs provided \u2014 defaulting to jailed real disk at ${process.cwd()}`);
     }
     this.buildCtx();
   }
@@ -4236,7 +4578,7 @@ var Agent = class _Agent {
       tools = [...tools, makeTaskTool(taskOpts), makeTaskBatchTool(taskOpts)];
     }
     if (o.checkpoints) tools = [...tools, ...checkpointTools()];
-    if (this.ctx.jobs) tools = [...tools, ...makeJobTools(this.ctx.jobs)];
+    if (this.ctx.jobs || [...tools, ...this.injectedTools].some(isMcpTool)) tools = [...tools, ...makeJobTools(this.jobs)];
     const plan = o.planMode ? planMode({ host: o.host }) : void 0;
     if (plan) tools = [...tools, plan.tool];
     this.activeHooks = composeHooks(o.hooks, plan?.hooks, o.permissions?.hooks());
@@ -4352,8 +4694,8 @@ var Agent = class _Agent {
     let closureNudged = false;
     let lastProgressAt = start;
     const kill = (finishReason) => {
-      log6.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${finishReason === "timeout" ? `, idle=${Date.now() - lastProgressAt - this.parkedMs}ms` : ""}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
-      this.ctx.jobs?.killAll();
+      log7.warn(`kill-switch: ${finishReason} (steps=${steps}, tokens=${usage.totalTokens}, budgetTokens=${Math.round(usage.totalTokens - 0.9 * usage.cacheReadTokens)}, ms=${Date.now() - start - this.parkedMs}${finishReason === "timeout" ? `, idle=${Date.now() - lastProgressAt - this.parkedMs}ms` : ""}${this.parkedMs ? ` +${this.parkedMs} parked` : ""})`);
+      this.jobs.killAll(`run ended: ${finishReason}`, true);
       const claims = this.survivingClaims();
       return { text: lastAssistantText(this.transcript), steps, finishReason, messages: this.transcript, usage, usageEstimated, ...claims.length ? { fabricatedToolClaims: claims } : {} };
     };
@@ -4374,22 +4716,27 @@ var Agent = class _Agent {
       const hostToolTimeoutMs = o.providerOptions?.toolTimeoutMs;
       const derivedToolTimeoutMs = Math.max(TRANSPORT_TOOL_TIMEOUT_FLOOR_MS, ...this.activeTools.map(transportHeadroomMs));
       const effectiveToolTimeoutMs = typeof hostToolTimeoutMs === "number" ? Math.max(hostToolTimeoutMs, derivedToolTimeoutMs) : derivedToolTimeoutMs;
+      this.toolHoldMs = effectiveToolTimeoutMs;
       if (isCursorWithTools) {
         if (typeof hostToolTimeoutMs === "number" && effectiveToolTimeoutMs !== hostToolTimeoutMs) {
-          log6.warn(`providerOptions.toolTimeoutMs=${hostToolTimeoutMs}ms is below what the registered tools need \u2014 RAISED to ${effectiveToolTimeoutMs}ms. ${toolTimeoutViolations(this.activeTools, hostToolTimeoutMs).length} tool(s) could outlive it, and the transport would have destroyed their results. To lower it, lower the tools' own maxDurationMs (e.g. the Shell tool's maxTimeoutMs) instead.`);
+          log7.warn(`providerOptions.toolTimeoutMs=${hostToolTimeoutMs}ms is below what the registered tools need \u2014 RAISED to ${effectiveToolTimeoutMs}ms. ${toolTimeoutViolations(this.activeTools, hostToolTimeoutMs).length} tool(s) could outlive it, and the transport would have destroyed their results. To lower it, lower the tools' own maxDurationMs (e.g. the Shell tool's maxTimeoutMs) instead.`);
         }
-        for (const v of toolTimeoutViolations(this.activeTools, effectiveToolTimeoutMs)) log6.warn(v);
+        for (const v of toolTimeoutViolations(this.activeTools, effectiveToolTimeoutMs)) log7.warn(v);
       }
       const cursorPo = isCursorWithTools ? {
         toolTimeoutMs: effectiveToolTimeoutMs,
         toolExecutor: async (name, args) => {
           const tc = { id: `cursor-${Date.now()}`, type: "function", function: { name, arguments: JSON.stringify(args) } };
-          this.hostToolsInFlight++;
-          this.hostToolHoldUntil = Math.max(this.hostToolHoldUntil, Date.now() + effectiveToolTimeoutMs);
+          const job = this.jobs.track({ kind: "host", label: name, holds: true, hardCapMs: effectiveToolTimeoutMs });
           try {
-            return await this.dispatch(tc);
+            const r = await this.dispatch(tc);
+            job.finish("done");
+            return r;
+          } catch (e) {
+            job.finish("error", void 0, String(e));
+            throw e;
           } finally {
-            this.hostToolsInFlight--;
+            this.toolRanThisAttempt = true;
             this.stallPoke?.();
           }
         }
@@ -4402,6 +4749,9 @@ var Agent = class _Agent {
       };
       try {
         for (let attempt = 0; ; attempt++) {
+          for (const [, h] of this.nativeJobs) if (h.status === "running") this.jobs.kill(h.id, "step attempt ended");
+          this.nativeJobs.clear();
+          this.toolRanThisAttempt = false;
           try {
             if (useStream) {
               const stall = this.armStallWatchdog(o.signal, o.stallMs);
@@ -4431,10 +4781,12 @@ var Agent = class _Agent {
             const stalled = err2?.code === "stall";
             const empty = err2?.code === "empty" || err2?.code === "cursor_silent";
             const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
-            const transient = !o.signal?.aborted && !isAbortError(err2) && attempt < maxAttempts && (network || serverSide || stalled || empty);
+            const replaysTool = stalled && this.toolRanThisAttempt;
+            if (replaysTool) log7.warn("model stall after tool(s) already ran this step \u2014 not retrying (a retry would replay them)");
+            const transient = !o.signal?.aborted && !isAbortError(err2) && !replaysTool && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err2;
             const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
-            log6.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
+            log7.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err2?.message ?? err2}) \u2014 retrying in ${waitMs}ms`);
             o.host?.notify?.({ kind: "retry", message: `${empty ? "model returned nothing" : stalled ? "model stalled" : "connection dropped"} \u2014 retrying step (#${attempt + 1})` });
             await new Promise((r) => setTimeout(r, waitMs));
           }
@@ -4442,12 +4794,12 @@ var Agent = class _Agent {
       } catch (err2) {
         if (err2?.code === "budget") return kill("budget");
         if (err2?.code === "stall") {
-          log6.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
+          log7.warn(`model stalled out after retries: ${err2?.message ?? err2}`);
           return { ...kill("timeout"), error: err2 };
         }
         if (o.signal?.aborted || isAbortError(err2)) return kill("aborted");
         if (err2?.code === "empty" || err2?.code === "cursor_silent") {
-          log6.warn(`model returned empty/silent turns after retries \u2014 surfacing as failed`);
+          log7.warn(`model returned empty/silent turns after retries \u2014 surfacing as failed`);
           return { text: "", steps, finishReason: "empty", messages: this.transcript, usage, usageEstimated, error: err2 };
         }
         const body = err2?.body ?? err2?.response?.data ?? err2?.error;
@@ -4459,7 +4811,7 @@ var Agent = class _Agent {
         }
         if (bodyStr && err2 instanceof Error && !err2.message.includes(bodyStr)) err2.detail = bodyStr;
         const errLog = err2 instanceof Error ? { message: err2.message, ...err2.detail ? { detail: err2.detail } : {}, stack: err2.stack } : err2;
-        log6.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
+        log7.error(`chat() failed: ${err2?.message ?? err2}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err2 };
       }
       if (o.signal?.aborted) return kill("aborted");
@@ -4515,21 +4867,21 @@ var Agent = class _Agent {
         if (emptyTurn && o.failEmptyTurns) {
           if (!emptyNudged && canNudge()) {
             emptyNudged = true;
-            log6.warn(`empty model turn after tool work (step ${steps}, provider finishReason=${res.finishReason ?? "n/a"}) \u2014 nudging once`);
+            log7.warn(`empty model turn after tool work (step ${steps}, provider finishReason=${res.finishReason ?? "n/a"}) \u2014 nudging once`);
             this.transcript.push({ role: "user", content: "Continue \u2014 you returned nothing. Answer the user now using the tool results above, or keep working if you are not done." });
             continue;
           }
-          log6.warn(`model returned empty turns after tool work \u2014 surfacing as failed`);
+          log7.warn(`model returned empty turns after tool work \u2014 surfacing as failed`);
           const e = new Error("empty_response: model returned an empty turn (no text, no tools) after a re-prompt");
           e.code = "empty";
           return { text: "", steps, finishReason: "empty", ...res.finishReason ? { providerFinishReason: res.finishReason } : {}, messages: this.transcript, usage, usageEstimated, error: e };
         }
         const fabricated = o.catchFabricatedToolUse && !closureNudged ? this.fabricatedToolNames(contentText(res.content ?? "")) : [];
         for (const n of fabricated) this.fabricatedClaims.add(n);
-        if (fabricated.length && !canNudge()) log6.warn(`fabricated tool use: text names ${fabricated.join(", ")} but no step/budget left to demand the call \u2014 finishing with the existing answer`);
+        if (fabricated.length && !canNudge()) log7.warn(`fabricated tool use: text names ${fabricated.join(", ")} but no step/budget left to demand the call \u2014 finishing with the existing answer`);
         if (fabricated.length && canNudge()) {
           closureNudged = true;
-          log6.warn(`fabricated tool use: text names ${fabricated.join(", ")} but the run invoked ${this.invokedTools.size ? [...this.invokedTools].join(", ") : "nothing"} \u2014 demanding the real call`);
+          log7.warn(`fabricated tool use: text names ${fabricated.join(", ")} but the run invoked ${this.invokedTools.size ? [...this.invokedTools].join(", ") : "nothing"} \u2014 demanding the real call`);
           this.transcript.push({
             role: "user",
             content: `You referred to ${fabricated.map((n) => `\`${n}\``).join(", ")} in your reply, but you never actually called ${fabricated.length > 1 ? "those tools" : "that tool"} \u2014 no tool call was made, so any result you reported for ${fabricated.length > 1 ? "them" : "it"} was invented. Either call ${fabricated.length > 1 ? "them" : "it"} for real now, or answer without ${fabricated.length > 1 ? "them" : "it"} and do NOT claim any outcome \u2014 including a failure or a timeout \u2014 for a call you did not make.`
@@ -4538,15 +4890,18 @@ var Agent = class _Agent {
         }
         if (o.closeDelegatedTurns && res.endedWithoutClosing && !closureNudged && canNudge()) {
           closureNudged = true;
-          log6.verbose("delegated turn went silent after a tool \u2014 nudging a closing answer");
+          log7.verbose("delegated turn went silent after a tool \u2014 nudging a closing answer");
           this.transcript.push({
             role: "user",
             content: "You ran tools but did not reply. Answer the user now using the tool results above; if a tool failed, say so plainly. Do NOT re-run those tools, do NOT narrate what you did, and do NOT ask for permission to continue."
           });
           continue;
         }
-        log6.verbose(`completed in ${steps} step(s)`);
-        await this.ctx.jobs?.drain();
+        log7.verbose(`completed in ${steps} step(s)`);
+        const drained = await this.jobs.drain(o.signal);
+        if (o.signal?.aborted) return kill("aborted");
+        if (drained.length) lastProgressAt = Date.now();
+        if (this.drainInjections()) continue;
         this.releaseStaleImages();
         await this.activeHooks?.onStop?.(res.content ?? "");
         const claims = this.survivingClaims();
@@ -4572,11 +4927,12 @@ var Agent = class _Agent {
         }
         this.transcript.push({ role: "tool", tool_call_id: tc.id, name: tc.function.name, content });
       }
+      lastProgressAt = Date.now();
       if (this.ctx.needsInput) {
         const question = this.ctx.needsInput;
         this.ctx.needsInput = void 0;
-        log6.warn(`needs_input: ${question.question} (steps=${steps})`);
-        await this.ctx.jobs?.drain();
+        log7.warn(`needs_input: ${question.question} (steps=${steps})`);
+        await this.jobs.drain();
         const text = [
           `OPEN QUESTION (run paused \u2014 no human was reachable): ${question.question}`,
           ...question.options.map((o2) => `  \u2022 ${o2.label}${o2.description ? ` \u2014 ${o2.description}` : ""}`)
@@ -4614,7 +4970,9 @@ var Agent = class _Agent {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
-        if (this.hostToolsInFlight > 0 && Date.now() < this.hostToolHoldUntil) return poke();
+        if (this.toolHoldActive()) return poke();
+        const inFlight = this.jobs.list().filter((j) => j.status === "running");
+        log7.warn(`stall watchdog: no stream output for ${stallMs}ms and no tool holding the stream \u2014 aborting the request` + (inFlight.length ? ` (${inFlight.length} detached job(s) running, not awaited by the stream: ${inFlight.map((j) => `${j.id}/${j.kind}`).join(", ")})` : ""));
         fired = true;
         ac.abort(stallError());
       }, stallMs);
@@ -4634,6 +4992,12 @@ var Agent = class _Agent {
       reclassify: (err2) => stalled() ? stallError() : err2
     };
   }
+  /** A host or native delegated tool is running and not stuck — the provider is quiet, not stalled. The reap runs
+   *  FIRST, so a holder past its deadline is released (logged with evidence) instead of holding forever. */
+  toolHoldActive() {
+    this.jobs.reap();
+    return this.jobs.holding().length > 0;
+  }
   /** A clean-stop turn that carries no assistant text AND no tool calls (native or delegated) — a
    *  non-result the model produced by going silent. Callers retry it rather than report "done". */
   isEmptyStop(res) {
@@ -4672,6 +5036,18 @@ var Agent = class _Agent {
           if (a.output !== void 0) prev.output = a.output;
           prev.status = a.status;
         }
+        const nj = a.id ? this.nativeJobs.get(a.id) : void 0;
+        if (a.status === "running") {
+          if (nj) nj.touch();
+          else if (a.id) this.nativeJobs.set(a.id, this.jobs.track({ kind: "native", label: a.name, holds: true, hardCapMs: this.toolHoldMs }));
+        } else {
+          if (nj) {
+            if (typeof a.output === "string") nj.chunk(a.output.slice(-4e3));
+            nj.finish(a.status === "error" ? "error" : "done");
+            this.nativeJobs.delete(a.id);
+          }
+          this.toolRanThisAttempt = true;
+        }
         sawTool = true;
         this.invokedTools.add(a.name);
         trailing = "";
@@ -4760,13 +5136,13 @@ var Agent = class _Agent {
     const decision = await this.park(Promise.resolve(hooks?.preToolUse?.(call, meta)));
     if (decision?.block) {
       const blocked = `Blocked by hook: ${decision.reason ?? "no reason given"}`;
-      log6.debug(`${tc.function.name} -> ${blocked}`);
+      log7.debug(`${tc.function.name} -> ${blocked}`);
       await hooks?.postToolUse?.(call, blocked, meta);
       return blocked;
     }
     this.options.host?.notify?.({ kind: "tool_use", id: tc.id ?? "", name: tc.function.name, input: args });
     if (earlyError) {
-      log6.debug(`${tc.function.name} -> ${earlyError}`);
+      log7.debug(`${tc.function.name} -> ${earlyError}`);
       await hooks?.postToolUse?.(call, earlyError, meta);
       this.options.host?.notify?.({ kind: "tool_result", id: tc.id ?? "", output: earlyError, isError: true });
       return earlyError;
@@ -4775,12 +5151,12 @@ var Agent = class _Agent {
     let images;
     let threw = false;
     try {
-      log6.debug(`${tc.function.name}(${tc.function.arguments})`);
+      log7.debug(`${tc.function.name}(${tc.function.arguments})`);
       this.ctx.emit = hooks?.onToolOutput ? (chunk) => {
         try {
           hooks.onToolOutput(call, chunk, meta);
         } catch (e) {
-          log6.debug(`onToolOutput hook error: ${e}`);
+          log7.debug(`onToolOutput hook error: ${e}`);
         }
       } : void 0;
       const raw = await tool.run(args, this.ctx);
@@ -4792,7 +5168,7 @@ var Agent = class _Agent {
       }
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log6.debug(`${tc.function.name} -> error: ${msg}`);
+      log7.debug(`${tc.function.name} -> error: ${msg}`);
       result = `Error: ${msg}`;
       threw = true;
     } finally {
@@ -4884,6 +5260,7 @@ function estimateTokens(m, keepRecentImages = 1) {
   return Math.ceil(sendBytes(m, keepRecentImages) / 4);
 }
 var TRANSPORT_TOOL_TIMEOUT_FLOOR_MS = 18e5;
+var isMcpTool = (t) => t.name.startsWith("mcp__") || t.name === "McpCall";
 function transportHeadroomMs(t) {
   const d = Number(t.maxDurationMs) || 0;
   if (!d) return 0;
@@ -5059,7 +5436,7 @@ function fitTokenBudget(messages, maxTokens, keepRecentImages = 1) {
   const ids = callIdSet(messages.slice(from));
   while (from < messages.length && messages[from].role === "tool" && !ids.has(messages[from].tool_call_id ?? "")) total -= per[from++];
   if (total > maxTokens)
-    log6.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
+    log7.warn(`context ~${total} tok still over maxContextTokens=${maxTokens} after trimming (system head can't be dropped)`);
   return [...head, ...messages.slice(from)];
 }
 function compact(m, max, focus) {
@@ -5364,6 +5741,7 @@ init_OverlayFilesystem();
 
 // src/index.ts
 init_tools();
+init_tools_jobs();
 
 // src/scheduler.ts
 function parseCronField(field, min, max) {
@@ -5636,7 +6014,7 @@ init_tools_web();
 init_tools();
 init_tools_structured();
 init_logging();
-var log7 = forComponent("scratch");
+var log8 = forComponent("scratch");
 var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
@@ -5676,7 +6054,7 @@ var Scratch = class {
           await (this.dirReady ??= mkdirp(this.fs, dir));
           await this.fs.writeFile(path, header + raw);
         } catch (e) {
-          log7.debug("scratch write failed; returning raw", e);
+          log8.debug("scratch write failed; returning raw", e);
           return raw;
         }
         const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
@@ -5706,7 +6084,7 @@ To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026",
       await (this.dirReady ??= mkdirp(this.fs, dir));
       await this.fs.writeFile(path, header + full);
     } catch (e) {
-      log7.debug("scratch spill failed; cropping lossy", e);
+      log8.debug("scratch spill failed; cropping lossy", e);
       return full.slice(0, pageBytes) + `
 
 [output cropped to ${pageBytes} of ${full.length} bytes; full output unavailable (scratch write failed) \u2014 refine your query]`;
@@ -5752,7 +6130,7 @@ Question: ${q2}`);
         const answer = (res.text ?? "").trim();
         return answer || "(no answer found in scratch)";
       } catch (e) {
-        log7.debug("Ask peek failed", e);
+        log8.debug("Ask peek failed", e);
         return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
@@ -5761,7 +6139,7 @@ Question: ${q2}`);
 
 // src/lessons.ts
 init_logging();
-var log8 = forComponent("Lessons");
+var log9 = forComponent("Lessons");
 var LessonOptionsDefaults = class {
   minRepeats = 2;
 };
@@ -5786,8 +6164,8 @@ function lessonCapture(options) {
       counts.set(lesson.slug, n);
       if (n < o.minRepeats) return;
       written.add(lesson.slug);
-      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log8.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
-      log8.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log9.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log9.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
     }
   };
 }
@@ -5795,7 +6173,7 @@ function lessonCapture(options) {
 // src/reflect.ts
 init_llm();
 init_logging();
-var log9 = forComponent("Reflect");
+var log10 = forComponent("Reflect");
 async function reflectOnRun(o) {
   const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
   if (!digest.trim()) return null;
@@ -5811,7 +6189,7 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
     const r = await o.ai.chat({ model: o.model, messages: [{ role: "user", content: prompt }], stream: false });
     text = r?.content ?? "";
   } catch (e) {
-    log9.warn(`reflection call failed: ${e?.message ?? e}`);
+    log10.warn(`reflection call failed: ${e?.message ?? e}`);
     return null;
   }
   const m = text.match(/LESSON:\s*(.+)/i);
@@ -5821,10 +6199,10 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
   try {
     await writeFact(o.fs, o.dir, slug2, lesson);
   } catch (e) {
-    log9.warn(`could not persist lesson: ${e?.message ?? e}`);
+    log10.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log9.debug(`reflection persisted ${slug2}`);
+  log10.debug(`reflection persisted ${slug2}`);
   return slug2;
 }
 function digestRun(messages, maxChars) {
@@ -5873,7 +6251,7 @@ function forComponent2(name) {
 }
 
 // node_modules/@bod.ee/voice/src/core/emotion.ts
-var log10 = forComponent2("Emotion");
+var log11 = forComponent2("Emotion");
 var EMOTIONS = [
   // primary (best results)
   "neutral",
@@ -6005,7 +6383,7 @@ function renderEmotions(text, opts = { show: true }) {
       speech += cartesiaTag(tag);
       if (opts.show) display += m[0];
     } else {
-      log10.debug(`dropping unknown emotion tag ${m[0]}`);
+      log11.debug(`dropping unknown emotion tag ${m[0]}`);
     }
     last = m.index + m[0].length;
   }
@@ -6047,7 +6425,7 @@ var EmotionStream = class {
       if (tag) {
         this.pending = tag;
         if (this.show) display += m[0];
-      } else log10.debug(`dropping unknown emotion tag ${m[0]}`);
+      } else log11.debug(`dropping unknown emotion tag ${m[0]}`);
       last = m.index + m[0].length;
     }
     this.emit(body.slice(last), (s, d, p) => {
@@ -6070,7 +6448,7 @@ var EmotionStream = class {
 };
 
 // node_modules/@bod.ee/voice/src/core/engine.ts
-var log11 = forComponent2("VoiceEngine");
+var log12 = forComponent2("VoiceEngine");
 var realClock = {
   now: () => performance.now(),
   setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -6345,7 +6723,7 @@ var VoiceEngine = class _VoiceEngine {
     await Promise.all([this.tts.connect(), this.stt.start()]);
     this.tts.warmup?.();
     this.setState("listening");
-    log11.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+    log12.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
   get usingAec() {
     return this.stt.usingAec;
@@ -6367,7 +6745,7 @@ var VoiceEngine = class _VoiceEngine {
       this.options.onDiag({ t: this.clock.now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log11.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log12.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   idleWaiters = [];
@@ -6476,7 +6854,7 @@ var VoiceEngine = class _VoiceEngine {
     if (prose.trim()) this.repliedSinceDispatch = true;
     for (const w of this.words(this.reply)) this.echoWords.add(w);
     this.tts.speak(forSpeech(speech), true);
-    if (!this.spokeDeltas && this.turnStartAt) log11.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
+    if (!this.spokeDeltas && this.turnStartAt) log12.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
     this.spokeDeltas = true;
     this.setState("speaking");
     if (this.options.revealMode !== "off" && display) {
@@ -6553,7 +6931,7 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = null;
       this.speaking = false;
       this.stopWordReveal(true);
-      if (this.turnStartAt) log11.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
+      if (this.turnStartAt) log12.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
       this.echoUntil = this.clock.now() + 2500;
       if (!this.usingAec) this.stt.reset();
       this.setState("listening");
@@ -6641,7 +7019,7 @@ var VoiceEngine = class _VoiceEngine {
     this.clearAckTimer("interrupt");
     this.adaptiveAckFired = false;
     this.ackProbe = null;
-    if (this.uttQueue.length) log11.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
+    if (this.uttQueue.length) log12.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
     const droppedQueued = this.uttQueue.length;
     this.uttQueue = [];
     if (!this.speaking && !this.drainTimer) return;
@@ -6787,7 +7165,7 @@ var VoiceEngine = class _VoiceEngine {
       if (flat && this.lastDispatchFlat && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS && (this.lastDispatchFlat.startsWith(flat) || flat.startsWith(this.lastDispatchFlat))) return;
       this.specSpent = true;
       this.specText = this.specPartial;
-      log11.debug(`speculate: "${this.specText.slice(0, 60)}"`);
+      log12.debug(`speculate: "${this.specText.slice(0, 60)}"`);
       this.diag("speculate", { text: this.specText });
       this.options.onSpeculate(this.specText);
     }, this.options.speculativeMs);
@@ -6856,7 +7234,7 @@ var VoiceEngine = class _VoiceEngine {
     };
     this.tts.newContext();
     this.tts.speak(phrase, false);
-    log11.debug(`backchannel: "${phrase}"`);
+    log12.debug(`backchannel: "${phrase}"`);
     this.diag("backchannel", { phrase });
     this.options.onBackchannel(phrase);
   }
@@ -6889,7 +7267,7 @@ var VoiceEngine = class _VoiceEngine {
     });
     if (idx < 0) return text;
     toks.splice(idx, 1);
-    log11.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
+    log12.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
     return toks.join(" ");
   }
   /** Merge a resumed utterance into the pending one, deduping any word-overlap. Soniox re-finalizes
@@ -6980,7 +7358,7 @@ var VoiceEngine = class _VoiceEngine {
     this.pendingUtt = this.mergeUtterance(this.pendingUtt, text);
     if (this.pendingTimer) this.clock.clearTimeout(this.pendingTimer);
     if (this.options.incompleteMergeMs && this.looksIncomplete(this.pendingUtt)) {
-      log11.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      log12.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
       this.diag("hold", { reason: "incomplete", tail: this.pendingUtt.slice(-40) });
       this.options.onHold();
       if (this.options.holdFiller && !this.speaking) this.speakFiller(this.options.holdFiller);
@@ -7015,13 +7393,13 @@ var VoiceEngine = class _VoiceEngine {
     if (text) {
       const flat = text.toLowerCase().replace(/[^a-z0-9]/g, "");
       if (flat && flat === this.lastDispatchFlat && !this.repliedSinceDispatch && this.clock.now() - this.lastDispatchAt < _VoiceEngine.DUP_FINAL_MS) {
-        log11.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
+        log12.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
         this.diag("utterance_drop", { reason: "dup_final", text: text.slice(0, 60) });
         return;
       }
       const refinal = this.refinalizes(text);
       if (refinal && this.repliedSinceDispatch) {
-        log11.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
+        log12.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
         this.diag("utterance_drop", { reason: "refinalized", text: text.slice(0, 60) });
         this.lastDispatchFlat = flat;
         this.lastDispatchWords = text.trim().split(/\s+/);
@@ -7181,7 +7559,7 @@ var SpokenSplitter = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/soniox.ts
-var log12 = forComponent2("SonioxSTT");
+var log13 = forComponent2("SonioxSTT");
 var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
@@ -7222,7 +7600,7 @@ var SonioxSTT = class {
       this.onDiag({ t: now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log12.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log13.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   lastChunkAt = 0;
@@ -7264,11 +7642,11 @@ var SonioxSTT = class {
     this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
-      log12.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      log13.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
       this.diag("stt_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: true });
       this.reset();
       this.connectWs().catch((e) => {
-        log12.error(`soniox reconnect failed: ${e.message}`);
+        log13.error(`soniox reconnect failed: ${e.message}`);
         this.diag("stt_reconnect_failed", { message: e.message });
       });
     };
@@ -7280,7 +7658,7 @@ var SonioxSTT = class {
     this.endpointTimer = setInterval(() => {
       const combined = (this.finalText + this.partialText).trim();
       if (!combined || now() - this.lastChangeAt < this.options.silenceEndpointMs) return;
-      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (this.firstTokenAt) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(combined, now());
     }, 120);
@@ -7292,7 +7670,7 @@ var SonioxSTT = class {
         if (this.stopped) return;
         const ref = this.lastChunkAt || this.startedChunksAt;
         if (now() - ref > noAudioMs) {
-          log12.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
+          log13.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
           this.diag("stt_watchdog_fatal", { noAudioMs });
           this.onFatal("microphone stopped delivering audio (try a different input device, e.g. AirPods, or check System Settings \u2192 Sound \u2192 Input)");
           this.stop();
@@ -7315,7 +7693,7 @@ var SonioxSTT = class {
   handle(m) {
     if (m.error_message) {
       this.diag("stt_error", { message: String(m.error_message), code: m.error_code });
-      return log12.error(`soniox: ${m.error_message}`);
+      return log13.error(`soniox: ${m.error_message}`);
     }
     let endpoint = false;
     for (const t of m.tokens ?? []) {
@@ -7332,7 +7710,7 @@ var SonioxSTT = class {
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log12.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(utterance, now());
     }
@@ -7354,7 +7732,7 @@ var SonioxSTT = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/cartesia.ts
-var log13 = forComponent2("CartesiaTTS");
+var log14 = forComponent2("CartesiaTTS");
 var now2 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
@@ -7390,7 +7768,7 @@ var CartesiaTTS = class _CartesiaTTS {
       this.onDiag({ t: now2(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log13.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log14.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   firstAudioAt = 0;
@@ -7425,11 +7803,11 @@ var CartesiaTTS = class _CartesiaTTS {
       this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
     });
     this.ws.onclose = (ev) => {
-      log13.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      log14.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
       this.diag("tts_ws_closed", { code: ev.code, reason: String(ev.reason || ""), reconnecting: !this.closed });
       if (!this.closed) {
         this.connecting = this.doConnect().catch((e) => {
-          log13.error(`cartesia reconnect failed: ${e.message}`);
+          log14.error(`cartesia reconnect failed: ${e.message}`);
           this.diag("tts_reconnect_failed", { message: e.message });
         });
       }
@@ -7457,12 +7835,12 @@ var CartesiaTTS = class _CartesiaTTS {
           this.down = true;
           this.downAt = now2();
           this.consecutiveOk = 0;
-          log13.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          log14.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
           this.diag("tts_breaker_open", { errors: this.consecutiveErrors });
           this.onDone();
           this.startProbe();
         } else if (!this.down) {
-          (/No valid transcripts/i.test(m.message || "") ? log13.debug : log13.warn)(`cartesia: ${JSON.stringify(m)}`);
+          (/No valid transcripts/i.test(m.message || "") ? log14.debug : log14.warn)(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -7477,7 +7855,7 @@ var CartesiaTTS = class _CartesiaTTS {
     this.stopProbe();
     const downMs = this.downAt ? now2() - this.downAt : 0;
     this.diag("tts_breaker_close", { downMs: Math.round(downMs) });
-    (downMs < 2e3 ? log13.debug : log13.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
+    (downMs < 2e3 ? log14.debug : log14.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
   async ensureConnected() {
@@ -7568,7 +7946,7 @@ configureLogging((name) => {
 });
 
 // src/duplex.ts
-var log14 = forComponent("DuplexAgent");
+var log15 = forComponent("DuplexAgent");
 function describeCall(call) {
   const v = call.args && Object.values(call.args).find((x) => typeof x === "string" && x.trim());
   const hint = v ? ` (${String(v).replace(/\s+/g, " ").trim().slice(0, 48)})` : "";
@@ -7779,7 +8157,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
           const m = this.reflexBuf.match(RESERVED_EVENT_MARKER) ?? this.reflexBuf.match(RESERVED_EVENT_OPENER);
           if (m) {
             this.fabricationCut = true;
-            log14.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log15.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
             const safe = this.reflexBuf.slice(this.reflexForwarded, m.index);
             if (!safe) return;
             if (safe.trim()) this.spokeThisTurn = true;
@@ -7874,7 +8252,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     return {
       preToolUse: (call) => {
         if (this.spec?.state === "pending" && !_DuplexAgent.SPEC_SAFE_TOOLS.has(call.name)) {
-          log14.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log15.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -7912,7 +8290,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
     try {
       await this.voice.send(fallback ? "[reminder] You said nothing to the user this turn. Tell them, in ONE short spoken sentence, what just happened \u2014 no tools." : dispatched ? "[reminder] You dispatched a task but said nothing to the user. Say ONE short spoken acknowledgement now \u2014 no tools." : "[reminder] You said nothing to the user this turn. Give your ONE short spoken reply now \u2014 no tools.");
     } catch (e) {
-      log14.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log15.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
     }
@@ -8005,7 +8383,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log14.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log15.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -8019,7 +8397,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       if (d === "abort") {
         if (this.voice.transcript.length > base) this.voice.transcript.length = base;
         this.speculativeAbortedCalls++;
-        log14.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log15.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -8284,7 +8662,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     this.notify("task_verify", `task ${id}: verifying`, { id });
     const cres = await new Agent(checkerOpts).run(checkBrief);
     if (cres.finishReason !== "stop") {
-      log14.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log15.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
       this.notify("task_verify", `task ${id}: verify inconclusive (${cres.finishReason})`, { id, finishReason: cres.finishReason });
     }
     const sum = (a = 0, b = 0) => a + b;
@@ -8420,7 +8798,7 @@ Another agent just implemented the above. Independently check the CURRENT state
     rec.status = "done";
     rec.result = res.text;
     const incomplete = res.finishReason !== "stop" && res.finishReason !== "empty";
-    log14.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    log15.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -8462,14 +8840,14 @@ Another agent just implemented the above. Independently check the CURRENT state
   foldIfSuperseded(rec, note) {
     if (!(rec.deliveryParked && this.suppressParkedResume)) return false;
     if (note.trim()) this.voice.transcript.push({ role: "assistant", content: note });
-    log14.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log15.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
     return true;
   }
   failTask(rec, msg) {
     this.dropAsk(rec.id);
     rec.status = "error";
     rec.result = msg;
-    log14.warn(`task ${rec.id} failed: ${msg}`);
+    log15.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
     if (this.foldIfSuperseded(rec, `The "${rec.label}" task failed: ${msg}`)) return;
     this.queueRevoice(this.integrationPrompt(rec, "error", msg, "error"), true);
@@ -8718,17 +9096,42 @@ async function withDeadline(p, ms) {
   }
 }
 var mcpTimedOut = (name, ms = MCP_CALL_TIMEOUT_MS) => `[${name}] no response after ${ms / 1e3}s \u2014 the MCP server never answered. The call's outcome is UNKNOWN: do not assume it ran or that it failed. Verify the state (or pick a bounded/narrower call) before retrying.`;
+async function runMcpCall(name, call, ctx, timeoutMs) {
+  const jobs = ctx?.toolJobs;
+  const shape = (raw) => {
+    const r2 = toResult(raw);
+    return r2.images?.length ? r2 : r2.text;
+  };
+  if (!jobs) {
+    const raw = await withDeadline(call({}), timeoutMs);
+    return raw === TIMED_OUT ? mcpTimedOut(name, timeoutMs) : shape(raw);
+  }
+  const r = await jobs.runForeground(async ({ signal, touch, onChunk }) => {
+    const raw = await call({
+      signal,
+      onProgress: (p) => {
+        touch();
+        if (p?.message) onChunk(`[progress${p.progress != null ? ` ${p.progress}${p.total != null ? `/${p.total}` : ""}` : ""}] ${p.message}
+`);
+      }
+    });
+    const res = toResult(raw);
+    onChunk(res.text + (res.images?.length ? `
+[${res.images.length} image(s) in the result]` : ""));
+    return res;
+  }, { kind: "mcp", label: name, idleAfterActivity: true });
+  if (r.done) return r.value.images?.length ? r.value : r.value.text;
+  const soft = jobs.options.foregroundMs.mcp ?? 0;
+  return `[still running] MCP call ${name} is still working after ${soft >= 1e3 ? `${Math.round(soft / 1e3)}s` : `${soft}ms`}, so it was handed to background job ${r.id} \u2014 NOT cancelled, the server keeps going. Its result will be delivered to you when it finishes, so continue with other work; to block on it use JobWait({id:"${r.id}"}) instead of sleeping. JobStatus/JobOutput show its progress; JobKill({id:"${r.id}"}) cancels it. Do NOT re-issue the same call \u2014 that would run it twice.`;
+}
 function mcpToolToAgentTool(spec, callTool, prefix = "mcp__", timeoutMs = MCP_CALL_TIMEOUT_MS) {
   return {
     name: `${prefix}${spec.name}`,
     description: spec.description ?? `MCP tool ${spec.name}`,
     parameters: spec.inputSchema ?? { type: "object", properties: {} },
     maxDurationMs: timeoutMs,
-    async run(args, _ctx) {
-      const raw = await withDeadline(callTool(spec.name, args ?? {}), timeoutMs);
-      if (raw === TIMED_OUT) return mcpTimedOut(spec.name, timeoutMs);
-      const r = toResult(raw);
-      return r.images?.length ? r : r.text;
+    run(args, ctx) {
+      return runMcpCall(spec.name, (o) => callTool(spec.name, args ?? {}, o), ctx, timeoutMs);
     }
   };
 }
@@ -8769,13 +9172,10 @@ function makeMcpToolSearch(specs, callTool, options = {}) {
       }
     },
     maxDurationMs: callTimeoutMs,
-    async run({ name, args }) {
+    async run({ name, args }, ctx) {
       const n = String(name ?? "");
       if (!byName.has(n)) return `Error: unknown MCP tool '${n}'. Use ToolSearch to find valid names.`;
-      const raw = await withDeadline(callTool(n, args ?? {}), callTimeoutMs);
-      if (raw === TIMED_OUT) return mcpTimedOut(n, callTimeoutMs);
-      const r = toResult(raw);
-      return r.images?.length ? r : r.text;
+      return runMcpCall(n, (o) => callTool(n, args ?? {}, o), ctx, callTimeoutMs);
     }
   };
   return [searchTool, callMcpTool];
@@ -8795,17 +9195,17 @@ function buildMcpCatalog(servers) {
   return { specs, routes };
 }
 function searchOverCatalog(servers, specs, routes, resolve5, options) {
-  const tools = specs.length ? makeMcpToolSearch(specs, (name, args) => {
+  const tools = specs.length ? makeMcpToolSearch(specs, (name, args, o) => {
     const r = routes.get(name);
     if (!r) throw new Error(`unknown MCP tool '${name}' \u2014 use ToolSearch to find valid names`);
-    return resolve5(r.server, r.rawName, args ?? {});
+    return resolve5(r.server, r.rawName, args ?? {}, o);
   }, options) : [];
   return { tools, serverNames: servers, toolCount: specs.length };
 }
 function makeMcpToolSearchFromMounted(mounted, options) {
   const { specs, routes } = buildMcpCatalog(mounted);
   const byName = new Map(mounted.map((m) => [m.name, m]));
-  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args) => byName.get(server).client.callTool(rawName, args), options);
+  return searchOverCatalog(mounted.map((m) => m.name), specs, routes, (server, rawName, args, o) => byName.get(server).client.callTool(rawName, args, o), options);
 }
 
 // src/index.ts
@@ -8818,9 +9218,20 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 init_logging();
 import { spawn } from "child_process";
 import { createHash } from "crypto";
-var log15 = forComponent("mcp");
+var log16 = forComponent("mcp");
 var PROTOCOL_VERSION = "2025-06-18";
 var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_CALL_TIMEOUT_MS = 30 * 6e4;
+function deadlineFor(method, spec, opts) {
+  if (opts?.timeoutMs != null) return opts.timeoutMs;
+  if (method === "tools/call") return spec.callTimeoutMs ?? Math.max(DEFAULT_CALL_TIMEOUT_MS, spec.timeoutMs ?? 0);
+  return spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+}
+function withProgressToken(params, token) {
+  const p = params && typeof params === "object" ? params : {};
+  return { ...p, _meta: { ...p._meta ?? {}, progressToken: token } };
+}
+var abortError = (signal) => signal.reason instanceof Error ? signal.reason : Object.assign(new Error("MCP request cancelled"), { name: "AbortError" });
 var StdioTransport = class {
   constructor(spec) {
     this.spec = spec;
@@ -8837,7 +9248,7 @@ var StdioTransport = class {
     proc.stdout.setEncoding("utf8");
     proc.stdout.on("data", (chunk) => this.onData(chunk));
     proc.stderr.setEncoding("utf8");
-    proc.stderr.on("data", (chunk) => log15.debug(`[${command}] stderr:`, chunk.trimEnd()));
+    proc.stderr.on("data", (chunk) => log16.debug(`[${command}] stderr:`, chunk.trimEnd()));
     proc.on("exit", (code) => this.failAll(new Error(`MCP server "${command}" exited (code ${code})`)));
     proc.on("error", (e) => this.failAll(e instanceof Error ? e : new Error(String(e))));
   }
@@ -8851,21 +9262,32 @@ var StdioTransport = class {
       try {
         this.dispatch(JSON.parse(line));
       } catch (e) {
-        log15.debug("dropping non-JSON line from MCP server:", line, e);
+        log16.debug("dropping non-JSON line from MCP server:", line, e);
       }
     }
   }
   dispatch(msg) {
+    if (msg?.method === "notifications/progress") {
+      const p2 = this.pending.get(msg.params?.progressToken);
+      try {
+        p2?.onProgress?.(msg.params ?? {});
+      } catch (e) {
+        log16.debug("onProgress handler threw", e);
+      }
+      return;
+    }
     if (msg?.id == null || !this.pending.has(msg.id)) return;
     const p = this.pending.get(msg.id);
     this.pending.delete(msg.id);
     clearTimeout(p.timer);
+    p.done?.();
     if (msg.error) p.reject(new Error(msg.error?.message ?? JSON.stringify(msg.error)));
     else p.resolve(msg.result);
   }
   failAll(e) {
     for (const p of this.pending.values()) {
       clearTimeout(p.timer);
+      p.done?.();
       p.reject(e);
     }
     this.pending.clear();
@@ -8874,19 +9296,31 @@ var StdioTransport = class {
     if (!this.proc?.stdin) throw new Error("MCP stdio transport not started");
     this.proc.stdin.write(JSON.stringify(msg) + "\n");
   }
-  request(method, params) {
+  request(method, params, opts = {}) {
     const id = this.nextId++;
-    const timeoutMs = this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = deadlineFor(method, this.spec, opts);
+    const { signal, onProgress } = opts;
     return new Promise((resolve5, reject) => {
-      const timer = setTimeout(() => {
+      if (signal?.aborted) return reject(abortError(signal));
+      const timer = timeoutMs > 0 ? setTimeout(() => {
         this.pending.delete(id);
+        done();
         reject(new Error(`MCP request "${method}" timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pending.set(id, { resolve: resolve5, reject, timer });
+      }, timeoutMs) : void 0;
+      const onAbort = () => {
+        if (!this.pending.delete(id)) return;
+        clearTimeout(timer);
+        this.notify("notifications/cancelled", { requestId: id, reason: String(signal?.reason?.message ?? "cancelled") }).catch((e) => log16.debug("cancel notify failed", e));
+        reject(abortError(signal));
+      };
+      const done = () => signal?.removeEventListener("abort", onAbort);
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.pending.set(id, { resolve: resolve5, reject, timer, onProgress, done });
       try {
-        this.write({ jsonrpc: "2.0", id, method, params });
+        this.write({ jsonrpc: "2.0", id, method, params: onProgress ? withProgressToken(params, id) : params });
       } catch (e) {
         clearTimeout(timer);
+        done();
         this.pending.delete(id);
         reject(e);
       }
@@ -8900,7 +9334,7 @@ var StdioTransport = class {
     try {
       this.proc?.stdin?.end();
     } catch (e) {
-      log15.debug("stdin end failed", e);
+      log16.debug("stdin end failed", e);
     }
     this.proc?.kill();
   }
@@ -8927,13 +9361,24 @@ var HttpTransport = class {
   fetchImpl;
   async start() {
   }
-  request(method, params) {
-    return this.post({ jsonrpc: "2.0", id: this.nextId++, method, params }, false);
+  async request(method, params, opts = {}) {
+    const id = this.nextId++;
+    const deadline = AbortSignal.timeout(deadlineFor(method, this.spec, opts));
+    const signal = opts.signal ? AbortSignal.any([opts.signal, deadline]) : deadline;
+    try {
+      return await this.post({ jsonrpc: "2.0", id, method, params: opts.onProgress ? withProgressToken(params, id) : params }, false, signal, opts.onProgress);
+    } catch (e) {
+      if (opts.signal?.aborted) {
+        void this.notify("notifications/cancelled", { requestId: id, reason: String(opts.signal.reason?.message ?? "cancelled") }).catch((err2) => log16.debug("cancel notify failed", err2));
+        throw abortError(opts.signal);
+      }
+      throw e;
+    }
   }
   async notify(method, params) {
-    await this.post({ jsonrpc: "2.0", method, params }, true);
+    await this.post({ jsonrpc: "2.0", method, params }, true, AbortSignal.timeout(this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS));
   }
-  async post(msg, isNotify) {
+  async post(msg, isNotify, signal, onProgress) {
     const headers = {
       "content-type": "application/json",
       accept: "application/json, text/event-stream",
@@ -8946,7 +9391,7 @@ var HttpTransport = class {
       method: "POST",
       headers,
       body: JSON.stringify(msg),
-      signal: AbortSignal.timeout(this.spec.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+      signal
     });
     const sid = resp.headers.get("mcp-session-id");
     if (sid) this.sessionId = sid;
@@ -8954,25 +9399,63 @@ var HttpTransport = class {
     if (!resp.ok) throw new Error(`MCP HTTP ${resp.status} ${resp.statusText}`);
     if (isNotify) return;
     const ct = resp.headers.get("content-type") ?? "";
-    const data = ct.includes("text/event-stream") ? parseSseResponse(await resp.text()) : await resp.json();
+    const data = ct.includes("text/event-stream") ? await readSseResponse(resp, msg.id, onProgress) : await resp.json();
     if (data?.error) throw new Error(data.error?.message ?? JSON.stringify(data.error));
     return data?.result;
   }
   async close() {
   }
 };
-function parseSseResponse(body) {
-  for (const line of body.split("\n")) {
-    const trimmed = line.trimStart();
-    if (!trimmed.startsWith("data:")) continue;
-    try {
-      const obj = JSON.parse(trimmed.slice(5).trim());
-      if (obj && (obj.result !== void 0 || obj.error !== void 0)) return obj;
-    } catch (e) {
-      log15.debug("skipping unparseable SSE data line", e);
+function sseMessage(line) {
+  const trimmed = line.trimStart();
+  if (!trimmed.startsWith("data:")) return void 0;
+  try {
+    return JSON.parse(trimmed.slice(5).trim());
+  } catch (e) {
+    log16.debug("skipping unparseable SSE data line", e);
+    return void 0;
+  }
+}
+async function readSseResponse(resp, id, onProgress) {
+  const handle = (obj) => {
+    if (obj?.method === "notifications/progress") {
+      try {
+        onProgress?.(obj.params ?? {});
+      } catch (e) {
+        log16.debug("onProgress handler threw", e);
+      }
+      return void 0;
     }
+    if (obj && (obj.result !== void 0 || obj.error !== void 0) && (obj.id == null || id == null || obj.id === id)) return obj;
+    return void 0;
+  };
+  const reader = resp.body?.getReader?.();
+  if (!reader) {
+    for (const l of (await resp.text()).split("\n")) {
+      const r = handle(sseMessage(l));
+      if (r) return r;
+    }
+    return {};
+  }
+  const dec = new TextDecoder();
+  let buf = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      buf += done ? dec.decode() : dec.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0 || done && buf) {
+        const line = nl >= 0 ? buf.slice(0, nl) : buf;
+        buf = nl >= 0 ? buf.slice(nl + 1) : "";
+        const r = handle(sseMessage(line));
+        if (r) return r;
+      }
+      if (done) return {};
+    }
+  } finally {
+    reader.cancel().catch(() => {
+    });
   }
-  return {};
 }
 var McpClient = class {
   constructor(transport, clientInfo = { name: "agentx", version: "0" }) {
@@ -8996,8 +9479,9 @@ var McpClient = class {
     const r = await this.transport.request("tools/list");
     return Array.isArray(r?.tools) ? r.tools : [];
   }
-  async callTool(name, args) {
-    return this.transport.request("tools/call", { name, arguments: args ?? {} });
+  /** `tools/call`. Pass `onProgress` to request progress notifications (liveness) and `signal` to cancel. */
+  async callTool(name, args, opts) {
+    return this.transport.request("tools/call", { name, arguments: args ?? {} }, opts);
   }
   async listResources() {
     const r = await this.transport.request("resources/list");
@@ -9011,7 +9495,7 @@ var McpClient = class {
   }
 };
 function buildTransport(cfg) {
-  return cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs });
+  return cfg.url ? new HttpTransport({ url: cfg.url, headers: cfg.headers, bearerToken: cfg.bearerToken, timeoutMs: cfg.timeoutMs, callTimeoutMs: cfg.callTimeoutMs }) : new StdioTransport({ command: cfg.command, args: cfg.args, env: cfg.env, cwd: cfg.cwd, timeoutMs: cfg.timeoutMs, callTimeoutMs: cfg.callTimeoutMs });
 }
 function withTimeout(p, ms, label) {
   if (!ms || ms <= 0) return p;
@@ -9033,11 +9517,11 @@ async function mountWithDeadline(name, cfg, mountTimeoutMs) {
     return await withTimeout((async () => {
       const init = await client.connect();
       const specs = await client.listTools();
-      const tools = mcpToolsToAgentTools(specs, (tool, a) => client.callTool(tool, a), `mcp__${name}__`);
+      const tools = mcpToolsToAgentTools(specs, (tool, a, o) => client.callTool(tool, a, o), `mcp__${name}__`);
       return { name, client, tools, specs, serverInfo: init?.serverInfo, config: cfg };
     })(), mountTimeoutMs, name);
   } catch (e) {
-    await client.close().catch((err2) => log15.debug(`close after failed mount of "${name}": ${err2}`));
+    await client.close().catch((err2) => log16.debug(`close after failed mount of "${name}": ${err2}`));
     throw e;
   }
 }
@@ -9048,15 +9532,15 @@ function validEntries(servers) {
   return Object.entries(servers).filter(([name, cfg]) => {
     if (!cfg || cfg.disabled) return false;
     if (!cfg.command && !cfg.url) {
-      log15.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
+      log16.warn(`MCP server "${name}" needs a command (stdio) or url (http) \u2014 skipping`);
       return false;
     }
     return true;
   });
 }
 function logMountFailure(name, e) {
-  if (e instanceof McpAuthError) log15.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
-  else log15.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
+  if (e instanceof McpAuthError) log16.warn(`MCP "${name}" needs-auth: HTTP ${e.status} \u2014 set bearerToken or headers in its config; skipping`);
+  else log16.error(`MCP server "${name}" failed to mount: ${e?.message ?? e}`);
 }
 async function mountMcpServers(servers = {}, opts = {}) {
   const entries = validEntries(servers);
@@ -9066,7 +9550,7 @@ async function mountMcpServers(servers = {}, opts = {}) {
     const name = entries[i][0];
     if (r.status === "fulfilled") {
       out.push(r.value);
-      log15.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
+      log16.debug(`MCP "${name}" mounted \u2014 ${r.value.tools.length} tool(s)${r.value.serverInfo?.name ? ` from ${r.value.serverInfo.name}` : ""}`);
     } else logMountFailure(name, r.reason);
   });
   return out;
@@ -9106,7 +9590,7 @@ var McpPool = class {
     const prev = this.warm.get(key);
     if (prev) {
       clearTimeout(prev.timer);
-      if (prev.client !== client) void prev.client.close().catch((err2) => log15.debug(`warm-pool replace close failed: ${err2}`));
+      if (prev.client !== client) void prev.client.close().catch((err2) => log16.debug(`warm-pool replace close failed: ${err2}`));
     }
     const e = { client, timer: void 0 };
     this.warm.set(key, e);
@@ -9123,7 +9607,7 @@ var McpPool = class {
     const e = this.warm.get(key);
     if (!e) return;
     this.warm.delete(key);
-    await e.client.close().catch((err2) => log15.debug(`warm-pool evict close failed: ${err2}`));
+    await e.client.close().catch((err2) => log16.debug(`warm-pool evict close failed: ${err2}`));
   }
   async closeAll() {
     for (const e of this.warm.values()) {
@@ -9341,7 +9825,7 @@ init_tools_shell();
 // src/tools.notify.ts
 init_logging();
 import { execFile } from "child_process";
-var log17 = forComponent("notify");
+var log18 = forComponent("notify");
 function makeNotifyTool(opts = {}) {
   const platform2 = opts.platform ?? process.platform;
   const run = opts.exec ?? execFile;
@@ -9365,7 +9849,7 @@ function makeNotifyTool(opts = {}) {
       return new Promise((resolve5) => {
         run(argv[0], argv[1], { timeout: 5e3 }, (e) => {
           if (e) {
-            log17.debug("notification failed", e);
+            log18.debug("notification failed", e);
             resolve5(`Notification failed: ${e.message}`);
           } else resolve5("Notification shown.");
         });
@@ -9381,7 +9865,7 @@ import { BodDB as BodDB2 } from "@bod.ee/db";
 init_logging();
 import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
 import { homedir } from "os";
-var log18 = forComponent("cli-util");
+var log19 = forComponent("cli-util");
 function dotDirs(base, sub, opts = {}) {
   const home = opts.home ?? homedir();
   const dirs = [`${base}/.agent/${sub}`, `${base}/.claude/${sub}`, `${home}/.agent/${sub}`, `${home}/.claude/${sub}`];
@@ -9398,7 +9882,7 @@ function parseJson(text, fallback, what = "json") {
   try {
     return JSON.parse(text);
   } catch (e) {
-    log18.debug(`parseJson(${what}) failed: ${e.message}`);
+    log19.debug(`parseJson(${what}) failed: ${e.message}`);
     return fallback;
   }
 }
@@ -9408,7 +9892,7 @@ function readJsonFile(path, fallback) {
   try {
     text = readFileSync4(path, "utf8");
   } catch (e) {
-    log18.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
+    log19.debug(`readJsonFile(${path}) unreadable: ${e.message}`);
     return fallback;
   }
   return parseJson(text, fallback, path);
@@ -9463,9 +9947,9 @@ function toCursorMcp(servers) {
   }
   return Object.keys(out).length ? { mcpServers: out } : void 0;
 }
-function cursorProviderOptions(model, cwd, mcpServers) {
+function cursorProviderOptions(model, cwd, mcpServers, hostMcpServers) {
   if (!(model ?? "").startsWith("cursor/")) return void 0;
-  return { cwd, ...toCursorMcp(mcpServers) ?? {}, ...process.env.CURSOR_WARM === "0" ? {} : { cursorSession: randomUUID() } };
+  return { cwd, ...toCursorMcp(mcpServers) ?? {}, ...hostMcpServers?.length ? { hostMcpServers } : {}, ...process.env.CURSOR_WARM === "0" ? {} : { cursorSession: randomUUID() } };
 }
 function toClaudeCodeMcp(servers) {
   if (!servers) return void 0;
@@ -9492,8 +9976,8 @@ function claudeCodeProviderOptions(model, cwd, mcpServers) {
   const warm = process.env.AGENTX_CC_WARM === "0" ? {} : { claudeCodeSession: randomUUID() };
   return { cwd, ...env ? { env } : {}, ...warm, ...toClaudeCodeMcp(mcpServers) ?? {} };
 }
-function providerOptionsFor(model, cwd, mcpServers) {
-  return cursorProviderOptions(model, cwd, mcpServers) ?? claudeCodeProviderOptions(model, cwd, mcpServers);
+function providerOptionsFor(model, cwd, mcpServers, hostMcpServers) {
+  return cursorProviderOptions(model, cwd, mcpServers, hostMcpServers) ?? claudeCodeProviderOptions(model, cwd, mcpServers);
 }
 async function buildAgent(o) {
   if (typeof o.sandbox !== "boolean")
@@ -9578,12 +10062,14 @@ Reference files in them by their mount path (the left side).`;
   const hooks = o.learnFromMistakes && memoryWriteDir ? composeHooks(o.hooks, lessonCapture({ fs, dir: memoryWriteDir, minRepeats: 2 })) : o.hooks;
   let realShell = [];
   const agentRef = {};
+  const jobRegistry = new JobRegistry();
   const useRealShell = o.realShell ?? !virtual;
   if (useRealShell && !virtual && !isClaudeCode) {
     const jobs = new ShellJobRegistry({
       cwd,
       killOnExit: true,
       osSandbox: o.osSandbox,
+      jobs: jobRegistry,
       onExit: (n) => agentRef.agent?.inject(formatJobExit(n))
     });
     realShell = [makeRealShellTool({ cwd, registry: jobs, osSandbox: o.osSandbox, jobsSurviveRun: o.singleRun !== true }), ...makeShellJobTools(jobs)];
@@ -9592,6 +10078,7 @@ Reference files in them by their mount path (the left side).`;
   const scratch = scratchDir ? new Scratch(fs, { dir: scratchDir }) : void 0;
   return agentRef.agent = new Agent({
     ai: o.ai,
+    jobs: jobRegistry,
     fs,
     model: o.model ?? "anthropic/claude-sonnet-4-6",
     // PDF reads (disk mode only — VFS paths aren't real files): poppler's pdftotext when installed.
@@ -9603,7 +10090,7 @@ Reference files in them by their mount path (the left side).`;
     // Warm cursor session (default on; CURSOR_WARM=0 to disable): one long-lived agent reused across
     // turns, amortising the ~2s Agent.create + h2 handshake. Keyed per agentx launch.
     ...(() => {
-      const po = providerOptionsFor(o.model, cwd, o.mcpServers);
+      const po = providerOptionsFor(o.model, cwd, o.mcpServers, o.hostMcpServers);
       return po ? { providerOptions: po } : {};
     })(),
     ...(() => {
@@ -9704,7 +10191,7 @@ import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as rea
 import { homedir as homedir3 } from "os";
 import { dirname as dirname3, join as join6 } from "path";
 import { fileURLToPath } from "url";
-var log19 = forComponent("VoiceIO");
+var log20 = forComponent("VoiceIO");
 var now3 = () => performance.now();
 var Player = class {
   proc = null;
@@ -9718,7 +10205,7 @@ var Player = class {
       ["-loglevel", "quiet", "-nodisp", "-fflags", "nobuffer", "-flags", "low_delay", "-probesize", "32", "-f", "s16le", "-ar", String(TTS_SAMPLE_RATE), "-ch_layout", "mono", "-i", "-"],
       { stdio: ["pipe", "ignore", "ignore"] }
     );
-    this.proc.on("error", (e) => log19.warn(`ffplay error: ${e.message}`));
+    this.proc.on("error", (e) => log20.warn(`ffplay error: ${e.message}`));
     this.proc.stdin.on("error", () => {
     });
     this.bytesWritten = 0;
@@ -9756,7 +10243,7 @@ function detectFfmpegMic() {
   const devices = [...audio.matchAll(/\[(\d+)\] (.+)/g)].map(([, idx, name]) => ({ idx, name: name.trim() }));
   const mic = devices.find((d) => /microphone|built-in/i.test(d.name) && !/teams|blackhole|loopback/i.test(d.name)) ?? devices[0];
   if (!mic) throw new Error("no audio input device found");
-  log19.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
+  log20.debug(`ffmpeg mic: [${mic.idx}] ${mic.name}`);
   return `:${mic.idx}`;
 }
 function detectedInputDevice() {
@@ -9792,15 +10279,15 @@ function resolveAecBinary() {
   if (existsSync4(bin) && statSync4(bin).mtimeMs >= statSync4(src).mtimeMs) return bin;
   if (spawnSync2("which", ["swiftc"]).status !== 0) return null;
   mkdirSync5(cacheDir, { recursive: true });
-  log19.info("compiling AEC mic helper (first run)\u2026");
+  log20.info("compiling AEC mic helper (first run)\u2026");
   const build = spawnSync2("swiftc", ["-O", "-o", bin, src, "-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist", "-Xlinker", plist], { encoding: "utf8" });
   if (build.status !== 0) {
-    log19.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
+    log20.warn(`AEC build failed: ${build.stderr?.slice(0, 400)}`);
     return null;
   }
   const sign = spawnSync2("codesign", ["-fs", "-", bin], { encoding: "utf8" });
   if (sign.status !== 0) {
-    log19.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
+    log20.warn(`codesign failed: ${sign.stderr?.slice(0, 200)}`);
     return null;
   }
   return bin;
@@ -9842,16 +10329,16 @@ var NodeMicSource = class {
       this.proc = spawn2(this.bin, [], { stdio: ["ignore", "pipe", "ignore"] });
     } else {
       if (spawnSync2("which", ["ffmpeg"]).status !== 0) throw new Error("voice I/O unavailable: no AEC helper and no ffmpeg on PATH");
-      log19.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
+      log20.info("mic: raw capture (no AEC) \u2014 echo handled heuristically; headphones recommended");
       this.proc = spawn2(
         "ffmpeg",
         ["-loglevel", "error", "-f", "avfoundation", "-i", detectFfmpegMic(), "-ar", String(STT_SAMPLE_RATE), "-ac", "1", "-f", "s16le", "-"],
         { stdio: ["ignore", "pipe", "pipe"] }
       );
-      this.proc.stderr.on("data", (d) => log19.warn(`ffmpeg: ${String(d).trim()}`));
+      this.proc.stderr.on("data", (d) => log20.warn(`ffmpeg: ${String(d).trim()}`));
     }
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log19.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
+      if (c && !this.stopped) log20.error(`mic capture exited (${c}) \u2014 check mic permission / MIC_DEVICE / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => onChunk(chunk));
   }
@@ -9917,7 +10404,7 @@ var AecDuplexAudio = class {
     this.proc.stdin.on("error", () => {
     });
     this.proc.on("exit", (c) => {
-      if (c && !this.stopped) log19.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
+      if (c && !this.stopped) log20.error(`aec duplex audio exited (${c}) \u2014 check mic permission / MIC_AEC=0`);
     });
     this.proc.stdout.on("data", (chunk) => {
       this.gotChunk = true;
@@ -9933,7 +10420,7 @@ var AecDuplexAudio = class {
             openMicSettings();
             this.onFatal?.("microphone permission denied \u2014 enable it in System Settings \u2192 Privacy & Security \u2192 Microphone for your terminal, then restart it");
           }
-        } else log19.debug(`mic-aec: ${s}`);
+        } else log20.debug(`mic-aec: ${s}`);
       }
     });
     if (!this.noVpio && !this.triedFallback) {
@@ -9942,7 +10429,7 @@ var AecDuplexAudio = class {
         this.triedFallback = true;
         this.noVpio = true;
         this._aec = false;
-        log19.warn("mic-aec: VPIO delivered no audio in 2.5s \u2014 falling back to non-VPIO capture (no AEC \u2192 half-duplex, no barge-in)");
+        log20.warn("mic-aec: VPIO delivered no audio in 2.5s \u2014 falling back to non-VPIO capture (no AEC \u2192 half-duplex, no barge-in)");
         this.onDegrade?.();
         this.killProc();
         this.spawnHelper();
@@ -10162,7 +10649,7 @@ function fakeVoiceParts(uttFile) {
 init_logging();
 import { appendFile, mkdirSync as mkdirSync6 } from "fs";
 import { dirname as dirname4 } from "path";
-var log20 = forComponent("VoiceDiag");
+var log21 = forComponent("VoiceDiag");
 var JsonlDiagSink = class {
   constructor(path) {
     this.path = path;
@@ -10203,7 +10690,7 @@ var JsonlDiagSink = class {
   disable(e) {
     this.disabled = true;
     this.queue.length = 0;
-    log20.debug(`voice diag sink disabled (${this.path}): ${e instanceof Error ? e.message : e}`);
+    log21.debug(`voice diag sink disabled (${this.path}): ${e instanceof Error ? e.message : e}`);
   }
   /** True once a failure permanently disabled the sink (tests/inspection). */
   get isDisabled() {
@@ -10273,7 +10760,7 @@ async function loadConfig(cwd) {
 
 // cli/hooks-config.ts
 import { spawnSync as spawnSync3 } from "child_process";
-var log21 = forComponent("hooks");
+var log22 = forComponent("hooks");
 var escapeRegex = (s) => s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
 function ruleMatches(rule, toolName) {
   if (!rule.tool || rule.tool === "*") return true;
@@ -10290,7 +10777,7 @@ function runCmd(rule, env) {
     });
     return { code: r.status ?? 1, out: ((r.stdout ?? "") + (r.stderr ?? "")).trim() };
   } catch (e) {
-    log21.debug(`hook command failed: ${rule.command}`, e);
+    log22.debug(`hook command failed: ${rule.command}`, e);
     return { code: 1, out: String(e?.message ?? e) };
   }
 }
@@ -10397,7 +10884,7 @@ function formatDiff(ops, opts = {}) {
 import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4, readdirSync, renameSync, symlinkSync as symlinkSync2, unlinkSync, readlinkSync } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
-var log22 = forComponent("session");
+var log23 = forComponent("session");
 var globalDir = () => join8(homedir5(), ".agent", "sessions");
 var SessionStore = class {
   dir;
@@ -10442,7 +10929,7 @@ var SessionStore = class {
   }
   load(id) {
     if (!this.safeId(id)) {
-      log22.debug(`rejecting unsafe session id: ${id}`);
+      log23.debug(`rejecting unsafe session id: ${id}`);
       return void 0;
     }
     const path = join8(this.dir, `${id}.json`);
@@ -10450,7 +10937,7 @@ var SessionStore = class {
     try {
       return JSON.parse(readFileSync7(path, "utf8"));
     } catch (e) {
-      log22.debug(`unreadable session ${id} \u2014 ignoring`, e);
+      log23.debug(`unreadable session ${id} \u2014 ignoring`, e);
       return void 0;
     }
   }
@@ -10463,7 +10950,7 @@ var SessionStore = class {
       try {
         metas.push(JSON.parse(readFileSync7(join8(this.dir, f), "utf8")).meta);
       } catch (e) {
-        log22.debug(`skipping unreadable session file ${f}`, e);
+        log23.debug(`skipping unreadable session file ${f}`, e);
       }
     }
     return metas.sort((a, b) => b.updated - a.updated);
@@ -10632,7 +11119,7 @@ import { promisify } from "util";
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join9, resolve as resolve3, sep as sep3, parse as parsePath } from "path";
-var log23 = forComponent("checkpoints");
+var log24 = forComponent("checkpoints");
 var exec = promisify(execFile3);
 var DEFAULT_EXCLUDE = [".agent/", ".git/", "node_modules/", "dist/", "build/", ".next/", "target/", ".venv/", "__pycache__/", "*.log"];
 function isBroadRoot(p) {
@@ -10678,7 +11165,7 @@ var ShadowRepo = class {
       writeFileSync5(join9(this.gitDir, "info", "exclude"), this.exclude.join("\n") + "\n");
       this.ready = true;
     } catch (e) {
-      log23.debug(`git checkpoints unavailable for ${this.workTree}`, e);
+      log24.debug(`git checkpoints unavailable for ${this.workTree}`, e);
       this.ready = false;
     }
     return this.ready;
@@ -10689,7 +11176,7 @@ var ShadowRepo = class {
   }
   async commit(label, forced = []) {
     await this.run("add", "-A");
-    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log23.debug(`force-add failed: ${p}`, e));
+    for (const p of forced) await this.run("add", "-f", "--", p).catch((e) => log24.debug(`force-add failed: ${p}`, e));
     await this.run("commit", "--allow-empty", "-q", "-m", label);
   }
   /** Inject the CURRENT (pre-edit) content of `paths` into the turn-open restore point by amending it.
@@ -10697,8 +11184,8 @@ var ShadowRepo = class {
    *  turn-boundary `add -A` would never have captured it. Amend (vs a new commit) keeps one restore
    *  point per turn, so the REPL's turn↔frame mapping stays intact. */
   async amendForced(paths) {
-    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log23.debug(`force-capture failed: ${p}`, e));
-    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log23.debug("amend failed", e));
+    for (const p of paths) await this.run("add", "-f", "--", p).catch((e) => log24.debug(`force-capture failed: ${p}`, e));
+    await this.run("commit", "--amend", "--no-edit", "-q", "--allow-empty").catch((e) => log24.debug("amend failed", e));
   }
   /** Commits on `ref`, oldest-first (canonical index space). */
   async log(ref) {
@@ -10758,7 +11245,7 @@ var ShadowRepo = class {
       await this.run("gc", "--auto", "-q").catch(() => {
       });
     } catch (e) {
-      log23.debug("checkpoint prune failed", e);
+      log24.debug("checkpoint prune failed", e);
     }
   }
 };
@@ -10826,7 +11313,7 @@ var GitCheckpoints = class {
   use(sessionId) {
     if (sessionId === this.session) return;
     this.session = sessionId;
-    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log23.debug("re-point failed", e));
+    if (this.started) for (const r of this.repos) void r.point(this.ref()).catch((e) => log24.debug("re-point failed", e));
   }
   async begin(label) {
     if (!await this.start()) return;
@@ -10846,7 +11333,7 @@ var GitCheckpoints = class {
           process.stderr.write(`\x1B[2m  checkpoints: '${this.repos[i].root}' too large to snapshot in ${Math.round(this.options.opTimeoutMs / 1e3)}s \u2014 file rewind disabled here\x1B[0m
 `);
         } else {
-          log23.debug("checkpoint commit failed", e);
+          log24.debug("checkpoint commit failed", e);
           survivors.push(this.repos[i]);
           survivorCaches.push(this.caches[i] ?? []);
         }
@@ -10881,7 +11368,7 @@ var GitCheckpoints = class {
           if (this.forced.has(abs)) continue;
           this.forced.add(abs);
           const i = this.repoIndexFor(abs);
-          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log23.debug("amendForced failed", e));
+          if (i >= 0) await this.repos[i].amendForced([abs]).catch((e) => log24.debug("amendForced failed", e));
         }
       }
     };
@@ -12704,7 +13191,7 @@ import { spawnSync as spawnSync5 } from "child_process";
 import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync10, readdirSync as readdirSync2, unlinkSync as unlinkSync3, chmodSync, existsSync as existsSync7 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join12 } from "path";
-var log24 = forComponent("os-sched");
+var log25 = forComponent("os-sched");
 var OsScheduler = class {
   options;
   constructor(options) {
@@ -12766,7 +13253,7 @@ var OsScheduler = class {
         }
       }
     } catch (e) {
-      log24.debug(`cancel ${id}`, e);
+      log25.debug(`cancel ${id}`, e);
     }
     for (const f of [`${id}.json`, `${id}.sh`]) {
       try {
@@ -12883,7 +13370,7 @@ import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync11, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join13 } from "path";
-var log25 = forComponent("remote-trigger");
+var log26 = forComponent("remote-trigger");
 var TRIGGER_DIR = () => join13(homedir9(), ".agent", "triggers");
 var sockPath = (sessionId, dir = TRIGGER_DIR()) => join13(dir, `${sessionId}.sock`);
 var TriggerServer = class {
@@ -12921,13 +13408,13 @@ var TriggerServer = class {
             conn.end(JSON.stringify({ ok: false, error: String(e) }) + "\n");
           }
         });
-        conn.on("error", (e) => log25.debug("trigger conn error", e));
+        conn.on("error", (e) => log26.debug("trigger conn error", e));
       });
-      this.server.on("error", (e) => log25.debug("trigger server error", e));
+      this.server.on("error", (e) => log26.debug("trigger server error", e));
       this.server.listen(p);
       this.path = p;
     } catch (e) {
-      log25.debug("trigger server unavailable", e);
+      log26.debug("trigger server unavailable", e);
     }
   }
   /** Re-bind on /resume (the session id changed). */
@@ -13049,7 +13536,7 @@ var strike = C("9");
 var link = (text, url) => useColor ? `\x1B]8;;${url}\x1B\\${cyan(text)}\x1B]8;;\x1B\\` : `${text} (${url})`;
 var mdPalette = { bold, dim, cyan, italic, strike, green, link };
 var err = (s) => process.stderr.write(s);
-var log26 = forComponent("cli");
+var log27 = forComponent("cli");
 var VERSION = (() => {
   try {
     return JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8")).version ?? "?";
@@ -13099,9 +13586,9 @@ var spinner = /* @__PURE__ */ (() => {
       if (!tty || timer) return;
       t0 = this.turnStart || Date.now();
       timer = setInterval(() => {
-        const secs = Math.round((Date.now() - t0) / 1e3);
+        const secs2 = Math.round((Date.now() - t0) / 1e3);
         const tail = this.tail?.();
-        err("\r\x1B[2K" + dim(`  ${frames[i = (i + 1) % frames.length]} ${label} ${secs ? `${secs}s \xB7 ` : ""}esc to interrupt`) + (tail ? "  " + tail : ""));
+        err("\r\x1B[2K" + dim(`  ${frames[i = (i + 1) % frames.length]} ${label} ${secs2 ? `${secs2}s \xB7 ` : ""}esc to interrupt`) + (tail ? "  " + tail : ""));
       }, 90);
     },
     stop() {
@@ -13794,7 +14281,7 @@ function costOf(pricing, promptTokens = 0, completionTokens = 0, cacheCreationTo
 function turnCost(model, usage) {
   return costOf(getModelInfo(model)?.pricing, usage?.promptTokens ?? 0, usage?.completionTokens ?? 0, usage?.cacheCreationTokens ?? 0, usage?.cacheReadTokens ?? 0, model);
 }
-async function evaluateGoal(ai, condition, transcript, log27) {
+async function evaluateGoal(ai, condition, transcript, log28) {
   const recent = transcript.filter((m) => m.role === "assistant").slice(-8).map((m) => {
     const text = typeof m.content === "string" ? m.content : m.content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
     return text.slice(0, 600);
@@ -13814,7 +14301,7 @@ ${recent}` }
     const match = r.content.match(/\{[\s\S]*\}/);
     if (match) return JSON.parse(match[0]);
   } catch (e) {
-    log27(dim(`  (goal evaluator error: ${e?.message ?? e})
+    log28(dim(`  (goal evaluator error: ${e?.message ?? e})
 `));
   }
   return { met: false, reason: "evaluation unclear" };
@@ -13982,7 +14469,7 @@ function optsFor(args, ai, cfg = {}, extraTools = []) {
     anthropicWebSearch: cfg.anthropicWebSearch
   };
 }
-async function makeAgent(args, ai, cfg, extraTools = []) {
+async function makeAgent(args, ai, cfg, extraTools = [], hostMcpServers) {
   const virtual = args.vfs || !!args.boddb;
   if (virtual && args.shell) err(yellow(`  \u26A0 --shell ignored in ${args.boddb ? "--boddb" : "--vfs sandbox"} (a real shell would escape to disk)
 `));
@@ -13996,7 +14483,7 @@ async function makeAgent(args, ai, cfg, extraTools = []) {
   else if (args.shell === false) err(dim("  \u2296 --no-shell: VFS bash only (no real /bin/sh)\n"));
   if (args.harden && !virtual) err(dim(`  \u26E8 hardened shell: writes confined to cwd+tmp${args.hardenNet ? "" : ", network blocked"} (sandbox-exec/bwrap)
 `));
-  const opts = optsFor(args, ai, cfg, extraTools);
+  const opts = { ...optsFor(args, ai, cfg, extraTools), hostMcpServers };
   const agent = await buildAgent(opts);
   const display = displayHooks(agent.options.fs, { flush: agent.options.host?.flushText });
   agent.options.hooks = cfg.hooks ? composeHooks(display, hooksFromConfig(cfg.hooks)) : display;
@@ -14035,7 +14522,7 @@ function mcpAgentTools(mounted, opts) {
   return tools;
 }
 async function closeMcp(mounted) {
-  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log26.debug("mcp close failed", e))));
+  await Promise.all(mounted.map((m) => m.client.close().catch((e) => log27.debug("mcp close failed", e))));
 }
 var IMG_EXT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
 function mentionRefs(line) {
@@ -14087,7 +14574,7 @@ async function expandMentions(fs, line) {
     if (loaded.includes(ref) || missing.includes(ref)) continue;
     if (ref.includes(":") && mcpMentionResolver) {
       const body = await mcpMentionResolver(ref).catch((e) => {
-        log26.debug("mcp mention resolve failed", e);
+        log27.debug("mcp mention resolve failed", e);
         return null;
       });
       if (body != null) {
@@ -14174,7 +14661,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
       try {
         store.save(session);
       } catch (ex) {
-        log26.debug("mid-turn session flush failed", ex);
+        log27.debug("mid-turn session flush failed", ex);
       }
     }
     return origNotify(e);
@@ -14201,7 +14688,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
   }
   agent.options.host?.flushText?.();
   flushLookupGroup();
-  const secs = ((Date.now() - t0) / 1e3).toFixed(1);
+  const secs2 = ((Date.now() - t0) / 1e3).toFixed(1);
   const cost = turnCost(agent.options.model, res.usage);
   const m = res.usageEstimated ? "~" : "";
   const tok = res.usage?.totalTokens ? `${m}${(res.usage.totalTokens / 1e3).toFixed(1)}k tok \xB7 ${cost > 0 ? m + fmtUsd(cost) + " \xB7 " : ""}` : "";
@@ -14212,7 +14699,7 @@ async function runTurn(agent, store, session, task, cp, cwd = process.cwd(), sen
   const didWork = agent.transcript.slice(msgsBefore).some((m2) => m2.role === "assistant" || m2.role === "tool");
   const silentAbort = res.finishReason === "aborted" && !res.usage?.totalTokens && !didWork;
   if (!silentAbort)
-    err("\n" + (process.stderr.isTTY ? "\r\x1B[0J" : "") + (ok ? green("  \u2713 done") : res.finishReason === "needs_input" ? yellow("  ? needs input") : red(`  \u2717 ${res.finishReason}`)) + dim(` \xB7 ${res.steps} steps \xB7 ${tools} tools \xB7 ${tok}${secs}s \xB7 ${shortId}
+    err("\n" + (process.stderr.isTTY ? "\r\x1B[0J" : "") + (ok ? green("  \u2713 done") : res.finishReason === "needs_input" ? yellow("  ? needs input") : red(`  \u2717 ${res.finishReason}`)) + dim(` \xB7 ${res.steps} steps \xB7 ${tools} tools \xB7 ${tok}${secs2}s \xB7 ${shortId}
 `));
   if (!silentAbort && process.stderr.isTTY && Date.now() - t0 > 1e4) err("\x07");
   if (res.finishReason === "error" && res.error) {
@@ -14323,14 +14810,14 @@ var isCancelTeardown = (e) => {
 function installCancelGuards(mounted) {
   process.on("unhandledRejection", (e) => {
     if (isCancelTeardown(e)) {
-      log26.debug("suppressed unhandledRejection (cursor stream cancel)", e);
+      log27.debug("suppressed unhandledRejection (cursor stream cancel)", e);
       return;
     }
-    log26.error("unhandledRejection", e);
+    log27.error("unhandledRejection", e);
   });
   process.on("uncaughtException", (e) => {
     if (isCancelTeardown(e)) {
-      log26.debug("suppressed uncaughtException (cursor stream cancel)", e);
+      log27.debug("suppressed uncaughtException (cursor stream cancel)", e);
       return;
     }
     console.error(e);
@@ -14344,7 +14831,7 @@ async function repl(args, ai, cfg, cwd) {
   let mcpToolNames = [];
   const initialMcpTools = mcpAgentTools(mounted);
   mcpToolNames = initialMcpTools.map((t) => t.name);
-  const agent = await makeAgent(args, ai, cfg, initialMcpTools);
+  const agent = await makeAgent(args, ai, cfg, initialMcpTools, mounted.map((m) => m.name));
   if (args.voice && !args.duplex) agent.options.tools = [...agent.options.tools ?? [], exitSessionTool(() => {
     exitRequested = true;
   })];
@@ -14586,7 +15073,7 @@ async function repl(args, ai, cfg, cwd) {
       ...args.voiceModel ?? cfg.reflexModel ? { reflexModel: resolveModelOrNewest(args.voiceModel ?? cfg.reflexModel) } : {},
       actModel: agent.options.model,
       actOptions: workerOptions,
-      providerOptionsFor: (m) => providerOptionsFor(m, cwd, cfg.mcpServers),
+      providerOptionsFor: (m) => providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name)),
       ...(args.thinkModel ?? cfg.thinkModel) !== void 0 ? { thinkModel: (args.thinkModel ?? cfg.thinkModel) === false ? false : resolveModelOrNewest(String(args.thinkModel ?? cfg.thinkModel)) } : {},
       host,
       ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, askRelay: true, emotionTags: emotionsOn } : {},
@@ -14668,7 +15155,7 @@ async function repl(args, ai, cfg, cwd) {
   const setModel = (m) => {
     work.model = m;
     work.contextWindow = getModelInfo(m)?.contextWindow ?? 0;
-    work.providerOptions = providerOptionsFor(m, cwd, cfg.mcpServers);
+    work.providerOptions = providerOptionsFor(m, cwd, cfg.mcpServers, mounted.map((x) => x.name));
     if (dx) dx.options.actModel = m;
     persistModel(cwd, m);
     err(dim("  model \u2192 " + m + "\n"));
@@ -14735,7 +15222,7 @@ async function repl(args, ai, cfg, cwd) {
     try {
       mkdirSync12(dir, { recursive: true });
     } catch (e) {
-      log26.debug("paste image dir create failed", e);
+      log27.debug("paste image dir create failed", e);
     }
     const img = grabClipboardImage(dir, String(Date.now()));
     return img ? { display: "Image", ref: "@" + img.path, path: img.path } : null;
@@ -14848,7 +15335,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
       mkdirSync12(join14(cwd, ".agent"), { recursive: true });
       appendFileSync(histPath, line + "\n");
     } catch (e) {
-      log26.debug("history write failed", e);
+      log27.debug("history write failed", e);
     }
   };
   const ago = (t) => {
@@ -14920,7 +15407,7 @@ Added entries are loadable now via the Skill/SlashCommand tools; removed ones ar
       try {
         store.save(session);
       } catch (e) {
-        log26.debug("session save after rewind failed", e);
+        log27.debug("session save after rewind failed", e);
       }
       err(green("  \u27F2 jumped back") + dim(` \u2014 ${face.transcript.length} message(s) kept; edit + resend
 `));
@@ -14954,7 +15441,7 @@ ${task}`;
       bangContext.length = 0;
     }
     const delta = await refreshCatalogs().catch((e) => {
-      log26.debug("catalog refresh failed", e);
+      log27.debug("catalog refresh failed", e);
       return "";
     });
     if (delta) {
@@ -15218,7 +15705,7 @@ ${task}`;
       desc: "rescan skills/commands dirs and rebuild the system prompt (one cache miss) \u2014 picks up entries created mid-session",
       run: async () => {
         await refreshCatalogs().catch((e) => {
-          log26.debug("catalog refresh failed", e);
+          log27.debug("catalog refresh failed", e);
         });
         face.reprepare();
         err(green(`  \u2713 reloaded \u2014 ${skills.length} skill(s), ${cmds.length} command(s); system prompt rebuilds on next message
@@ -15720,7 +16207,7 @@ ${task}`;
           try {
             for (const def of (await loadAgents(fs2, d)).agents) if (!seen.has(def.name)) seen.set(def.name, { def, from: d });
           } catch (e) {
-            log26.debug(`loadAgents(${d}) failed`, e);
+            log27.debug(`loadAgents(${d}) failed`, e);
           }
         }
         if (!seen.size) {
@@ -15808,7 +16295,7 @@ ${task}`;
           }
           if (idx >= 0) {
             const old = mounted.splice(idx, 1)[0];
-            await old.client.close().catch((e) => log26.debug("mcp close failed", e));
+            await old.client.close().catch((e) => log27.debug("mcp close failed", e));
           }
           try {
             const m = await mountMcpServer(name, conf);
@@ -15836,7 +16323,7 @@ ${task}`;
           }
           const m = mounted.splice(idx, 1)[0];
           remountMcpTools();
-          await m.client.close().catch((e) => log26.debug("mcp close failed", e));
+          await m.client.close().catch((e) => log27.debug("mcp close failed", e));
           err(dim(`  removed "${name}"
 `));
           return;
@@ -16039,16 +16526,16 @@ ${task}`;
     try {
       return readdirSync4(join14(cwd, absDir.replace(/^\/+/, "")), { withFileTypes: true }).map((d) => ({ name: d.name, dir: d.isDirectory() }));
     } catch (e) {
-      log26.debug("completion readdir failed", absDir, e);
+      log27.debug("completion readdir failed", absDir, e);
       return null;
     }
   };
   const agentCommandNames = () => [...cmds.map((c) => c.name), ...skills.map((s) => s.name)];
   const commandNames = () => [...Object.keys(builtins).filter((k) => k !== "quit"), ...agentCommandNames()];
-  const describe = (hit) => hit.startsWith("/") ? builtins[hit.slice(1)]?.desc ?? cmds.find((c) => c.name === hit.slice(1))?.description ?? skills.find((s) => s.name === hit.slice(1))?.description : void 0;
+  const describe2 = (hit) => hit.startsWith("/") ? builtins[hit.slice(1)]?.desc ?? cmds.find((c) => c.name === hit.slice(1))?.description ?? skills.find((s) => s.name === hit.slice(1))?.description : void 0;
   const suggest = (lineToCursor) => {
     const [hits, token] = completeLine(lineToCursor, { commands: commandNames(), agentCommands: agentCommandNames(), listDir, bangHistory: history });
-    return { hits, token, describe };
+    return { hits, token, describe: describe2 };
   };
   const editor = createLineEditor(process.stderr);
   editorRef = editor;
@@ -16175,7 +16662,7 @@ ${out}
         return;
       }
       await refreshCatalogs().catch((e) => {
-        log26.debug("catalog refresh failed", e);
+        log27.debug("catalog refresh failed", e);
       });
       const sk = skills.find((x) => x.name === name);
       if (sk) {
@@ -16663,7 +17150,7 @@ async function main() {
   });
   if (args.task) {
     const mounted = await mountMcp(cfg, new McpOAuth({ storePath: join14(cwd, ".agent", "mcp-auth.json") }));
-    const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted));
+    const agent = await makeAgent(args, ai, cfg, mcpAgentTools(mounted), mounted.map((m) => m.name));
     const store = new SessionStore(cwd);
     const session = startSession(args, store, agent, cwd);
     process.once("SIGINT", () => activeTurn?.abort());