nolo-cli 0.201.0-alpha.2 → 0.202.0-alpha.1

package/chunk-2BMURXSB.js

@@ -0,0 +1,1863 @@
+import {
+  resolveNoloStateDir
+} from "./chunk-6UBGXX2W.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/processTask.ts
+var PROCESS_TASK_TERMINAL_STATUSES = [
+  "stopped",
+  "exited",
+  "failed"
+];
+function isProcessTaskTerminalStatus(status) {
+  return typeof status === "string" && PROCESS_TASK_TERMINAL_STATUSES.includes(status);
+}
+function reportedTaskStatus(source, exitCode) {
+  if (source === "killed") {
+    return "stopped";
+  }
+  if (source === "exited") {
+    return exitCode !== void 0 && exitCode !== 0 ? "failed" : "exited";
+  }
+  if (source === "started" || source === "promoted") {
+    return "running";
+  }
+  return source;
+}
+var DEFAULT_TASK_EVENT_RETENTION_MS = 5 * 60 * 1e3;
+var DEFAULT_MAX_TASK_EVENTS_TASKS = 200;
+var ProcessTaskEventLog = class {
+  events = /* @__PURE__ */ new Map();
+  terminalTasks = /* @__PURE__ */ new Map();
+  retentionMs;
+  maxTasks;
+  now;
+  evictedCount = 0;
+  activeOverflowCount = 0;
+  constructor(options) {
+    this.retentionMs = options?.retentionMs ?? DEFAULT_TASK_EVENT_RETENTION_MS;
+    this.maxTasks = options?.maxTasks ?? DEFAULT_MAX_TASK_EVENTS_TASKS;
+    this.now = options?.now ?? Date.now;
+  }
+  /** Append one event; assigns the next monotonic seq for the task. */
+  append(input) {
+    const currentTime = this.now();
+    const list = this.events.get(input.taskId) ?? [];
+    const lastSeq = list.length > 0 ? list[list.length - 1].seq : 0;
+    const event = Object.freeze({
+      taskId: input.taskId,
+      seq: lastSeq + 1,
+      type: input.type,
+      pid: input.pid,
+      createdAt: currentTime,
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {}
+    });
+    list.push(event);
+    this.events.set(input.taskId, list);
+    if (input.type === "exited" || input.type === "killed") {
+      this.terminalTasks.set(input.taskId, currentTime);
+    }
+    this.evict(currentTime);
+    return { ...event };
+  }
+  /**
+   * All events of the task with `seq > cursor` (default 0 = from the start).
+   *
+   * NOTE for cursor consumers (Phase 1 taskWait/taskLogs): an empty array is
+   * ambiguous — it means either "no new events yet" or "the whole task was
+   * evicted" (retention is per-taskId, never partial, so a cursor can never
+   * land in a hole). Do NOT treat empty as "still running and idle": pair the
+   * read with `hasTask(taskId)` to tell the two apart, otherwise a wait loop
+   * can hang forever on an evicted task. Eviction only ever happens after a
+   * terminal event plus the retention delay, so a live task is always readable.
+   */
+  read(taskId, cursor = 0) {
+    return (this.events.get(taskId) ?? []).filter((event) => event.seq > cursor).map((event) => ({ ...event }));
+  }
+  /**
+   * Whether the task's event trail is still retained. Lets a cursor consumer
+   * disambiguate the empty result of `read()` (see its note).
+   */
+  hasTask(taskId) {
+    return this.events.has(taskId);
+  }
+  latestSeq(taskId) {
+    const list = this.events.get(taskId);
+    return list && list.length > 0 ? list[list.length - 1].seq : 0;
+  }
+  getStats() {
+    return {
+      taskCount: this.events.size,
+      terminalTaskCount: this.terminalTasks.size,
+      activeTaskCount: this.events.size - this.terminalTasks.size,
+      evictedCount: this.evictedCount,
+      activeOverflowCount: this.activeOverflowCount
+    };
+  }
+  clear() {
+    this.events.clear();
+    this.terminalTasks.clear();
+    this.evictedCount = 0;
+    this.activeOverflowCount = 0;
+  }
+  evict(currentTime) {
+    for (const [taskId, terminalTime] of this.terminalTasks.entries()) {
+      if (currentTime - terminalTime >= this.retentionMs) {
+        this.events.delete(taskId);
+        this.terminalTasks.delete(taskId);
+        this.evictedCount += 1;
+      }
+    }
+    if (this.events.size > this.maxTasks) {
+      const sortedTerminal = Array.from(this.terminalTasks.entries()).sort((a, b) => a[1] - b[1]);
+      for (const [taskId] of sortedTerminal) {
+        if (this.events.size <= this.maxTasks) {
+          break;
+        }
+        this.events.delete(taskId);
+        this.terminalTasks.delete(taskId);
+        this.evictedCount += 1;
+      }
+      if (this.events.size > this.maxTasks) {
+        this.activeOverflowCount += 1;
+      }
+    }
+  }
+};
+
+// packages/agent-runtime/processRegistry.ts
+function toProcessTaskView(record) {
+  const capsule = record.resultCapsule;
+  return {
+    taskId: record.taskId,
+    pid: record.pid,
+    pgid: record.pgid,
+    command: record.command,
+    label: record.label,
+    startedAt: record.startedAt,
+    status: record.status,
+    ...record.exitCode !== void 0 ? { exitCode: record.exitCode } : {},
+    persist: record.persist,
+    promoted: record.promoted,
+    transient: record.transient,
+    ...capsule?.durationMs !== void 0 ? { durationMs: capsule.durationMs } : {},
+    ...capsule?.spill ? { outputRef: capsule.spill.displayPath } : {}
+  };
+}
+var taskIdCounter = 0;
+function mintTaskId(pid) {
+  taskIdCounter += 1;
+  return `ptask-${pid}-${Date.now().toString(36)}-${taskIdCounter.toString(36)}`;
+}
+var ProcessRegistry = class {
+  processes = /* @__PURE__ */ new Map();
+  byTaskId = /* @__PURE__ */ new Map();
+  eventLog;
+  terminalListeners = /* @__PURE__ */ new Set();
+  constructor(eventLogOptions) {
+    this.eventLog = new ProcessTaskEventLog(eventLogOptions);
+  }
+  /**
+   * Subscribe to terminal transitions (markExited / kill). Fired synchronously
+   * at the same instant the terminal event is appended to the task event log,
+   * so consumers (TUI pending-notice buffer) observe the same ordering as the
+   * audit stream. Each task fires at most once: markExited is gated on the
+   * "running" status, kill()/stopAll() on the same guard, and late close
+   * events after a user stop are already suppressed by the status check.
+   *
+   * Returns an unsubscribe function. Registration does NOT replay terminal
+   * states for tasks that already terminated before subscription (no
+   * backfill): the event log keeps the audit trail, and replaying would
+   * double-notify tasks the previous session already surfaced.
+   */
+  onProcessTerminal(listener) {
+    this.terminalListeners.add(listener);
+    return () => {
+      this.terminalListeners.delete(listener);
+    };
+  }
+  /** Emit a terminal notice synchronously; listener errors must not break registry callers. */
+  emitTerminal(notice) {
+    for (const listener of [...this.terminalListeners]) {
+      try {
+        listener(notice);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Pre-register an envelope right after a successful spawn and emit the
+   * `started` event. Returns the stored record (with its stable taskId).
+   */
+  add(proc) {
+    const record = {
+      taskId: proc.taskId ?? mintTaskId(proc.pid),
+      pid: proc.pid,
+      pgid: proc.pgid,
+      command: proc.command,
+      label: proc.label,
+      startedAt: Date.now(),
+      status: "running",
+      persist: proc.persist ?? false,
+      promoted: proc.promoted ?? false,
+      transient: proc.transient ?? false,
+      owner: proc.owner ?? null
+    };
+    this.processes.set(proc.pid, record);
+    this.byTaskId.set(record.taskId, proc.pid);
+    this.eventLog.append({ taskId: record.taskId, pid: proc.pid, type: "started" });
+    return { ...record };
+  }
+  list() {
+    return Array.from(this.processes.values()).map((proc) => ({ ...proc }));
+  }
+  /**
+   * User-visible view: only real background tasks — entries registered by
+   * launchProcess (background from birth) plus envelopes promoted to
+   * background by timeout detach. Transient foreground grace-period envelopes
+   * (workspaceShell pre-registration, not yet promoted) are excluded so the
+   * status line, /procs and /stop keep behaving exactly as before Phase 0.
+   * Audit/internal consumers that need the full truth use list() instead.
+   */
+  listBackground() {
+    return Array.from(this.processes.values()).filter((proc) => !proc.transient).map((proc) => ({ ...proc }));
+  }
+  get(pid) {
+    const item = this.processes.get(pid);
+    return item ? { ...item } : void 0;
+  }
+  getTaskId(pid) {
+    return this.processes.get(pid)?.taskId;
+  }
+  getByTaskId(taskId) {
+    const pid = this.byTaskId.get(taskId);
+    return pid === void 0 ? void 0 : this.get(pid);
+  }
+  /** Append-only lifecycle events of a task with `seq > cursor` (ascending). */
+  getTaskEvents(taskId, cursor = 0) {
+    return this.eventLog.read(taskId, cursor);
+  }
+  latestTaskSeq(taskId) {
+    return this.eventLog.latestSeq(taskId);
+  }
+  /**
+   * Whether the task's event trail is still retained. Cursor consumers MUST
+   * pair this with getTaskEvents(): an empty read means either "no new events"
+   * or "the whole trail was evicted" (§1.1), and only this call tells them
+   * apart — without it a wait loop hangs forever on an evicted task.
+   */
+  hasTaskEvents(taskId) {
+    return this.eventLog.hasTask(taskId);
+  }
+  /**
+   * Timeout-detach promotion: mark the pre-registered envelope as a background
+   * task. Same record, same taskId, no re-execution, no second registration.
+   */
+  promote(pid) {
+    const item = this.processes.get(pid);
+    if (!item) return void 0;
+    if (!item.promoted) {
+      item.promoted = true;
+      item.transient = false;
+      this.eventLog.append({ taskId: item.taskId, pid, type: "promoted" });
+    }
+    return { ...item };
+  }
+  /**
+   * Terminate a background process group and update its status to "stopped".
+   *
+   * Invariant (§1.3): Transient foreground envelopes (workspaceShell grace
+   * period before timeout detach) are NOT stoppable through this entry point;
+   * their lifecycle belongs to the foreground runner (abort/timeout). Calling
+   * kill() on a transient entry does not signal the process, does not emit a
+   * "killed" event, and returns false.
+   */
+  kill(pid, signal = "SIGTERM") {
+    const item = this.processes.get(pid);
+    if (!item) return false;
+    if (item.transient) return false;
+    if (item.status === "running") {
+      try {
+        if (process.platform === "win32") {
+          process.kill(item.pid, signal);
+        } else {
+          process.kill(-item.pgid, signal);
+        }
+      } catch {
+        try {
+          process.kill(item.pid, signal);
+        } catch {
+        }
+      }
+      item.status = "stopped";
+      this.eventLog.append({ taskId: item.taskId, pid, type: "killed" });
+      this.emitTerminal({
+        taskId: item.taskId,
+        pid,
+        label: item.label,
+        command: item.command,
+        status: "stopped",
+        promoted: item.promoted
+      });
+      return true;
+    }
+    return false;
+  }
+  stopAll(signal = "SIGTERM", opts) {
+    for (const item of this.processes.values()) {
+      if (opts?.backgroundOnly && item.transient) continue;
+      if (item.status === "running" && (opts?.includePersist || !item.persist)) {
+        try {
+          if (process.platform === "win32") {
+            process.kill(item.pid, signal);
+          } else {
+            process.kill(-item.pgid, signal);
+          }
+        } catch {
+          try {
+            process.kill(item.pid, signal);
+          } catch {
+          }
+        }
+        item.status = "stopped";
+        this.eventLog.append({ taskId: item.taskId, pid: item.pid, type: "killed" });
+        this.emitTerminal({
+          taskId: item.taskId,
+          pid: item.pid,
+          label: item.label,
+          command: item.command,
+          status: "stopped",
+          promoted: item.promoted
+        });
+      }
+    }
+  }
+  markExited(pid, exitCode, resultCapsule) {
+    const item = this.processes.get(pid);
+    if (item && item.status === "running") {
+      item.exitCode = exitCode;
+      if (resultCapsule) item.resultCapsule = resultCapsule;
+      item.status = exitCode === 0 ? "exited" : "failed";
+      this.eventLog.append({
+        taskId: item.taskId,
+        pid,
+        type: "exited",
+        exitCode
+      });
+      this.emitTerminal({
+        taskId: item.taskId,
+        pid,
+        label: item.label,
+        command: item.command,
+        status: item.status,
+        exitCode,
+        promoted: item.promoted,
+        ...item.resultCapsule ? { resultCapsule: item.resultCapsule } : {}
+      });
+    }
+  }
+  /**
+   * Grace-period completion: the command ended before detach promotion, so the
+   * envelope is transient by design — record the final event, then drop the
+   * envelope entirely ("不留痕是结果"). The event stream keeps the audit trail.
+   * No-op for already-promoted envelopes (their lifecycle is owned by
+   * markExited after detach).
+   */
+  completeTransient(pid, exitCode) {
+    const item = this.processes.get(pid);
+    if (!item || item.promoted) return;
+    this.eventLog.append({ taskId: item.taskId, pid, type: "exited", exitCode });
+    this.processes.delete(pid);
+    this.byTaskId.delete(item.taskId);
+  }
+  /** Drop an envelope without emitting events (spawn/registration failure paths). */
+  remove(pid) {
+    const item = this.processes.get(pid);
+    if (!item) return false;
+    this.processes.delete(pid);
+    this.byTaskId.delete(item.taskId);
+    return true;
+  }
+  clear() {
+    this.processes.clear();
+    this.byTaskId.clear();
+    this.eventLog.clear();
+    this.terminalListeners.clear();
+  }
+};
+var registry = null;
+function getProcessRegistry() {
+  if (!registry) {
+    registry = new ProcessRegistry();
+  }
+  return registry;
+}
+
+// packages/agent-runtime/workspaceShell.ts
+import { createWriteStream, mkdirSync as mkdirSync2, rmSync } from "node:fs";
+import { dirname, join as join3, resolve } from "node:path";
+import { spawn as spawnChildProcess } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { tmpdir } from "node:os";
+
+// packages/agent-runtime/runtimeCompat.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+var IS_WINDOWS = process.platform === "win32";
+function isExecutableFile(candidate) {
+  if (!existsSync(candidate)) return false;
+  try {
+    return statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveExecutableOnPath(name) {
+  if (IS_WINDOWS && !/\.[a-z]+$/i.test(name)) {
+    const exts = (process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+    for (const ext of exts) {
+      const found = resolveExecutableOnPath(name + ext);
+      if (found) return found;
+    }
+    return null;
+  }
+  const pathEnv = process.env.PATH ?? "";
+  const sep = pathEnv.includes(";") && IS_WINDOWS ? ";" : ":";
+  const pathDirs = pathEnv.split(sep).filter(Boolean);
+  const fallbackDirs = IS_WINDOWS ? [] : [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+    `${process.env.HOME ?? ""}/.local/bin`
+  ].filter(Boolean);
+  for (const dir of [...pathDirs, ...fallbackDirs]) {
+    const candidate = join(dir, name);
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  return null;
+}
+function createGlob(pattern) {
+  const regex = globToRegExp(pattern);
+  return {
+    match(path) {
+      return regex.test(path);
+    },
+    scanSync(opts) {
+      const dot = opts.dot ?? false;
+      const results = [];
+      walkDir(opts.cwd, "", dot, results);
+      return results.filter((rel) => regex.test(rel));
+    }
+  };
+}
+function walkDir(dir, prefix, dot, out) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const name = String(entry.name);
+    if (!dot && name.startsWith(".")) continue;
+    const rel = prefix ? `${prefix}/${name}` : name;
+    const full = join(dir, name);
+    if (entry.isDirectory()) {
+      walkDir(full, rel, dot, out);
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+}
+function globToRegExp(pattern) {
+  const trailingDir = pattern.endsWith("/");
+  const src = trailingDir ? pattern.slice(0, -1) : pattern;
+  const anchored = src.startsWith("/");
+  const body = anchored ? src.slice(1) : src;
+  let regex = "^";
+  if (!anchored) regex += "(?:.*/)?";
+  regex += convertBody(body);
+  if (trailingDir) {
+    regex += "(?:/.*)?";
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+function convertBody(p) {
+  let out = "";
+  let i = 0;
+  while (i < p.length) {
+    const c = p[i];
+    if (c === "*") {
+      if (p[i + 1] === "*") {
+        i += 2;
+        if (p[i] === "/") {
+          out += "(?:.*/)?";
+          i += 1;
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      out += "[^/]";
+      i += 1;
+    } else if (c === "[") {
+      out += "[";
+      i += 1;
+      if (p[i] === "!") {
+        out += "^";
+        i += 1;
+      }
+      while (i < p.length && p[i] !== "]") {
+        out += p[i] === "\\" ? "\\\\" : p[i];
+        i += 1;
+      }
+      if (p[i] === "]") {
+        out += "]";
+        i += 1;
+      }
+    } else if (c === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let bodyStr = "";
+      while (j < p.length && depth > 0) {
+        if (p[j] === "{") depth += 1;
+        else if (p[j] === "}") depth -= 1;
+        if (depth > 0) bodyStr += p[j];
+        j += 1;
+      }
+      const alts = bodyStr.split(",").map((alt) => convertBody(alt));
+      out += `(?:${alts.join("|")})`;
+      i = j;
+    } else {
+      out += escapeRegexChar(c);
+      i += 1;
+    }
+  }
+  return out;
+}
+function escapeRegexChar(c) {
+  if ("\\^$.|+()".includes(c)) {
+    return `\\${c}`;
+  }
+  return c;
+}
+function spawnToWebStreams(options) {
+  const [command, ...args] = options.cmd;
+  const child = spawn(command, args, {
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exited = new Promise((resolve2) => {
+    child.on("exit", (code) => resolve2(code ?? 1));
+    child.on("error", () => resolve2(127));
+  });
+  const toWeb = (stream) => {
+    if (!stream) return null;
+    return stream.toWeb?.() ?? new ReadableStream({
+      start(controller) {
+        stream.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+        stream.on("end", () => controller.close());
+        stream.on("error", (e) => controller.error(e));
+      }
+    });
+  };
+  return {
+    stdout: toWeb(child.stdout),
+    stderr: toWeb(child.stderr),
+    exited
+  };
+}
+
+// packages/agent-runtime/windowsPowerShellAlias.ts
+import { lstatSync, readlinkSync, statSync as statSync2 } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { win32 } from "node:path";
+var VERSION_COMMAND = "$PSVersionTable.PSVersion.Major";
+function defaultIsAlias(path) {
+  return lstatSync(path).isSymbolicLink();
+}
+function defaultResolveTarget(path) {
+  const target = win32.resolve(win32.dirname(path), readlinkSync(path));
+  if (win32.basename(target).toLowerCase() !== "pwsh.exe" || !statSync2(target).isFile()) {
+    throw new Error("Store alias does not point to a PowerShell executable");
+  }
+  return target;
+}
+function defaultProbe(path) {
+  return execFileSync(path, [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    VERSION_COMMAND
+  ], { encoding: "utf8", timeout: 3e3, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] });
+}
+function resolveWindowsStoreAliasRoot(options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") return null;
+  const env = options.env ?? process.env;
+  if (!env.LOCALAPPDATA) return null;
+  return win32.resolve(env.LOCALAPPDATA, "Microsoft", "WindowsApps");
+}
+function isWindowsStoreAliasPath(path, options = {}) {
+  if (!path) return false;
+  const root = resolveWindowsStoreAliasRoot(options);
+  if (!root) return false;
+  const relative3 = win32.relative(root, win32.resolve(path));
+  if (relative3 === "") return true;
+  return relative3 !== ".." && !relative3.startsWith("..\\") && !win32.isAbsolute(relative3);
+}
+function resolveWindowsPowerShellAliasTarget(path, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  if (!isWindowsStoreAliasPath(path, { platform, env })) return null;
+  const isAlias = options.isAlias ?? defaultIsAlias;
+  const resolveTarget = options.resolveTarget ?? defaultResolveTarget;
+  const probe = options.probe ?? defaultProbe;
+  try {
+    if (!isAlias(path)) return null;
+    const target = resolveTarget(path);
+    const major = probe(target).trim();
+    if (/^\d+$/.test(major) && Number(major) >= 7) return target;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findWindowsPowerShellAlias(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const root = resolveWindowsStoreAliasRoot({ platform, env });
+  if (!root) return null;
+  const dirs = [...(env.PATH ?? "").split(";"), root];
+  const visited = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    if (!dir.trim()) continue;
+    const relative3 = win32.relative(root, win32.resolve(dir));
+    if (relative3 === ".." || relative3.startsWith("..\\") || win32.isAbsolute(relative3)) continue;
+    const candidate = win32.join(dir, "pwsh.exe");
+    const key = candidate.toLowerCase();
+    if (visited.has(key)) continue;
+    visited.add(key);
+    const target = resolveWindowsPowerShellAliasTarget(candidate, options);
+    if (target) return target;
+  }
+  return null;
+}
+
+// packages/agent-runtime/toolSpillStore.ts
+import { createHash, randomUUID } from "node:crypto";
+import { constants, copyFileSync, createReadStream, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, renameSync, statSync as statSync3, unlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { isAbsolute, join as join2, relative } from "node:path";
+var DEFAULT_MAX_SPILL_DIR_BYTES = 50 * 1024 * 1024;
+var DEFAULT_SPILL_TTL_MS = 24 * 60 * 60 * 1e3;
+var SPILL_CLEANUP_THROTTLE_MS = 60 * 1e3;
+var SPILL_THROTTLE_MAX_DIRS = 64;
+var lastSpillCleanupAtMsByDir = /* @__PURE__ */ new Map();
+function resolveSpillDirectory(options) {
+  if (options?.baseDir) {
+    return options.baseDir;
+  }
+  if (options?.workspaceRoot) {
+    return join2(options.workspaceRoot, ".nolo", "spills");
+  }
+  return resolveNoloStateDir("spills");
+}
+function countLines(text) {
+  if (!text) return 0;
+  let lines = 1;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) {
+      lines++;
+    }
+  }
+  return lines;
+}
+var SPILL_PUBLICATION_GRACE_MS = 6e4;
+async function hashFileStreaming(path) {
+  const hash = createHash("sha256");
+  await new Promise((resolve2, reject) => {
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve2());
+  });
+  return hash.digest("hex");
+}
+async function promoteToolSpillFile(sourcePath, options) {
+  const injected = options?.ops ?? {};
+  const ops = {
+    now: injected.now ?? (() => Date.now()),
+    statSize: injected.statSize ?? ((path) => statSync3(path).size),
+    rename: injected.rename ?? ((from, to) => renameSync(from, to)),
+    copyExclusive: injected.copyExclusive ?? ((from, to) => {
+      copyFileSync(from, to, constants.COPYFILE_EXCL);
+    }),
+    unlink: injected.unlink ?? ((path) => unlinkSync(path)),
+    exists: injected.exists ?? ((path) => existsSync2(path)),
+    mkdirp: injected.mkdirp ?? ((dir) => mkdirSync(dir, { recursive: true })),
+    touch: injected.touch ?? ((path, atMs) => {
+      const at = new Date(atMs);
+      utimesSync(path, at, at);
+    }),
+    hashFile: injected.hashFile ?? hashFileStreaming,
+    cleanup: injected.cleanup ?? ((dir) => cleanupExpiredSpills(dir, { throttleMs: 0 })),
+    randomId: injected.randomId ?? (() => randomUUID())
+  };
+  const preservedIfPresent = () => {
+    try {
+      return ops.exists(sourcePath) ? sourcePath : void 0;
+    } catch {
+      return sourcePath;
+    }
+  };
+  let size = 0;
+  try {
+    size = ops.statSize(sourcePath);
+  } catch {
+    const preservedPath = preservedIfPresent();
+    return preservedPath ? { ok: false, reason: "unverified", preservedPath } : { ok: false, reason: "missing" };
+  }
+  if (size <= 0) return { ok: false, reason: "empty" };
+  let expectedHash = "";
+  try {
+    expectedHash = await ops.hashFile(sourcePath);
+  } catch {
+    const preservedPath = preservedIfPresent();
+    return preservedPath ? { ok: false, reason: "unverified", preservedPath } : { ok: false, reason: "missing" };
+  }
+  const workspaceRoot = options?.workspaceRoot;
+  const candidateDirs = Array.from(
+    new Set(
+      [
+        resolveSpillDirectory({ workspaceRoot }),
+        resolveNoloStateDir("spills")
+      ].filter(Boolean)
+    )
+  );
+  for (const dir of candidateDirs) {
+    const id = ops.randomId();
+    const final = join2(dir, `spill-execshell-${id}.log`);
+    const stage = join2(dir, `.spill-execshell-${id}.${ops.randomId()}.copying`);
+    let stageOwnedByMove = false;
+    let stageOwnedByCopy = false;
+    try {
+      ops.mkdirp(dir);
+      try {
+        ops.rename(sourcePath, stage);
+        stageOwnedByMove = true;
+      } catch (error) {
+        if (error?.code !== "EXDEV") throw error;
+        ops.copyExclusive(sourcePath, stage);
+        stageOwnedByCopy = true;
+      }
+      const actualHash = await ops.hashFile(stage);
+      if (actualHash !== expectedHash) throw new Error("spill verification failed");
+      ops.touch(stage, ops.now());
+      ops.rename(stage, final);
+      if (ops.exists(sourcePath)) {
+        try {
+          ops.unlink(sourcePath);
+        } catch {
+        }
+      }
+      try {
+        ops.cleanup(dir);
+      } catch {
+      }
+      const displayPath = workspaceRoot && isAbsolute(workspaceRoot) && dir === candidateDirs[0] ? (() => {
+        const rel = relative(workspaceRoot, final);
+        return !rel.startsWith("..") && !isAbsolute(rel) ? rel : final;
+      })() : final;
+      return { ok: true, spillPath: final, displayPath };
+    } catch {
+      if (stageOwnedByCopy) {
+        try {
+          ops.unlink(stage);
+        } catch {
+        }
+        continue;
+      }
+      if (stageOwnedByMove) {
+        try {
+          ops.rename(stage, sourcePath);
+          continue;
+        } catch {
+          return { ok: false, reason: "publish-failed", preservedPath: stage };
+        }
+      }
+    }
+  }
+  return {
+    ok: false,
+    reason: "publish-failed",
+    preservedPath: preservedIfPresent()
+  };
+}
+function cleanupExpiredSpills(spillDir, options) {
+  if (!existsSync2(spillDir)) return;
+  const throttleMs = options?.throttleMs ?? 0;
+  if (throttleMs > 0) {
+    const now2 = Date.now();
+    const last = lastSpillCleanupAtMsByDir.get(spillDir);
+    if (last !== void 0 && now2 - last < throttleMs) return;
+    if (lastSpillCleanupAtMsByDir.size >= SPILL_THROTTLE_MAX_DIRS) {
+      lastSpillCleanupAtMsByDir.clear();
+    }
+    lastSpillCleanupAtMsByDir.set(spillDir, now2);
+  }
+  const maxAge = options?.maxAgeMs ?? DEFAULT_SPILL_TTL_MS;
+  const maxBytes = options?.maxTotalBytes ?? DEFAULT_MAX_SPILL_DIR_BYTES;
+  const now = Date.now();
+  try {
+    const entries = readdirSync2(spillDir, { withFileTypes: true });
+    const spillFiles = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const isSpillLog = entry.name.startsWith("spill-") && entry.name.endsWith(".log");
+      const isOrphanTmp = entry.name.startsWith(".spill-") && entry.name.endsWith(".tmp");
+      if (!isSpillLog && !isOrphanTmp) continue;
+      const fullPath = join2(spillDir, entry.name);
+      try {
+        const stats = statSync3(fullPath);
+        const protectedByPublication = isSpillLog && entry.name.startsWith("spill-execshell-") && now - stats.mtimeMs < SPILL_PUBLICATION_GRACE_MS;
+        if (!protectedByPublication && (now - stats.mtimeMs > maxAge || isOrphanTmp)) {
+          unlinkSync(fullPath);
+        } else {
+          spillFiles.push({
+            name: entry.name,
+            fullPath,
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+            protectedByPublication
+          });
+        }
+      } catch {
+      }
+    }
+    let totalSize = spillFiles.reduce((acc, file) => acc + file.size, 0);
+    if (totalSize > maxBytes) {
+      spillFiles.sort((a, b) => a.mtimeMs - b.mtimeMs);
+      for (const file of spillFiles) {
+        if (totalSize <= maxBytes) break;
+        if (file.protectedByPublication) continue;
+        try {
+          unlinkSync(file.fullPath);
+          totalSize -= file.size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function spillToolOutput(options) {
+  const { content, workspaceRoot } = options;
+  const spillDir = resolveSpillDirectory({ workspaceRoot, baseDir: options.baseDir });
+  if (!existsSync2(spillDir)) {
+    mkdirSync(spillDir, { recursive: true });
+  }
+  cleanupExpiredSpills(spillDir, {
+    maxAgeMs: options.ttlMs,
+    maxTotalBytes: options.maxRetentionBytes,
+    throttleMs: SPILL_CLEANUP_THROTTLE_MS
+  });
+  const hash = createHash("sha256").update(content).digest("hex").slice(0, 12);
+  const safeToolName = (options.toolName || "tool").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 24);
+  const fileName = `spill-${safeToolName}-${hash}.log`;
+  const spillPath = join2(spillDir, fileName);
+  const tmpPath = join2(spillDir, `.${fileName}.${Math.random().toString(36).slice(2, 8)}.tmp`);
+  const byteLength = Buffer.byteLength(content, "utf-8");
+  const totalChars = content.length;
+  const totalLines = countLines(content);
+  if (existsSync2(spillPath)) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      utimesSync(spillPath, now, now);
+    } catch {
+    }
+  } else {
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, spillPath);
+  }
+  let displayPath = spillPath;
+  if (workspaceRoot && isAbsolute(workspaceRoot)) {
+    const rel = relative(workspaceRoot, spillPath);
+    if (!rel.startsWith("..") && !isAbsolute(rel)) {
+      displayPath = rel;
+    }
+  }
+  return {
+    spillPath,
+    displayPath,
+    totalChars,
+    totalLines,
+    byteLength,
+    hash
+  };
+}
+function formatToolOverflowMarker(args) {
+  const { spillRef, totalChars, totalLines, omittedChars } = args;
+  const omittedNote = omittedChars !== void 0 && omittedChars > 0 ? ` omitted: ${omittedChars} chars;` : "";
+  return `
+
+[TOOL-OVERFLOW: full output spilled to ${spillRef} (total: ${totalChars} chars, ${totalLines} lines;${omittedNote} inspect via readFile or grep)]
+
+`;
+}
+
+// packages/agent-runtime/processTaskResult.ts
+var PROCESS_RESULT_CAPSULE_TAIL_CHARS = 4e3;
+var PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS = 2e4;
+function tailText(value, maxChars) {
+  if (value.length <= maxChars) return { text: value, truncated: false };
+  return { text: value.slice(-maxChars), truncated: true };
+}
+function formatCapsuleStream(name, value) {
+  return value.trim() ? `${name}:
+${value.replace(/\n+$/, "")}` : "";
+}
+function buildProcessTaskResultCapsule(args) {
+  const tailChars = args.tailChars ?? PROCESS_RESULT_CAPSULE_TAIL_CHARS;
+  const spillThresholdChars = args.spillThresholdChars ?? PROCESS_RESULT_CAPSULE_SPILL_THRESHOLD_CHARS;
+  const stdout = typeof args.stdout === "string" ? args.stdout : "";
+  const stderr = typeof args.stderr === "string" ? args.stderr : "";
+  const exitCode = args.exitCode;
+  const captureError = args.captureError?.trim() || void 0;
+  const durationMs = typeof args.startedAt === "number" && Number.isFinite(args.startedAt) ? Math.max(0, (args.endedAt ?? Date.now()) - args.startedAt) : void 0;
+  const stdoutProvenance = args.streamProvenance?.stdout;
+  const stderrProvenance = args.streamProvenance?.stderr;
+  const ringEvicted = Boolean(stdoutProvenance?.evicted || stderrProvenance?.evicted);
+  const stdoutTailSource = typeof args.stdoutTail === "string" ? args.stdoutTail : stdout;
+  const stderrTailSource = typeof args.stderrTail === "string" ? args.stderrTail : stderr;
+  const stdoutTail = tailText(stdoutTailSource, tailChars);
+  const stderrTail = tailText(stderrTailSource, tailChars);
+  const inlineSize = stdout.length + stderr.length;
+  const inlineTruncated = stdoutTail.truncated || stderrTail.truncated;
+  const truncated = inlineTruncated || ringEvicted || Boolean(captureError);
+  const shouldSpill = truncated || inlineSize > spillThresholdChars;
+  let spill;
+  if (shouldSpill) {
+    try {
+      const result = spillToolOutput({
+        content: [
+          formatCapsuleStream("stdout", stdout),
+          formatCapsuleStream("stderr", stderr)
+        ].filter(Boolean).join("\n\n"),
+        toolName: "execShell",
+        ...args.workspaceRoot !== void 0 ? { workspaceRoot: args.workspaceRoot } : {}
+      });
+      spill = {
+        displayPath: result.displayPath,
+        // Prefer the caller's live provenance counters: they count every
+        // byte of the original stream, while the buffered content above may
+        // be a capped prefix of it.
+        totalChars: (stdoutProvenance?.totalChars ?? stdout.length) + (stderrProvenance?.totalChars ?? stderr.length),
+        totalLines: (stdoutProvenance?.totalLines ?? countLines(stdout)) + (stderrProvenance?.totalLines ?? countLines(stderr))
+      };
+    } catch {
+    }
+  }
+  return {
+    stdout: stdoutTail.text,
+    stderr: stderrTail.text,
+    exitCode,
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...captureError ? { captureError } : {},
+    truncated,
+    ...spill ? { spill } : {}
+  };
+}
+
+// packages/agent-runtime/workspaceShell.ts
+var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
+var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
+var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
+function readTrimmedString(value) {
+  return asOptionalTrimmedString(value);
+}
+function extractActivityRefs(rawRefs) {
+  if (!Array.isArray(rawRefs)) return void 0;
+  const refs = rawRefs.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim()) {
+      return [{ type: "file", path: entry.trim() }];
+    }
+    if (!isRecord(entry)) return [];
+    const path = readTrimmedString(entry.path);
+    if (path) return [{ type: "file", path }];
+    const terminalId = readTrimmedString(entry.id);
+    const terminalLabel = readTrimmedString(entry.label);
+    if (entry.type === "terminal" || terminalId || terminalLabel) {
+      return [{
+        type: "terminal",
+        ...terminalId ? { id: terminalId } : {},
+        ...terminalLabel ? { label: terminalLabel } : {}
+      }];
+    }
+    if (entry.type === "url" || typeof entry.url === "string") {
+      const url = readTrimmedString(entry.url);
+      const label = readTrimmedString(entry.label);
+      return url ? [{ type: "url", url, ...label ? { label } : {} }] : [];
+    }
+    return [];
+  });
+  return refs.length ? refs : void 0;
+}
+function extractActivityAction(rawAction) {
+  if (!isRecord(rawAction)) return void 0;
+  const title = readTrimmedString(rawAction.title);
+  if (!title) return void 0;
+  const kind = readTrimmedString(rawAction.kind);
+  const detail = readTrimmedString(rawAction.detail);
+  const refs = extractActivityRefs(rawAction.refs);
+  return {
+    title,
+    ...kind ? { kind } : {},
+    ...detail ? { detail } : {},
+    ...refs ? { refs } : {}
+  };
+}
+function extractActivityPhase(rawPhase) {
+  if (!isRecord(rawPhase)) return void 0;
+  const title = readTrimmedString(rawPhase.title);
+  if (!title) return void 0;
+  const id = readTrimmedString(rawPhase.id) || title.toLowerCase().replace(/\s+/g, "-");
+  const index = asOptionalFiniteNumber(rawPhase.index);
+  const total = asOptionalFiniteNumber(rawPhase.total);
+  const status = rawPhase.status === "pending" || rawPhase.status === "running" || rawPhase.status === "success" || rawPhase.status === "failed" ? rawPhase.status : void 0;
+  return {
+    id,
+    title,
+    ...index !== void 0 ? { index } : {},
+    ...total !== void 0 ? { total } : {},
+    ...status ? { status } : {}
+  };
+}
+function extractActivityPlan(rawPlan) {
+  if (!isRecord(rawPlan)) return void 0;
+  if (!Array.isArray(rawPlan.phases)) return void 0;
+  const phases = rawPlan.phases.flatMap((entry, index) => {
+    const phase = extractActivityPhase(entry);
+    if (!phase) return [];
+    return [{
+      id: phase.id,
+      title: phase.title,
+      index: phase.index ?? index + 1,
+      ...phase.status ? { status: phase.status } : {}
+    }];
+  });
+  if (phases.length === 0) return void 0;
+  const title = readTrimmedString(rawPlan.title);
+  return {
+    ...title ? { title } : {},
+    phases
+  };
+}
+function extractActivity(parsed) {
+  const raw = parsed._activity;
+  if (!isRecord(raw)) return void 0;
+  const nestedAction = extractActivityAction(raw.action);
+  const legacyAction = extractActivityAction(raw);
+  const action = nestedAction || legacyAction;
+  const phase = extractActivityPhase(raw.phase);
+  const plan = extractActivityPlan(raw.plan);
+  if (!action && !plan) return void 0;
+  return {
+    ...action ? action : {},
+    ...phase ? { phase } : {},
+    ...nestedAction ? { action: nestedAction } : {},
+    ...plan ? { plan } : {}
+  };
+}
+function tokenizeShellPrefix(command) {
+  const tokens = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s"'|;&<>]+)/g;
+  let match;
+  while (match = pattern.exec(command)) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+  }
+  return tokens;
+}
+function resolvePowerShellShellKind(executable) {
+  const base = (executable.split(/[\\/]/).pop() ?? "").toLowerCase();
+  return base === "pwsh" || base === "pwsh.exe" ? "pwsh" : "powershell5";
+}
+function wrapPowerShellCommand(command, shellKind = "pwsh") {
+  return [
+    "[Console]::InputEncoding=[System.Text.Encoding]::UTF8",
+    "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$OutputEncoding=[System.Text.Encoding]::UTF8",
+    // $PSStyle only exists on PowerShell 7+; injecting it on 5.1 makes every
+    // command emit a PropertyNotFound error on stderr.
+    ...shellKind === "pwsh" ? ["$PSStyle.OutputRendering='PlainText'"] : [],
+    command
+  ].join("; ");
+}
+var cachedPowerShellExecutable;
+var cachedBashExecutable;
+function selectPowerShellExecutable(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const resolveOnPath = deps.resolveOnPath ?? resolveExecutableOnPath;
+  const resolveAliasTarget = deps.resolveAliasTarget ?? ((path) => resolveWindowsPowerShellAliasTarget(path, { platform, env }));
+  const isAliasPath = deps.isAliasPath ?? ((path) => isWindowsStoreAliasPath(path, { platform, env }));
+  const pathHit = resolveOnPath("pwsh");
+  const aliasTarget = pathHit ? resolveAliasTarget(pathHit) : null;
+  if (aliasTarget) return aliasTarget;
+  if (pathHit && !isAliasPath(pathHit)) return pathHit;
+  const alias = (deps.findAlias ?? (() => findWindowsPowerShellAlias({ platform, env })))();
+  if (alias) return alias;
+  return resolveOnPath("powershell.exe") ?? resolveOnPath("powershell");
+}
+function findPowerShellExecutable() {
+  if (cachedPowerShellExecutable !== void 0) return cachedPowerShellExecutable;
+  cachedPowerShellExecutable = selectPowerShellExecutable();
+  return cachedPowerShellExecutable;
+}
+function buildPowerShellSpawnArgs(args) {
+  return [
+    args.executable,
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    wrapPowerShellCommand(args.command, resolvePowerShellShellKind(args.executable))
+  ];
+}
+function resolveShellLoginMode() {
+  if (process.env.NOLO_SHELL_LOGIN_MODE === "login" || process.env.NOLO_LOGIN_SHELL === "1") {
+    return "login";
+  }
+  return "fast";
+}
+function buildBashCommand(command, options) {
+  if (cachedBashExecutable === void 0) {
+    cachedBashExecutable = resolveExecutableOnPath("bash") || resolveExecutableOnPath("sh");
+  }
+  if (!cachedBashExecutable) throw new Error("bash/sh is not available on this machine.");
+  const isLogin = options?.login ?? resolveShellLoginMode() === "login";
+  return [cachedBashExecutable, isLogin ? "-lc" : "-c", command];
+}
+function buildWorkspaceShellPlan(args) {
+  if (args.shell === "bash") {
+    const argv2 = buildBashCommand(args.command, { login: args.login });
+    return { argv: argv2, resolvedShell: "bash", executable: argv2[0] ?? "bash" };
+  }
+  if (args.shell === "powershell" || process.platform === "win32") {
+    const executable = findPowerShellExecutable();
+    if (!executable) throw new Error("PowerShell is not available on this machine.");
+    return {
+      argv: buildPowerShellSpawnArgs({ executable, command: args.command }),
+      resolvedShell: "powershell",
+      executable,
+      shellKind: resolvePowerShellShellKind(executable)
+    };
+  }
+  const argv = buildBashCommand(args.command, { login: args.login });
+  return { argv, resolvedShell: "bash", executable: argv[0] ?? "bash" };
+}
+function buildWorkspaceShellCommand(args) {
+  return buildWorkspaceShellPlan(args).argv;
+}
+function findWorkspaceShellEscapeToken(command) {
+  const tokens = tokenizeShellPrefix(command);
+  for (const token of tokens) {
+    if (token === ".." || token.startsWith("../") || token.startsWith("..\\") || token.includes("/../") || token.includes("\\..\\")) {
+      return token;
+    }
+    if (token === "~" || token.startsWith("~/") || token.startsWith("~\\")) {
+      return token;
+    }
+    if (token === "/" || token.startsWith("/") || /^[A-Za-z]:[\\/]/.test(token) || token.startsWith("\\\\")) {
+      return token;
+    }
+  }
+  return null;
+}
+function buildWorkspaceShellEscapeBlockedResult(args) {
+  return {
+    content: [
+      "workspace_shell_escape_blocked",
+      `blockedToken: ${args.token}`,
+      `command: ${args.command}`,
+      "Use paths relative to the authorized folder only.",
+      "exitCode: 126"
+    ].join("\n"),
+    metadata: {
+      exitCode: 126,
+      workspaceShellEscapeBlocked: true,
+      blockedToken: args.token
+    }
+  };
+}
+function extractInteractiveGhAuthCommand(command) {
+  const tokens = tokenizeShellPrefix(command);
+  if (tokens[0] !== "gh" || tokens[1] !== "auth") return null;
+  const subcommand = tokens[2];
+  if (subcommand !== "login" && subcommand !== "refresh") return null;
+  if (tokens.includes("--help")) return null;
+  const result = ["gh", "auth", subcommand];
+  for (let index = 3; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-h" || token === "--hostname" || token === "-s" || token === "--scopes" || token === "--remove-scopes" || token === "-r") {
+      const value = tokens[index + 1];
+      if (value) {
+        result.push(token, value);
+        index += 1;
+      }
+      continue;
+    }
+    if (token === "--clipboard" || token === "-c" || token === "--insecure-storage" || token === "--reset-scopes") {
+      result.push(token);
+      continue;
+    }
+    if (token.startsWith("--hostname=") || token.startsWith("--scopes=") || token.startsWith("--remove-scopes=")) {
+      result.push(token);
+      continue;
+    }
+  }
+  return result.join(" ");
+}
+function buildInteractiveCommandBlockedResult(command) {
+  const argv = tokenizeShellPrefix(command);
+  return {
+    content: [
+      "action_gate: handoff",
+      `command: ${command}`,
+      "Run this in the current TUI terminal, then resume the agent turn.",
+      "exitCode: 130"
+    ].join("\n"),
+    metadata: {
+      exitCode: 130,
+      timedOut: false,
+      actionGate: {
+        id: `gate-${Date.now().toString(36)}-terminal-handoff`,
+        kind: "handoff",
+        title: "This command requires an interactive terminal.",
+        body: "Complete it in the terminal, then nolo will continue.",
+        payload: {
+          command: argv,
+          displayCommand: command
+        }
+      },
+      reason: "interactive-command-requires-terminal"
+    }
+  };
+}
+function resolveExecShellTimeoutMs(override) {
+  const fromOverride = asOptionalPositiveFiniteNumber(override);
+  if (fromOverride !== void 0) return fromOverride;
+  const raw = process.env[EXEC_SHELL_TIMEOUT_ENV];
+  if (raw === void 0) return void 0;
+  return asOptionalPositiveFiniteNumber(Number(raw));
+}
+function resolveDetachMs(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+    return override;
+  }
+  const raw = process.env[EXEC_SHELL_DETACH_ENV];
+  if (raw === void 0) return DEFAULT_EXEC_SHELL_DETACH_MS;
+  const parsed = asOptionalPositiveFiniteNumber(Number(raw));
+  return parsed === void 0 ? DEFAULT_EXEC_SHELL_DETACH_MS : parsed;
+}
+function truncateToolOutput(value, limit = 2e4, options) {
+  if (value.length <= limit) return value;
+  let spillNote = "";
+  try {
+    const spill = spillToolOutput({
+      content: value,
+      toolName: options?.toolName ?? "execShell",
+      workspaceRoot: options?.workspaceRoot
+    });
+    spillNote = `; spillFile=${spill.displayPath}; totalLines=${spill.totalLines}`;
+  } catch {
+  }
+  const approxMarkerLen = 40 + spillNote.length;
+  if (limit <= approxMarkerLen) return value.slice(0, limit);
+  const remaining = limit - approxMarkerLen;
+  const headSize = Math.floor(remaining * 0.3);
+  const tailSize = remaining - headSize;
+  const head = value.slice(0, headSize);
+  const tail = value.slice(-tailSize);
+  const actualRemoved = value.length - headSize - tailSize;
+  return `${head}
+
+[... truncated ${actualRemoved} chars${spillNote} ...]
+
+${tail}`;
+}
+var DEFAULT_MAX_STREAM_BUFFER_BYTES = 5 * 1024 * 1024;
+function removeSpillFile(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+}
+function readNodeStream(stream, maxBytesOrOptions = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
+  if (!stream) return Promise.resolve("");
+  const options = typeof maxBytesOrOptions === "number" ? { maxBytes: maxBytesOrOptions } : maxBytesOrOptions ?? {};
+  const maxBytes = typeof options.maxBytes === "number" && Number.isFinite(options.maxBytes) && options.maxBytes >= 0 ? options.maxBytes : DEFAULT_MAX_STREAM_BUFFER_BYTES;
+  const spillPath = asOptionalTrimmedString(options.spillPath);
+  const spillRetention = options.spillRetention ?? "keep";
+  const createSink = options.spillSinkFactory ?? ((path) => createWriteStream(path));
+  return new Promise((resolveStream, rejectStream) => {
+    const chunks = [];
+    let totalBytes = 0;
+    let settled = false;
+    let truncated = false;
+    let spillState = spillPath ? "idle" : "disabled";
+    let spillError = null;
+    let spillRetainedPath = null;
+    let sourceEnded = false;
+    let spillSink = null;
+    let sourcePausedForSpill = false;
+    let sinkFinished = false;
+    const formatLimit = maxBytes >= 1024 * 1024 ? `${Math.round(maxBytes / (1024 * 1024))}MB` : `${Math.round(maxBytes / 1024)}KB`;
+    const resumeSourceIfPaused = () => {
+      if (!sourcePausedForSpill) return;
+      sourcePausedForSpill = false;
+      try {
+        stream.resume?.();
+      } catch {
+      }
+    };
+    const markSpillFailed = (error) => {
+      if (spillState === "failed") return;
+      spillState = "failed";
+      if (!spillError) {
+        spillError = toErrorMessage(error);
+      }
+      const sink = spillSink;
+      spillSink = null;
+      if (sink) {
+        try {
+          sink.destroy?.();
+        } catch {
+        }
+      }
+      resumeSourceIfPaused();
+    };
+    const writeToSink = (buf) => {
+      const sink = spillSink;
+      if (!sink || spillState !== "open") return;
+      if (sink.destroyed === true) {
+        markSpillFailed(new Error("spill writable closed before finish"));
+        return;
+      }
+      let accepted = true;
+      try {
+        accepted = sink.write(buf) !== false;
+      } catch (error) {
+        markSpillFailed(error);
+        return;
+      }
+      if (!accepted && !sourcePausedForSpill) {
+        sourcePausedForSpill = true;
+        try {
+          stream.pause?.();
+        } catch {
+          sourcePausedForSpill = false;
+        }
+      }
+    };
+    const openSpill = (headChunks, crossingChunk) => {
+      if (!spillPath || spillState !== "idle") return;
+      let sink;
+      try {
+        mkdirSync2(dirname(spillPath), { recursive: true });
+        sink = createSink(spillPath);
+        sink.on("error", (error) => markSpillFailed(error));
+        sink.on("drain", () => {
+          if (settled) return;
+          resumeSourceIfPaused();
+        });
+        sink.on("finish", () => {
+          sinkFinished = true;
+        });
+        sink.on("close", () => {
+          if (sinkFinished || spillState !== "open") return;
+          markSpillFailed(new Error("spill writable closed before finish"));
+        });
+      } catch (error) {
+        spillState = "failed";
+        spillError = toErrorMessage(error);
+        spillSink = null;
+        return;
+      }
+      spillSink = sink;
+      spillState = "open";
+      for (const head of headChunks) writeToSink(head);
+      writeToSink(crossingChunk);
+    };
+    const settleSpillRetention = async () => {
+      if (!spillPath || spillRetention === "keep") {
+        if (spillPath && spillRetention === "keep" && spillState === "ok") {
+          spillRetainedPath = spillPath;
+        }
+        return;
+      }
+      if (spillRetention === "promote" && spillState === "ok" && sourceEnded) {
+        const promoted = await promoteToolSpillFile(spillPath, {
+          workspaceRoot: options.spillWorkspaceRoot
+        });
+        if (promoted.ok) {
+          spillRetainedPath = promoted.displayPath;
+          return;
+        }
+        if (promoted.preservedPath) {
+          return;
+        }
+      }
+      removeSpillFile(spillPath);
+    };
+    const finalize = (wasTruncated) => {
+      if (settled) return;
+      settled = true;
+      const truncatedNow = wasTruncated || truncated;
+      const baseText = Buffer.concat(chunks).toString("utf8");
+      const done = async () => {
+        await settleSpillRetention();
+        let text = baseText;
+        if (truncatedNow) {
+          const notes = [`output exceeded ${formatLimit} buffer limit`];
+          if (spillRetainedPath && sourceEnded) {
+            notes.push(`full output: ${spillRetainedPath}`);
+          } else if (spillPath) {
+            notes.push(
+              spillState === "failed" ? `spill failed${spillError ? ` (${spillError})` : ""}; output incomplete` : `spill output not retained; output incomplete`
+            );
+          }
+          text += `
+
+[stream pipe truncated: ${notes.join("; ")}]`;
+        }
+        resolveStream(text);
+      };
+      const sink = spillSink;
+      if (!sink || spillState !== "open") {
+        void done();
+        return;
+      }
+      let closed = false;
+      const settleSink = (failed, error) => {
+        if (closed) return;
+        closed = true;
+        if (failed) {
+          markSpillFailed(error ?? new Error("spill write failed"));
+        } else if (spillState === "open") {
+          spillState = "ok";
+        }
+        void done();
+      };
+      if (sink.destroyed === true) {
+        settleSink(true, new Error("spill writable closed before finish"));
+        return;
+      }
+      sink.once("error", (error) => settleSink(true, error));
+      sink.once("finish", () => settleSink(false));
+      sink.once("close", () => {
+        settleSink(!sinkFinished, new Error("spill writable closed before finish"));
+      });
+      try {
+        sink.end?.();
+      } catch (error) {
+        settleSink(true, error);
+      }
+    };
+    stream.on("data", (chunk) => {
+      if (settled) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      if (truncated) {
+        writeToSink(buf);
+        return;
+      }
+      if (totalBytes + buf.length >= maxBytes) {
+        const remaining = Math.max(0, maxBytes - totalBytes);
+        const headChunks = chunks.slice();
+        if (remaining > 0) {
+          chunks.push(buf.subarray(0, remaining));
+        }
+        totalBytes += buf.length;
+        truncated = true;
+        openSpill(headChunks, buf);
+        return;
+      }
+      totalBytes += buf.length;
+      chunks.push(buf);
+    });
+    stream.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      const sink = spillSink;
+      spillSink = null;
+      if (!spillError) spillError = toErrorMessage(error);
+      if (spillState !== "failed" && spillState !== "disabled") {
+        spillState = "failed";
+      }
+      if (sink) {
+        try {
+          sink.destroy?.();
+        } catch {
+        }
+      }
+      resumeSourceIfPaused();
+      void settleSpillRetention();
+      rejectStream(error);
+    });
+    stream.on("end", () => {
+      sourceEnded = true;
+      finalize(false);
+    });
+    stream.on("close", () => finalize(false));
+  });
+}
+function waitForNodeProcessExit(proc) {
+  return new Promise((resolveExit, rejectExit) => {
+    proc.on("error", rejectExit);
+    proc.on("close", (code) => {
+      resolveExit(code ?? 0);
+    });
+  });
+}
+function deriveLabel(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return "process";
+  const tokens = trimmed.split(/\s+/);
+  const lastToken = tokens[tokens.length - 1] ?? trimmed;
+  const labelCandidate = lastToken.split(/[/\\]/).pop() || lastToken;
+  return labelCandidate || trimmed;
+}
+function isSpawnFailureError(error) {
+  if (!error || typeof error !== "object") return false;
+  const err = error;
+  if (err.code === "ENOENT") return true;
+  const message = toErrorMessage(error).toLowerCase();
+  return message.includes("enoent") || message.includes("executable not found") || message.includes("spawn") && message.includes("not found");
+}
+function spawnFailedCommandResult(error, outputLimit) {
+  const stderr = `spawn failed: ${toErrorMessage(error)}
+`;
+  return {
+    stdout: "",
+    stderr,
+    exitCode: 127,
+    timedOut: false,
+    spawnFailed: true,
+    content: truncateToolOutput(
+      [`stderr:
+${stderr.trim()}`, "exitCode: 127"].filter(Boolean).join("\n\n"),
+      outputLimit
+    )
+  };
+}
+function stdoutPromiseResult(promise) {
+  return promise.then(
+    (value) => ({ value }),
+    (error) => ({
+      value: "",
+      error: error instanceof Error ? error.message : String(error)
+    })
+  );
+}
+async function runWorkspaceCommand(args) {
+  const timeoutMs = asOptionalPositiveFiniteNumber(args.timeoutMs);
+  const detached = process.platform !== "win32";
+  const command = [
+    ...args.commandPrefix ?? [],
+    ...args.command
+  ];
+  const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
+    cwd: resolve(args.workspaceRoot),
+    stdio: [
+      args.stdin === void 0 ? "ignore" : "pipe",
+      "pipe",
+      "pipe"
+    ],
+    detached
+  });
+  if (args.stdin !== void 0 && proc.stdin) {
+    proc.stdin.write(args.stdin);
+    proc.stdin.end();
+  }
+  const label = args.label?.trim() || deriveLabel(args.command.join(" "));
+  const registry2 = getProcessRegistry();
+  if (typeof proc.pid === "number") {
+    registry2.add({
+      pid: proc.pid,
+      pgid: proc.pid,
+      command: args.command.join(" "),
+      label,
+      // Foreground grace-period envelope: not a user-visible background task
+      // until promote() flips the marker on timeout detach (see
+      // listBackground). Keeps the status line / /procs / /stop semantics
+      // identical to pre-Phase-0. Ownership rides along so the promoted record
+      // stays attributable without any terminal-time inference.
+      transient: true,
+      owner: args.owner ?? null
+    });
+  }
+  const exitPromise = waitForNodeProcessExit(proc);
+  const cleanupChildOnHostSignal = (signal) => {
+    if (typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+      } catch {
+      }
+    }
+  };
+  if (detached) {
+    process.once("SIGHUP", cleanupChildOnHostSignal);
+    process.once("SIGTERM", cleanupChildOnHostSignal);
+    process.once("SIGINT", cleanupChildOnHostSignal);
+  }
+  const detachSignalCleanup = () => {
+    if (!detached) return;
+    process.removeListener("SIGHUP", cleanupChildOnHostSignal);
+    process.removeListener("SIGTERM", cleanupChildOnHostSignal);
+    process.removeListener("SIGINT", cleanupChildOnHostSignal);
+  };
+  exitPromise.then(detachSignalCleanup, detachSignalCleanup);
+  const stdoutCapture = stdoutPromiseResult(
+    readNodeStream(proc.stdout, {
+      spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}.log`),
+      spillRetention: "promote",
+      spillWorkspaceRoot: args.workspaceRoot
+    })
+  );
+  const stderrCapture = stdoutPromiseResult(
+    readNodeStream(proc.stderr, {
+      spillPath: join3(tmpdir(), `nolo-stream-${randomUUID2()}-stderr.log`),
+      spillRetention: "promote",
+      spillWorkspaceRoot: args.workspaceRoot
+    })
+  );
+  const killChild = (signal) => {
+    if (detached && typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+        return;
+      } catch {
+      }
+    }
+    try {
+      proc.kill(signal);
+    } catch {
+    }
+  };
+  let timeout;
+  let detachTimer;
+  const timeoutResult = Symbol("timeout");
+  const abortResult = Symbol("abort");
+  const detachResult = Symbol("detach");
+  let abortListener;
+  const abortPromise = args.abortSignal ? new Promise((resolveAbort) => {
+    if (args.abortSignal.aborted) {
+      resolveAbort(abortResult);
+      return;
+    }
+    abortListener = () => resolveAbort(abortResult);
+    args.abortSignal.addEventListener("abort", abortListener, { once: true });
+  }) : null;
+  const effectiveDetachMs = resolveDetachMs(args.detachMs);
+  const detachPromise = new Promise((resolveDetach) => {
+    detachTimer = setTimeout(() => resolveDetach(detachResult), effectiveDetachMs);
+  });
+  const exitOrTimeoutPromise = timeoutMs ? Promise.race([
+    exitPromise,
+    new Promise((resolveTimeout) => {
+      timeout = setTimeout(() => resolveTimeout(timeoutResult), timeoutMs);
+    })
+  ]) : exitPromise;
+  const raceCandidates = [
+    exitOrTimeoutPromise,
+    detachPromise
+  ];
+  if (abortPromise) {
+    raceCandidates.push(abortPromise);
+  }
+  let raceWinner;
+  try {
+    raceWinner = await Promise.race(raceCandidates);
+  } catch (error) {
+    if (timeout) clearTimeout(timeout);
+    if (detachTimer) clearTimeout(detachTimer);
+    if (abortListener && args.abortSignal) {
+      args.abortSignal.removeEventListener("abort", abortListener);
+    }
+    if (typeof proc.pid === "number") {
+      registry2.remove(proc.pid);
+    }
+    if (isSpawnFailureError(error)) {
+      return spawnFailedCommandResult(error, args.outputLimit);
+    }
+    throw error;
+  }
+  if (timeout) clearTimeout(timeout);
+  if (detachTimer) clearTimeout(detachTimer);
+  if (abortListener && args.abortSignal) {
+    args.abortSignal.removeEventListener("abort", abortListener);
+  }
+  const timedOut = raceWinner === timeoutResult;
+  const aborted = raceWinner === abortResult;
+  const detachedProcess = raceWinner === detachResult;
+  if (timedOut || aborted) {
+    killChild("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      killChild("SIGKILL");
+    }, 500);
+    try {
+      await exitPromise;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+  if (detachedProcess) {
+    exitPromise.catch(() => {
+    });
+    const pid = typeof proc.pid === "number" ? proc.pid : 0;
+    const pgid = pid;
+    const promoted = registry2.promote(pid);
+    const envelope = promoted ?? registry2.add({
+      pid,
+      pgid,
+      command: args.command.join(" "),
+      label,
+      promoted: true,
+      owner: args.owner ?? null
+    });
+    const taskId = envelope.taskId;
+    proc.on("close", (code) => {
+      detachSignalCleanup();
+      const exitCode2 = code ?? 1;
+      void (async () => {
+        const [stdoutResult, stderrResult] = await Promise.all([
+          stdoutCapture,
+          stderrCapture
+        ]);
+        const stdout2 = stdoutResult.value;
+        const stderr2 = stderrResult.value;
+        let capsule;
+        try {
+          capsule = buildProcessTaskResultCapsule({
+            stdout: stdout2,
+            stderr: stderr2,
+            exitCode: exitCode2,
+            // Duration is measured from the registry envelope's startedAt
+            // (spawn moment), not from the detach moment.
+            startedAt: registry2.get(pid)?.startedAt,
+            workspaceRoot: args.workspaceRoot,
+            captureError: [stdoutResult.error, stderrResult.error].filter(Boolean).join("; ")
+          });
+        } catch {
+        }
+        registry2.markExited(pid, exitCode2, capsule);
+      })();
+    });
+    const immediate = effectiveDetachMs === 0;
+    const reason = immediate ? `command looks long-running; moved to background immediately (pid=${pid}, label=${label})` : `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})`;
+    return {
+      stdout: "",
+      stderr: `${reason}
+Use listProcesses to inspect or stop it.`,
+      exitCode: 0,
+      timedOut: false,
+      detached: true,
+      pid,
+      label,
+      taskId,
+      content: JSON.stringify({
+        detached: true,
+        pid,
+        label,
+        taskId,
+        status: "running",
+        ...immediate ? { reason: "long-running-command" } : {}
+      })
+    };
+  }
+  const [stdoutCaptureResult, stderrCaptureResult] = await Promise.all([
+    stdoutCapture,
+    stderrCapture
+  ]);
+  const stdout = stdoutCaptureResult.value;
+  const rawStderr = stderrCaptureResult.value;
+  const streamCaptureError = [stdoutCaptureResult.error, stderrCaptureResult.error].filter(Boolean).join("; ");
+  const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
+  if (typeof proc.pid === "number") {
+    registry2.completeTransient(proc.pid, exitCode);
+  }
+  const stderr = aborted ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command aborted by signal
+` : timedOut ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command timed out after ${timeoutMs ?? "unknown"}ms
+` : rawStderr;
+  return {
+    stdout,
+    stderr,
+    exitCode,
+    timedOut,
+    aborted,
+    content: truncateToolOutput(
+      [
+        stdout.trim() ? `stdout:
+${stdout.trim()}` : "",
+        stderr.trim() ? `stderr:
+${stderr.trim()}` : "",
+        `exitCode: ${exitCode}`
+      ].filter(Boolean).join("\n\n"),
+      args.outputLimit,
+      {
+        toolName: "execShell",
+        workspaceRoot: args.workspaceRoot
+      }
+    )
+  };
+}
+
+export {
+  spillToolOutput,
+  formatToolOverflowMarker,
+  resolveExecutableOnPath,
+  createGlob,
+  spawnToWebStreams,
+  isProcessTaskTerminalStatus,
+  reportedTaskStatus,
+  toProcessTaskView,
+  getProcessRegistry,
+  buildProcessTaskResultCapsule,
+  extractActivity,
+  findPowerShellExecutable,
+  buildWorkspaceShellPlan,
+  buildWorkspaceShellCommand,
+  findWorkspaceShellEscapeToken,
+  buildWorkspaceShellEscapeBlockedResult,
+  extractInteractiveGhAuthCommand,
+  buildInteractiveCommandBlockedResult,
+  resolveExecShellTimeoutMs,
+  truncateToolOutput,
+  deriveLabel,
+  runWorkspaceCommand
+};