@livx.cc/agentx 0.99.47 → 0.99.49

package/dist/index.js

@@ -1511,6 +1511,404 @@ 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 now3 = registry.options.now();
+        if (!id) {
+          const all = registry.list();
+          return all.length ? all.map((j2) => describe(j2, now3)).join("\n") : "(no background jobs)";
+        }
+        const j = registry.get(String(id));
+        return j ? describe(j, now3) : 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, SandboxJobRegistry, 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).
+       *  NOTE the asymmetry that default hides: for a HOST job silence really is uninformative (the caller holds
+       *  the pending dispatch promise — independent proof it is alive), but a NATIVE job has no such proof AND it
+       *  suppresses the stall watchdog, i.e. it turns the provider's own silence into permission to keep ignoring
+       *  that provider's silence. So Agent passes an explicit per-job `idleMs` (nativeHoldMs) for `native`: the
+       *  provider must keep re-proving liveness with `running` events or forfeit the hold. See Agent.nativeHoldMs. */
+      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 now3 = o.now();
+        let settle;
+        const done = new Promise((r) => {
+          settle = r;
+        });
+        const job = {
+          id: `job-${++this.seq}`,
+          kind,
+          label: opts.label ?? "",
+          status: "running",
+          startedAt: now3,
+          lastActivityAt: now3,
+          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 now3 = this.options.now();
+        const killed = [];
+        for (const j of this.jobs.values()) {
+          if (j.status !== "running") continue;
+          const verdict = this.verdict(j, now3);
+          if (!verdict || verdict.idle && j.cpuTime) continue;
+          this.stuck(j, verdict.reason, now3);
+          killed.push(j.id);
+        }
+        return killed;
+      }
+      /** Full sweep: sample CPU probes (advancing CPU = activity), then `reap()` including probed jobs. */
+      async sweep() {
+        const now3 = 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, now3);
+          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)`, now3);
+        }
+        return this.reap();
+      }
+      verdict(j, now3) {
+        if (j.hardCapMs && now3 - j.startedAt >= j.hardCapMs) return { reason: `stuck: exceeded hard cap ${secs(j.hardCapMs)}`, idle: false };
+        if (j.idleMs && (!j.idleAfterActivity || j.active) && now3 - j.lastActivityAt >= j.idleMs) return { reason: `stuck: idle ${secs(now3 - j.lastActivityAt)}`, idle: true };
+        return null;
+      }
+      stuck(j, reason, now3) {
+        log5.warn(`reaping ${j.id} (${j.kind} "${j.label}"): ${reason} \u2014 age ${secs(now3 - j.startedAt)}, last activity ${secs(now3 - 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;
+      }
+    };
+    SandboxJobRegistry = class extends JobRegistry {
+      constructor(maxBuffer) {
+        super(typeof maxBuffer === "number" ? { maxBuffer } : maxBuffer);
+      }
+    };
+    NO_JOB = (id) => `Error: no background job '${id}'. Use JobStatus with no id to list jobs.`;
+    describe = (j, now3) => `${j.id}  ${j.status}${j.reason ? ` (${j.reason})` : ""}  ${j.kind}${j.label ? "  " + j.label : ""}  \xB7 ${secs((j.endedAt ?? now3) - j.startedAt)} old \xB7 last activity ${secs(now3 - j.lastActivityAt)} ago \xB7 ${j.bytes} byte(s)`;
+  }
+});
+
 // src/NodeDiskFilesystem.ts
 var NodeDiskFilesystem_exports = {};
 __export(NodeDiskFilesystem_exports, {
@@ -1954,7 +2352,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;
@@ -1984,10 +2385,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 } = await import("child_process");
+    const out = await new Promise((res, rej) => execFile("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) {
+    log8.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);
@@ -2118,7 +2548,7 @@ function makeRealShellTool(options) {
           proc.stderr?.on("data", collect);
           proc.on("error", (err) => {
             if (err?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
-            log7.debug("shell spawn error", err);
+            log8.debug("shell spawn error", err);
             finish(`[exit 1] ${err?.message ?? err}${out ? "\n" + clean(out) : ""}`);
           });
           proc.on("close", (code) => {
@@ -2138,7 +2568,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;
@@ -2162,7 +2592,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)"}`;
       }
     },
@@ -2177,13 +2607,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));
@@ -2191,7 +2621,7 @@ ${clean(out) || "(no output yet)"}`;
     }
   ];
 }
-var log7, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, NO_JOB2;
+var log8, clean, DETACHED, SECRET_ENV_RE, _spawn, ShellJobRegistry, shellStatus, NO_JOB2;
 var init_tools_shell = __esm({
   "src/tools.shell.ts"() {
     "use strict";
@@ -2199,62 +2629,94 @@ var init_tools_shell = __esm({
     init_redact();
     init_logging();
     init_shell_sandbox();
-    log7 = forComponent("shell");
+    init_tools_jobs();
+    log8 = 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 spawn = 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 = spawn(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", (err) => {
-            if (job.status === "running") {
-              job.status = "error";
-              append(`
-[error] ${err?.message ?? err}`);
-              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, spawn(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));
+        }
+        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", (err) => {
+          if (h.status === "running") {
+            append(`
+[error] ${err?.message ?? err}`);
+            h.finish("error", void 0, err?.message ?? String(err));
+          }
+        });
+        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 {
+          }
         }
-        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);
+        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 {
         }
       }
@@ -2273,14 +2735,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
@@ -2288,53 +2756,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", (err) => {
-          if (job.status === "running") {
-            job.status = "error";
-            append(`
-[error] ${err?.message ?? err}`);
-            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}).`;
   }
 });
@@ -2342,111 +2779,7 @@ var init_tools_shell = __esm({
 // 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 = {
@@ -3229,7 +3562,7 @@ function exitWorktree() {
 // src/subagent.ts
 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;
@@ -3303,7 +3636,7 @@ function traceFileFor(dir, label, depth) {
     const id = `${Date.now().toString(36)}-${(traceSeq++).toString(36)}`;
     return join3(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;
   }
 }
@@ -3311,7 +3644,7 @@ function flushTrace(file, meta, messages, status) {
   try {
     writeFileSync(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) {
@@ -3352,7 +3685,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 });
@@ -3806,7 +4139,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;
@@ -3843,6 +4176,15 @@ var AgentOptions = class {
    *  arrives for this long. The between-steps `timeoutMs` can't preempt an in-flight `chat()`, so a
    *  provider that goes silent mid-stream would otherwise park the loop forever. 0 = off. */
   stallMs = 6e4;
+  /** IDLE bound on a NATIVE delegated tool's hold over the stall watchdog (cursor's own shell/mcp/task:
+   *  `running` → silence → `completed`). Such a hold is the provider's own unverified CLAIM that it is
+   *  busy, and it SUSPENDS the very stall detection that would catch that provider going silent — so its
+   *  only backstop was `hardCapMs = toolHoldMs`, the TRANSPORT deadline (≥30m, sized for host-tool
+   *  round-trips a native call never makes). A wedged native call therefore bought 30m of total silence,
+   *  ×2 attempts = the 61-minute zero-output run (blank 2026-09-18). Idle, not absolute: every further
+   *  `running` event `touch()`es the job, so a native tool that keeps reporting progress holds
+   *  indefinitely — what expires is silence, not work. 0 = off (hard cap only). */
+  nativeHoldMs = 3e5;
   /** Stop if the identical tool-call batch (name+args) repeats this many times in a row. 0 = off. */
   maxRepeats = 3;
   /** Cumulative cap on tool calls dispatched across the run. 0 = unbounded. */
@@ -3958,6 +4300,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). */
@@ -4024,17 +4372,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;
-  /** Delegated-runtime NATIVE tools (cursor's own shell/mcp/task) seen `running` but not yet `completed`/`error`,
-   *  id → hold-until. The runtime streams nothing while one runs, so it holds the watchdog like a host tool —
-   *  bounded by the same tool deadline (`toolHoldMs`) so a lost `completed` event can't disable it. */
-  nativeToolsInFlight = /* @__PURE__ */ new Map();
+  /** 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.
+   *  A NATIVE job carries a second, much tighter bound (`idleMs = nativeHoldMs`): the transport deadline is
+   *  sized for a host-tool round-trip it never makes, and silence is the only thing it can actually prove. */
+  jobs;
+  /** Native delegated tool activity id → its job (per step attempt). */
+  nativeJobs = /* @__PURE__ */ new Map();
   toolHoldMs = 0;
+  nativeHoldMs = 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;
@@ -4082,6 +4431,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()
@@ -4133,6 +4483,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). */
@@ -4144,7 +4499,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
@@ -4160,7 +4516,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();
   }
@@ -4230,7 +4586,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());
@@ -4346,8 +4702,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 } : {} };
     };
@@ -4369,22 +4725,26 @@ var Agent = class _Agent {
       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;
+      this.nativeHoldMs = o.nativeHoldMs;
       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?.();
           }
@@ -4398,7 +4758,8 @@ var Agent = class _Agent {
       };
       try {
         for (let attempt = 0; ; attempt++) {
-          this.nativeToolsInFlight.clear();
+          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) {
@@ -4430,11 +4791,11 @@ var Agent = class _Agent {
             const empty = err?.code === "empty" || err?.code === "cursor_silent";
             const maxAttempts = empty ? Math.max(o.emptyRetries, 0) : 2;
             const replaysTool = stalled && this.toolRanThisAttempt;
-            if (replaysTool) log6.warn("model stall after tool(s) already ran this step \u2014 not retrying (a retry would replay them)");
+            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(err) && !replaysTool && attempt < maxAttempts && (network || serverSide || stalled || empty);
             if (!transient) throw err;
             const waitMs = (empty ? o.emptyRetryBaseMs : 1e3) * (attempt + 1);
-            log6.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err?.message ?? err}) \u2014 retrying in ${waitMs}ms`);
+            log7.warn(`${empty ? "empty model turn" : stalled ? "model stall" : "network drop"} mid-step (${err?.message ?? err}) \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 +4803,12 @@ var Agent = class _Agent {
       } catch (err) {
         if (err?.code === "budget") return kill("budget");
         if (err?.code === "stall") {
-          log6.warn(`model stalled out after retries: ${err?.message ?? err}`);
+          log7.warn(`model stalled out after retries: ${err?.message ?? err}`);
           return { ...kill("timeout"), error: err };
         }
         if (o.signal?.aborted || isAbortError(err)) return kill("aborted");
         if (err?.code === "empty" || err?.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: err };
         }
         const body = err?.body ?? err?.response?.data ?? err?.error;
@@ -4459,7 +4820,7 @@ var Agent = class _Agent {
         }
         if (bodyStr && err instanceof Error && !err.message.includes(bodyStr)) err.detail = bodyStr;
         const errLog = err instanceof Error ? { message: err.message, ...err.detail ? { detail: err.detail } : {}, stack: err.stack } : err;
-        log6.error(`chat() failed: ${err?.message ?? err}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
+        log7.error(`chat() failed: ${err?.message ?? err}${bodyStr ? ` \u2014 ${bodyStr}` : ""}`, errLog);
         return { text: "", steps, finishReason: "error", messages: this.transcript, usage, usageEstimated, error: err };
       }
       if (o.signal?.aborted) return kill("aborted");
@@ -4515,21 +4876,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 +4899,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 +4936,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 +4979,15 @@ var Agent = class _Agent {
       if (!stallMs) return;
       if (timer) clearTimeout(timer);
       timer = setTimeout(() => {
-        if (this.toolHoldActive()) return poke();
+        if (this.toolHoldActive()) {
+          const now3 = Date.now();
+          const who = this.jobs.holding().map((j) => `${j.kind} "${j.label}" (${Math.round((now3 - j.startedAt) / 1e3)}s, quiet ${Math.round((now3 - j.lastActivityAt) / 1e3)}s)`).join(", ");
+          log7.warn(`stall watchdog: no stream output for ${stallMs}ms \u2014 held by ${who}`);
+          this.options.host?.notify?.({ kind: "tool_hold", message: `waiting on ${who}` });
+          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,12 +5007,11 @@ var Agent = class _Agent {
       reclassify: (err) => stalled() ? stallError() : err
     };
   }
-  /** A host or native delegated tool is running within its deadline — the provider is quiet, not stalled. */
+  /** 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() {
-    const now3 = Date.now();
-    if (this.hostToolsInFlight > 0 && now3 < this.hostToolHoldUntil) return true;
-    for (const until of this.nativeToolsInFlight.values()) if (now3 < until) return true;
-    return false;
+    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". */
@@ -4679,10 +5051,16 @@ 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 (a.id) this.nativeToolsInFlight.set(a.id, Date.now() + this.toolHoldMs);
+          if (nj) nj.touch();
+          else if (a.id) this.nativeJobs.set(a.id, this.jobs.track({ kind: "native", label: a.name, holds: true, idleMs: this.nativeHoldMs, hardCapMs: this.toolHoldMs }));
         } else {
-          if (a.id) this.nativeToolsInFlight.delete(a.id);
+          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;
@@ -4773,13 +5151,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;
@@ -4788,12 +5166,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);
@@ -4805,7 +5183,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 {
@@ -4897,6 +5275,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;
@@ -5072,7 +5451,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) {
@@ -5468,6 +5847,7 @@ var toolCall = (id, name, args) => ({
 
 // src/index.ts
 init_tools();
+init_tools_jobs();
 
 // src/scheduler.ts
 function parseCronField(field, min, max) {
@@ -5742,7 +6122,7 @@ async function fullAgentOptions(opts = {}) {
   const registry = jobs ?? new ShellJobRegistry2({ cwd, killOnExit: true });
   if (onJobExit) registry.setOnExit((n) => onJobExit(formatJobExit2(n)));
   const shell = [makeRealShellTool2({ cwd, registry }), ...makeShellJobTools2(registry)];
-  return { ...rest, tools: [...tools ?? defaultTools(), ...shell] };
+  return { ...rest, jobs: registry.jobs, tools: [...tools ?? defaultTools(), ...shell] };
 }
 
 // src/index.ts
@@ -5754,7 +6134,7 @@ init_tools_web();
 init_tools();
 init_tools_structured();
 init_logging();
-var log8 = forComponent("scratch");
+var log9 = forComponent("scratch");
 var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
@@ -5794,7 +6174,7 @@ var Scratch = class {
           await (this.dirReady ??= mkdirp(this.fs, dir));
           await this.fs.writeFile(path, header + raw);
         } catch (e) {
-          log8.debug("scratch write failed; returning raw", e);
+          log9.debug("scratch write failed; returning raw", e);
           return raw;
         }
         const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
@@ -5824,7 +6204,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) {
-      log8.debug("scratch spill failed; cropping lossy", e);
+      log9.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]`;
@@ -5870,7 +6250,7 @@ Question: ${q}`);
         const answer = (res.text ?? "").trim();
         return answer || "(no answer found in scratch)";
       } catch (e) {
-        log8.debug("Ask peek failed", e);
+        log9.debug("Ask peek failed", e);
         return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
@@ -5879,7 +6259,7 @@ Question: ${q}`);
 
 // src/lessons.ts
 init_logging();
-var log9 = forComponent("Lessons");
+var log10 = forComponent("Lessons");
 var LessonOptionsDefaults = class {
   minRepeats = 2;
 };
@@ -5904,8 +6284,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) => log9.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
-      log9.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
+      await writeFact(o.fs, o.dir, lesson.slug, lesson.body).catch((e) => log10.warn(`could not persist ${lesson.slug}: ${e?.message ?? e}`));
+      log10.debug(`captured lesson ${lesson.slug} (recurred ${n}\xD7)`);
     }
   };
 }
@@ -5913,7 +6293,7 @@ function lessonCapture(options) {
 // src/reflect.ts
 init_llm();
 init_logging();
-var log10 = forComponent("Reflect");
+var log11 = forComponent("Reflect");
 async function reflectOnRun(o) {
   const digest = digestRun(o.result.messages, o.maxDigestChars ?? 6e3);
   if (!digest.trim()) return null;
@@ -5929,7 +6309,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) {
-    log10.warn(`reflection call failed: ${e?.message ?? e}`);
+    log11.warn(`reflection call failed: ${e?.message ?? e}`);
     return null;
   }
   const m = text.match(/LESSON:\s*(.+)/i);
@@ -5939,10 +6319,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) {
-    log10.warn(`could not persist lesson: ${e?.message ?? e}`);
+    log11.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log10.debug(`reflection persisted ${slug2}`);
+  log11.debug(`reflection persisted ${slug2}`);
   return slug2;
 }
 function digestRun(messages, maxChars) {
@@ -5991,7 +6371,7 @@ function forComponent2(name) {
 }
 
 // node_modules/@bod.ee/voice/src/core/emotion.ts
-var log11 = forComponent2("Emotion");
+var log12 = forComponent2("Emotion");
 var EMOTIONS = [
   // primary (best results)
   "neutral",
@@ -6145,7 +6525,7 @@ var EmotionStream = class {
       if (tag) {
         this.pending = tag;
         if (this.show) display += m[0];
-      } else log11.debug(`dropping unknown emotion tag ${m[0]}`);
+      } else log12.debug(`dropping unknown emotion tag ${m[0]}`);
       last = m.index + m[0].length;
     }
     this.emit(body.slice(last), (s, d, p) => {
@@ -6168,7 +6548,7 @@ var EmotionStream = class {
 };
 
 // node_modules/@bod.ee/voice/src/core/engine.ts
-var log12 = forComponent2("VoiceEngine");
+var log13 = forComponent2("VoiceEngine");
 var realClock = {
   now: () => performance.now(),
   setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -6443,7 +6823,7 @@ var VoiceEngine = class _VoiceEngine {
     await Promise.all([this.tts.connect(), this.stt.start()]);
     this.tts.warmup?.();
     this.setState("listening");
-    log12.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
+    log13.debug(`voice I/O up (${this.stt.usingAec ? "AEC" : "heuristic echo"} capture)`);
   }
   get usingAec() {
     return this.stt.usingAec;
@@ -6465,7 +6845,7 @@ var VoiceEngine = class _VoiceEngine {
       this.options.onDiag({ t: this.clock.now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log12.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log13.debug(`onDiag threw \u2014 diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   idleWaiters = [];
@@ -6574,7 +6954,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) log12.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
+    if (!this.spokeDeltas && this.turnStartAt) log13.debug(`ttft: ${Math.round(this.clock.now() - this.turnStartAt)}ms`);
     this.spokeDeltas = true;
     this.setState("speaking");
     if (this.options.revealMode !== "off" && display) {
@@ -6651,7 +7031,7 @@ var VoiceEngine = class _VoiceEngine {
       this.drainTimer = null;
       this.speaking = false;
       this.stopWordReveal(true);
-      if (this.turnStartAt) log12.debug(`turn: ${Math.round(this.clock.now() - this.turnStartAt)}ms (incl. playback)`);
+      if (this.turnStartAt) log13.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");
@@ -6739,7 +7119,7 @@ var VoiceEngine = class _VoiceEngine {
     this.clearAckTimer("interrupt");
     this.adaptiveAckFired = false;
     this.ackProbe = null;
-    if (this.uttQueue.length) log12.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
+    if (this.uttQueue.length) log13.info(`barge-in dropped ${this.uttQueue.length} queued worker utterance(s)`);
     const droppedQueued = this.uttQueue.length;
     this.uttQueue = [];
     if (!this.speaking && !this.drainTimer) return;
@@ -6885,7 +7265,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;
-      log12.debug(`speculate: "${this.specText.slice(0, 60)}"`);
+      log13.debug(`speculate: "${this.specText.slice(0, 60)}"`);
       this.diag("speculate", { text: this.specText });
       this.options.onSpeculate(this.specText);
     }, this.options.speculativeMs);
@@ -6954,7 +7334,7 @@ var VoiceEngine = class _VoiceEngine {
     };
     this.tts.newContext();
     this.tts.speak(phrase, false);
-    log12.debug(`backchannel: "${phrase}"`);
+    log13.debug(`backchannel: "${phrase}"`);
     this.diag("backchannel", { phrase });
     this.options.onBackchannel(phrase);
   }
@@ -6987,7 +7367,7 @@ var VoiceEngine = class _VoiceEngine {
     });
     if (idx < 0) return text;
     toks.splice(idx, 1);
-    log12.verbose(`stripped backchannel echo "${this.lastBcPhrase}" from dispatching final`);
+    log13.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
@@ -7078,7 +7458,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)) {
-      log12.verbose(`hold: incomplete utterance "${this.pendingUtt.slice(-40)}"`);
+      log13.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);
@@ -7113,13 +7493,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) {
-        log12.verbose(`dropped duplicate final "${text.slice(0, 40)}" (identical to the just-dispatched utterance, no reply between)`);
+        log13.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) {
-        log12.verbose(`dropped re-finalization "${text.slice(0, 60)}" (superset of the just-dispatched utterance, reply already flowing)`);
+        log13.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+/);
@@ -7279,7 +7659,7 @@ var SpokenSplitter = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/soniox.ts
-var log13 = forComponent2("SonioxSTT");
+var log14 = forComponent2("SonioxSTT");
 var now = () => performance.now();
 var SonioxSTTOptions = class {
   auth = "";
@@ -7320,7 +7700,7 @@ var SonioxSTT = class {
       this.onDiag({ t: now(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log13.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log14.debug(`onDiag threw \u2014 STT diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   lastChunkAt = 0;
@@ -7362,11 +7742,11 @@ var SonioxSTT = class {
     this.ws.onmessage = (ev) => this.handle(JSON.parse(String(ev.data)));
     this.ws.onclose = (ev) => {
       if (this.stopped) return;
-      log13.warn(`soniox ws closed (${ev.code} ${ev.reason || ""}) \u2014 reconnecting`);
+      log14.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) => {
-        log13.error(`soniox reconnect failed: ${e.message}`);
+        log14.error(`soniox reconnect failed: ${e.message}`);
         this.diag("stt_reconnect_failed", { message: e.message });
       });
     };
@@ -7378,7 +7758,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) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
+      if (this.firstTokenAt) log14.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192silence-endpoint, "${combined.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(combined, now());
     }, 120);
@@ -7390,7 +7770,7 @@ var SonioxSTT = class {
         if (this.stopped) return;
         const ref = this.lastChunkAt || this.startedChunksAt;
         if (now() - ref > noAudioMs) {
-          log13.error(`stt: no mic audio for >${Math.round(noAudioMs / 1e3)}s \u2014 capture device stopped delivering`);
+          log14.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();
@@ -7413,7 +7793,7 @@ var SonioxSTT = class {
   handle(m) {
     if (m.error_message) {
       this.diag("stt_error", { message: String(m.error_message), code: m.error_code });
-      return log13.error(`soniox: ${m.error_message}`);
+      return log14.error(`soniox: ${m.error_message}`);
     }
     let endpoint = false;
     for (const t of m.tokens ?? []) {
@@ -7430,7 +7810,7 @@ var SonioxSTT = class {
     this.onPartial(combined);
     if (endpoint && this.finalText.trim()) {
       const utterance = this.finalText.trim();
-      if (this.firstTokenAt) log13.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
+      if (this.firstTokenAt) log14.debug(`stt: ${Math.round(now() - this.firstTokenAt)}ms first-token\u2192endpoint, "${utterance.slice(0, 60)}"`);
       this.reset();
       this.onUtterance(utterance, now());
     }
@@ -7452,7 +7832,7 @@ var SonioxSTT = class {
 };
 
 // node_modules/@bod.ee/voice/src/adapters/cartesia.ts
-var log14 = forComponent2("CartesiaTTS");
+var log15 = forComponent2("CartesiaTTS");
 var now2 = () => performance.now();
 var CartesiaTTSOptions = class {
   auth = "";
@@ -7488,7 +7868,7 @@ var CartesiaTTS = class _CartesiaTTS {
       this.onDiag({ t: now2(), kind, ...fields });
     } catch (e) {
       this.diagOn = false;
-      log14.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
+      log15.debug(`onDiag threw \u2014 TTS diagnostics disabled: ${e instanceof Error ? e.message : e}`);
     }
   }
   firstAudioAt = 0;
@@ -7523,11 +7903,11 @@ var CartesiaTTS = class _CartesiaTTS {
       this.ws.onerror = (e) => rej(new Error(`cartesia ws: ${e.message || "connect failed"}`));
     });
     this.ws.onclose = (ev) => {
-      log14.warn(`cartesia ws closed (${ev.code} ${ev.reason || ""})`);
+      log15.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) => {
-          log14.error(`cartesia reconnect failed: ${e.message}`);
+          log15.error(`cartesia reconnect failed: ${e.message}`);
           this.diag("tts_reconnect_failed", { message: e.message });
         });
       }
@@ -7555,12 +7935,12 @@ var CartesiaTTS = class _CartesiaTTS {
           this.down = true;
           this.downAt = now2();
           this.consecutiveOk = 0;
-          log14.warn(`TTS circuit breaker open \u2014 ${this.consecutiveErrors} consecutive errors, switching to text-only`);
+          log15.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 || "") ? log14.debug : log14.warn)(`cartesia: ${JSON.stringify(m)}`);
+          (/No valid transcripts/i.test(m.message || "") ? log15.debug : log15.warn)(`cartesia: ${JSON.stringify(m)}`);
         }
       }
     };
@@ -7575,7 +7955,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 ? log14.debug : log14.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
+    (downMs < 2e3 ? log15.debug : log15.info)(`TTS recovered${downMs ? ` (down ${downMs}ms)` : ""}`);
   }
   /** Ensure the WS is open before sending — reconnects if idle-closed. */
   async ensureConnected() {
@@ -7666,7 +8046,7 @@ configureLogging((name) => {
 });
 
 // src/duplex.ts
-var log15 = forComponent("DuplexAgent");
+var log16 = 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)})` : "";
@@ -7877,7 +8257,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;
-            log15.warn(`reflex fabricated a [task \u2026] event in its spoken stream \u2014 cutting it (kept ${m.index} chars)`);
+            log16.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;
@@ -7972,7 +8352,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)) {
-          log15.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
+          log16.verbose(`speculation aborted: reflex called ${call.name} on unconfirmed input`);
           this.abortSpeculation();
           return { block: true, reason: "Speculative turn aborted." };
         }
@@ -8010,7 +8390,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) {
-      log15.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
+      log16.warn(`ack nudge failed: ${e instanceof Error ? e.message : e}`);
     } finally {
       this.nudging = false;
     }
@@ -8103,7 +8483,7 @@ ${nowLine()}. Anchor every relative or time-sensitive reference \u2014 "today",
       try {
         res = await this.voice.send(spec.text);
       } catch (e) {
-        log15.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
+        log16.warn(`speculative turn failed: ${e instanceof Error ? e.message : e}`);
       } finally {
         this.voice.options.signal = prevSignal;
       }
@@ -8117,7 +8497,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++;
-        log15.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
+        log16.verbose(`speculation aborted (${this.speculativeAbortedCalls} total): "${spec.text.slice(0, 50)}"`);
         if (this.spec === spec) this.spec = void 0;
         return res ?? empty;
       }
@@ -8382,7 +8762,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") {
-      log15.warn(`task ${id}: verify inconclusive (${cres.finishReason})`);
+      log16.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;
@@ -8518,7 +8898,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";
-    log15.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
+    log16.verbose(`task ${id} done (${res.steps} steps${incomplete ? `, INCOMPLETE: ${res.finishReason}` : ""})`);
     this.notify("task_done", `task ${id} (${rec.label}) completed`, {
       id,
       text: res.text,
@@ -8560,14 +8940,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 });
-    log15.verbose(`task ${rec.id} settled but superseded (${rec.status}) \u2014 folded into transcript, not voiced`);
+    log16.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;
-    log15.warn(`task ${rec.id} failed: ${msg}`);
+    log16.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);
@@ -8816,17 +9196,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);
     }
   };
 }
@@ -8867,13 +9272,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];
@@ -8893,17 +9295,17 @@ function buildMcpCatalog(servers) {
   return { specs, routes };
 }
 function searchOverCatalog(servers, specs, routes, resolve2, 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 resolve2(r.server, r.rawName, args ?? {});
+    return resolve2(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);
 }
 function makeLazyMcpToolSearch(servers, resolve2, options) {
   const { specs, routes } = buildMcpCatalog(servers);
@@ -8988,6 +9390,8 @@ export {
   IndexedDbFilesystem,
   JailOptions,
   JailedFilesystem,
+  JobRegistry,
+  JobRegistryOptions,
   LessonOptionsDefaults,
   MEMORY_PROMPT,
   MODEL_ALIASES,
@@ -9042,6 +9446,7 @@ export {
   expandTemplate,
   findGitRoot,
   forComponent,
+  formatJobNotice,
   fullAgentOptions,
   getOrCreateWorktree,
   getWorktreeSession,