nolo-cli 0.157.0-alpha.1 → 0.157.0

package/{chunk-MM3662RS.js → chunk-LPO6AMQU.js}

@@ -2,13 +2,13 @@ import {
   isAgentRunTerminalStatus,
   normalizeRunTitle
 } from "./chunk-PJNFNEJE.js";
-import {
-  resolvePlatformAuthToken
-} from "./chunk-SUKSWFLP.js";
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
 } from "./chunk-A7GB5UGH.js";
+import {
+  resolvePlatformAuthToken
+} from "./chunk-PIG2IUVZ.js";
 
 // packages/cli/client/originShellApprovalTransport.ts
 import { realpathSync } from "node:fs";
@@ -320,10 +320,635 @@ function createShellApprovalChild(channel, timeoutMs = TTL) {
 
 // packages/cli/agentRunControl.ts
 import { homedir as nodeHomedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join, resolve } from "node:path";
-import * as nodeFs from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, join as join2, resolve } from "node:path";
+import * as nodeFs2 from "node:fs";
 import { execFileSync as nodeExecFileSync, spawn as nodeSpawn } from "node:child_process";
 
+// packages/cli/client/hostMemory.ts
+import { readFileSync, existsSync } from "node:fs";
+import { freemem as osFreemem, totalmem as osTotalmem } from "node:os";
+var PROC_MEMINFO_PATH = "/proc/meminfo";
+var PROC_MOUNTS_PATH = "/proc/mounts";
+var DEFAULT_CGROUP2_MOUNT = "/sys/fs/cgroup";
+var SANDBOX_MARKER_PATHS = ["/.dockerenv", "/run/.containerenv"];
+var PROC_SELF_CGROUP_PATH = "/proc/self/cgroup";
+var SANDBOX_CGROUP_PATTERN = /(docker|kubepods|instabox|containerd)/;
+var MEMORY_AVAILABLE_RATIO_THRESHOLD = 0.15;
+var SWAP_USED_RATIO_THRESHOLD = 0.7;
+var HOST_MEMORY_PRESSURE_HINT = "\u26A0 \u5185\u5B58\u504F\u7D27\uFF0C\u5EFA\u8BAE\u91CD\u6D3B\u653E\u6C99\u76D2/\u8FDC\u7AEF\u6216\u51CF\u5C11\u5E76\u53D1";
+var BYTES_PER_MB = 1024 * 1024;
+function toMbFromBytes(bytes) {
+  return Math.round(bytes / BYTES_PER_MB);
+}
+function kbToMb(kb) {
+  return Math.round(kb / 1024);
+}
+function tryReadText(deps, path) {
+  try {
+    const reader = deps.readFile ?? ((p) => readFileSync(p, "utf8"));
+    const text = reader(path);
+    return typeof text === "string" ? text : null;
+  } catch {
+    return null;
+  }
+}
+function tryExists(deps, path) {
+  try {
+    const checker = deps.exists ?? ((p) => existsSync(p));
+    return checker(path) === true;
+  } catch {
+    return false;
+  }
+}
+function readKbValue(text, key) {
+  const match = new RegExp(`^${key}:\\s*(\\d+)`, "m").exec(text);
+  if (!match) return null;
+  const value = Number.parseInt(match[1], 10);
+  return Number.isFinite(value) ? value : null;
+}
+function parseProcMeminfo(text) {
+  if (typeof text !== "string" || text.length === 0) return null;
+  const totalKb = readKbValue(text, "MemTotal");
+  const availableKb = readKbValue(text, "MemAvailable");
+  if (totalKb === null || availableKb === null) return null;
+  if (!(totalKb > 0)) return null;
+  const swapTotalKb = readKbValue(text, "SwapTotal") ?? 0;
+  const swapFreeKb = readKbValue(text, "SwapFree") ?? 0;
+  return {
+    source: "proc-meminfo",
+    totalMb: kbToMb(totalKb),
+    availableMb: kbToMb(Math.max(0, availableKb)),
+    swapTotalMb: kbToMb(Math.max(0, swapTotalKb)),
+    swapUsedMb: kbToMb(Math.max(0, swapTotalKb - swapFreeKb)),
+    hostAvailableMb: null
+  };
+}
+function detectSandbox(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") return false;
+  for (const marker of SANDBOX_MARKER_PATHS) {
+    if (tryExists(deps, marker)) return true;
+  }
+  const selfCgroup = tryReadText(deps, PROC_SELF_CGROUP_PATH);
+  return selfCgroup !== null && SANDBOX_CGROUP_PATTERN.test(selfCgroup);
+}
+function readOsView(deps) {
+  const os = deps.os ?? { totalmem: osTotalmem, freemem: osFreemem };
+  try {
+    const totalMb = toMbFromBytes(os.totalmem());
+    const availableMb = toMbFromBytes(os.freemem());
+    if (!(totalMb > 0) || !Number.isFinite(availableMb)) return null;
+    return {
+      source: "os",
+      totalMb,
+      availableMb: Math.max(0, availableMb),
+      // os 没有可移植的 swap 口径：按契约显示 n/a，而不是编一个数字。
+      swapTotalMb: null,
+      swapUsedMb: null,
+      hostAvailableMb: null
+    };
+  } catch {
+    return null;
+  }
+}
+function readHostView(deps) {
+  const platform = deps.platform ?? process.platform;
+  if (platform === "linux") {
+    const text = tryReadText(deps, PROC_MEMINFO_PATH);
+    if (text !== null) {
+      const parsed = parseProcMeminfo(text);
+      if (parsed) return parsed;
+    }
+  }
+  return readOsView(deps);
+}
+function parseCgroup2RelativePath(text) {
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(":");
+    if (parts.length < 3 || parts[0] !== "0" || parts[1] !== "") continue;
+    const path = parts.slice(2).join(":").trim();
+    if (!path) continue;
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+  return null;
+}
+function parseCgroup2MountPoint(mountsText) {
+  for (const line of mountsText.split("\n")) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length < 3) continue;
+    if (fields[2] !== "cgroup2") continue;
+    const mountPoint = fields[1].replace(/\\040/g, " ");
+    if (mountPoint.startsWith("/")) return mountPoint;
+  }
+  return null;
+}
+function cgroupAncestorDirs(mountPoint, relativePath) {
+  const base = mountPoint.length > 1 && mountPoint.endsWith("/") ? mountPoint.slice(0, -1) : mountPoint;
+  const dirs = [];
+  if (relativePath && relativePath !== "/") {
+    const rel = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
+    const segments = rel.split("/").filter(Boolean);
+    for (let depth = segments.length; depth >= 1; depth -= 1) {
+      dirs.push(`${base}/${segments.slice(0, depth).join("/")}`);
+    }
+  }
+  dirs.push(base);
+  return dirs;
+}
+function readCgroupMaxMb(deps, dir) {
+  const maxText = tryReadText(deps, `${dir}/memory.max`);
+  if (maxText === null) return null;
+  const maxRaw = maxText.trim();
+  if (maxRaw === "" || maxRaw === "max") return null;
+  const maxBytes = Number.parseInt(maxRaw, 10);
+  if (!Number.isFinite(maxBytes) || maxBytes <= 0) return null;
+  const totalMb = toMbFromBytes(maxBytes);
+  return totalMb > 0 ? totalMb : null;
+}
+function buildCgroupSnapshot(deps, dir, totalMb, hostView) {
+  const currentText = tryReadText(deps, `${dir}/memory.current`);
+  let usedMb = null;
+  if (currentText !== null) {
+    const currentBytes = Number.parseInt(currentText.trim(), 10);
+    if (Number.isFinite(currentBytes)) {
+      usedMb = Math.min(totalMb, Math.max(0, toMbFromBytes(currentBytes)));
+    }
+  }
+  return {
+    source: "cgroup",
+    totalMb,
+    availableMb: usedMb === null ? null : Math.max(0, totalMb - usedMb),
+    // swap 不是 cgroup 配额的一部分，只能借宿主视角（Linux 上就是 /proc/meminfo）。
+    swapTotalMb: hostView?.swapTotalMb ?? null,
+    swapUsedMb: hostView?.swapUsedMb ?? null,
+    hostAvailableMb: hostView?.availableMb ?? null
+  };
+}
+function readCgroupLimitView(deps, hostView) {
+  const selfCgroupText = tryReadText(deps, PROC_SELF_CGROUP_PATH) ?? "";
+  const relativePath = parseCgroup2RelativePath(selfCgroupText);
+  const mountsText = tryReadText(deps, PROC_MOUNTS_PATH) ?? "";
+  const mountPoint = parseCgroup2MountPoint(mountsText) ?? DEFAULT_CGROUP2_MOUNT;
+  let limitingDir = null;
+  let limitingMb = Number.POSITIVE_INFINITY;
+  for (const dir of cgroupAncestorDirs(mountPoint, relativePath)) {
+    const totalMb = readCgroupMaxMb(deps, dir);
+    if (totalMb === null) continue;
+    if (totalMb < limitingMb) {
+      limitingMb = totalMb;
+      limitingDir = dir;
+    }
+  }
+  if (limitingDir === null) return null;
+  return buildCgroupSnapshot(deps, limitingDir, limitingMb, hostView);
+}
+function readHostMemory(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "linux") {
+    return readHostView(deps);
+  }
+  const hostView = readHostView(deps);
+  const cgroupView = readCgroupLimitView(deps, hostView);
+  if (!cgroupView) return hostView;
+  return {
+    ...cgroupView,
+    scope: detectSandbox(deps) ? "sandbox" : "cgroup-limit"
+  };
+}
+function isHostMemoryTight(mem) {
+  if (!(mem.totalMb > 0)) return false;
+  if (mem.availableMb !== null && mem.availableMb / mem.totalMb < MEMORY_AVAILABLE_RATIO_THRESHOLD) {
+    return true;
+  }
+  if (mem.swapTotalMb !== null && mem.swapUsedMb !== null && mem.swapTotalMb > 0 && mem.swapUsedMb / mem.swapTotalMb > SWAP_USED_RATIO_THRESHOLD) {
+    return true;
+  }
+  return false;
+}
+function formatHostMemoryMb(mb) {
+  const value = Math.max(0, Math.round(Number.isFinite(mb) ? mb : 0));
+  if (value >= 1024) return `${(value / 1024).toFixed(1)}G`;
+  return `${value}M`;
+}
+function formatSwapPart(mem) {
+  if (mem.swapTotalMb === null || mem.swapUsedMb === null) return "swap n/a";
+  return `swap ${formatHostMemoryMb(mem.swapUsedMb)}/${formatHostMemoryMb(mem.swapTotalMb)}`;
+}
+function formatHostMemoryLine(mem) {
+  const usedMb = mem.availableMb === null ? null : Math.max(0, mem.totalMb - mem.availableMb);
+  let line;
+  if (mem.source === "cgroup") {
+    const hostAvailable = mem.hostAvailableMb === null ? "n/a" : formatHostMemoryMb(mem.hostAvailableMb);
+    const prefix = (mem.scope ?? "sandbox") === "cgroup-limit" ? "[\u9650\u989D] \u672C\u8FDB\u7A0B\u5185\u5B58" : "[sandbox] \u5BB9\u5668\u5185\u5B58";
+    const usage = usedMb === null ? "\u5360\u7528\u672A\u77E5" : formatHostMemoryMb(usedMb);
+    line = `${prefix} ${usage}/${formatHostMemoryMb(mem.totalMb)} \xB7 \u5BBF\u4E3B\u53EF\u7528 ${hostAvailable}`;
+  } else {
+    const available = mem.availableMb === null ? "n/a" : formatHostMemoryMb(mem.availableMb);
+    line = `\u672C\u5730\u5185\u5B58 ${formatHostMemoryMb(usedMb ?? 0)}/${formatHostMemoryMb(mem.totalMb)}\uFF08\u53EF\u7528 ${available}\uFF09\xB7 ${formatSwapPart(mem)}`;
+  }
+  return isHostMemoryTight(mem) ? `${line} \xB7 ${HOST_MEMORY_PRESSURE_HINT}` : line;
+}
+
+// packages/cli/client/hostMemoryReservation.ts
+import { join } from "path";
+import * as nodeFs from "fs";
+
+// packages/cli/client/hostMemoryAdmission.ts
+var LOCAL_AGENT_RUN_MIN_AVAILABLE_MB = 512;
+var STARTUP_WINDOW_MS = 1e4;
+var STARTUP_WINDOW_RESERVED_MB_PER_RUN = 384;
+var HostMemoryAdmissionError = class extends Error {
+  code = "HOST_MEMORY_ADMISSION_DENIED";
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "HostMemoryAdmissionError";
+    this.details = details;
+  }
+};
+function assertHostMemoryAdmission(deps = {}) {
+  const readMem = deps.readHostMemory ?? readHostMemory;
+  const snapshot = readMem(deps.hostMemoryDeps);
+  const minAvailableMb = deps.minAvailableMb ?? LOCAL_AGENT_RUN_MIN_AVAILABLE_MB;
+  const startupWindowMs = deps.startupWindowMs ?? STARTUP_WINDOW_MS;
+  const reservedMbPerRun = deps.reservedMbPerRun ?? STARTUP_WINDOW_RESERVED_MB_PER_RUN;
+  const now = deps.now ? deps.now().getTime() : Date.now();
+  for (const [name, value] of Object.entries({ minAvailableMb, startupWindowMs, reservedMbPerRun, now })) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new Error(`Invalid ${name}`);
+  }
+  if (!snapshot) {
+    throw new HostMemoryAdmissionError(
+      `[host-memory-admission] \u65E0\u6CD5\u6D4B\u5B9A\u672C\u673A\u53EF\u7528\u5185\u5B58\uFF08\u5FEB\u7167\u4E3A null\uFF09\uFF0C\u62D2\u7EDD\u672C\u5730 fork\u3002\u9700\u786E\u4FDD /proc/meminfo \u6216 OS \u5185\u5B58\u6307\u6807\u53EF\u8BFB\u3002`,
+      {
+        effectiveAvailableMb: null,
+        requiredMinMb: minAvailableMb,
+        source: "null",
+        limitingSource: "unknown",
+        activeStartupRuns: 0,
+        reservedStartupMb: 0,
+        unreservedAvailableMb: null
+      }
+    );
+  }
+  if (!["cgroup", "proc-meminfo", "os"].includes(snapshot.source)) throw new Error("Unknown host memory source");
+  let effectiveAvailableMb = null;
+  let limitingSource = "host";
+  if (snapshot.source === "cgroup") {
+    const cgroupAvail = snapshot.availableMb;
+    const hostAvail = snapshot.hostAvailableMb;
+    if (cgroupAvail === null || typeof cgroupAvail !== "number" || Number.isNaN(cgroupAvail) || !Number.isFinite(cgroupAvail) || cgroupAvail < 0) {
+      throw new HostMemoryAdmissionError(
+        `[host-memory-admission] cgroup \u914D\u989D\u5185\u5B58\u5360\u7528\u672A\u77E5\u6216\u65E0\u6548\uFF0C\u62D2\u7EDD\u65E0\u58F0\u5F53\u5145\u8DB3\u3002`,
+        {
+          effectiveAvailableMb: null,
+          requiredMinMb: minAvailableMb,
+          source: snapshot.source,
+          limitingSource: "cgroup",
+          activeStartupRuns: 0,
+          reservedStartupMb: 0,
+          unreservedAvailableMb: null
+        }
+      );
+    }
+    if (typeof hostAvail !== "number" || !Number.isFinite(hostAvail) || hostAvail < 0) {
+      throw new HostMemoryAdmissionError("[host-memory-admission] \u5BBF\u4E3B\u53EF\u7528\u5185\u5B58\u672A\u77E5\u6216\u65E0\u6548\uFF0C\u62D2\u7EDD\u672C\u5730 fork\u3002", {
+        effectiveAvailableMb: null,
+        requiredMinMb: minAvailableMb,
+        source: snapshot.source,
+        limitingSource: "host",
+        activeStartupRuns: 0,
+        reservedStartupMb: 0,
+        unreservedAvailableMb: null
+      });
+    }
+    if (Number.isFinite(hostAvail)) {
+      if (cgroupAvail <= hostAvail) {
+        effectiveAvailableMb = cgroupAvail;
+        limitingSource = "cgroup";
+      } else {
+        effectiveAvailableMb = hostAvail;
+        limitingSource = "host";
+      }
+    } else {
+      effectiveAvailableMb = cgroupAvail;
+      limitingSource = "cgroup";
+    }
+  } else {
+    if (snapshot.availableMb === null || typeof snapshot.availableMb !== "number" || Number.isNaN(snapshot.availableMb) || !Number.isFinite(snapshot.availableMb) || snapshot.availableMb < 0) {
+      throw new HostMemoryAdmissionError(
+        `[host-memory-admission] \u5BBF\u4E3B\u53EF\u7528\u5185\u5B58\u672A\u77E5\u6216\u65E0\u6548\uFF0C\u62D2\u7EDD\u65E0\u58F0\u5F53\u5145\u8DB3\u3002`,
+        {
+          effectiveAvailableMb: null,
+          requiredMinMb: minAvailableMb,
+          source: snapshot.source,
+          limitingSource: "host",
+          activeStartupRuns: 0,
+          reservedStartupMb: 0,
+          unreservedAvailableMb: null
+        }
+      );
+    }
+    effectiveAvailableMb = snapshot.availableMb;
+    limitingSource = "host";
+  }
+  let activeStartupRuns = 0;
+  if (deps.listRecentRuns) {
+    const records = deps.listRecentRuns();
+    if (!Array.isArray(records)) {
+      throw new HostMemoryAdmissionError(
+        `[host-memory-admission] \u83B7\u53D6\u6700\u8FD1\u8FD0\u884C\u8BB0\u5F55\u5217\u8868\u5931\u8D25\uFF0C\u62D2\u7EDD\u672A\u77E5\u5F53\u5F52\u96F6\u3002`,
+        {
+          effectiveAvailableMb,
+          requiredMinMb: minAvailableMb,
+          source: snapshot.source,
+          limitingSource,
+          activeStartupRuns: 0,
+          reservedStartupMb: 0,
+          unreservedAvailableMb: effectiveAvailableMb
+        }
+      );
+    }
+    for (const rec of records) {
+      if (!rec || typeof rec !== "object") {
+        throw new HostMemoryAdmissionError(
+          `[host-memory-admission] \u8FD0\u884C\u8BB0\u5F55\u635F\u574F\uFF0C\u62D2\u7EDD\u672A\u77E5\u5F53\u5F52\u96F6\u3002`,
+          {
+            effectiveAvailableMb,
+            requiredMinMb: minAvailableMb,
+            source: snapshot.source,
+            limitingSource,
+            activeStartupRuns: 0,
+            reservedStartupMb: 0,
+            unreservedAvailableMb: effectiveAvailableMb
+          }
+        );
+      }
+      if (rec.status !== "running") continue;
+      const startedTime = new Date(rec.startedAt).getTime();
+      if (!Number.isFinite(startedTime) || Number.isNaN(startedTime)) {
+        throw new HostMemoryAdmissionError(
+          `[host-memory-admission] \u8FD0\u884C\u8BB0\u5F55 startedAt \u65E0\u6548\uFF0C\u62D2\u7EDD\u672A\u77E5\u5F53\u5F52\u96F6\u3002`,
+          {
+            effectiveAvailableMb,
+            requiredMinMb: minAvailableMb,
+            source: snapshot.source,
+            limitingSource,
+            activeStartupRuns: 0,
+            reservedStartupMb: 0,
+            unreservedAvailableMb: effectiveAvailableMb
+          }
+        );
+      }
+      if (now - startedTime >= 0 && now - startedTime < startupWindowMs) {
+        activeStartupRuns += 1;
+      }
+    }
+  }
+  const reservedStartupMb = activeStartupRuns * reservedMbPerRun;
+  const netAvailableMb = effectiveAvailableMb - reservedStartupMb;
+  if (netAvailableMb < minAvailableMb) {
+    const detailMsg = `\u5F53\u524D\u6709\u6548\u53EF\u7528 ${formatHostMemoryMb(effectiveAvailableMb)}\uFF08\u53D7\u9650\u6E90: ${limitingSource}\uFF09` + (activeStartupRuns > 0 ? `\uFF0C\u5E76\u53D1\u542F\u52A8\u7A97\u53E3\u5185\u6709 ${activeStartupRuns} \u4E2A\u8FDB\u884C\u4E2D\u4EFB\u52A1\uFF08\u9884\u7559 ${formatHostMemoryMb(reservedStartupMb)}\uFF0C\u6298\u7B97\u5269\u4F59 ${formatHostMemoryMb(netAvailableMb)}\uFF09` : "") + `\uFF0C\u4F4E\u4E8E\u5B89\u5168\u9608\u503C ${formatHostMemoryMb(minAvailableMb)}\u3002`;
+    throw new HostMemoryAdmissionError(
+      `[host-memory-admission] \u62D2\u7EDD\u672C\u5730\u6D3E\u53D1\uFF1A${detailMsg}\u4E3A\u907F\u514D\u89E6\u53D1\u5BBF\u4E3B/cgroup OOM-killer \u5D29\u6E83\uFF0C\u8BF7\u7B49\u5F85\u5176\u4ED6\u4EFB\u52A1\u5B8C\u6210\u6216\u91CA\u653E\u5185\u5B58\u540E\u518D\u8BD5\u3002`,
+      {
+        effectiveAvailableMb: netAvailableMb,
+        requiredMinMb: minAvailableMb,
+        source: snapshot.source,
+        limitingSource,
+        activeStartupRuns,
+        reservedStartupMb,
+        unreservedAvailableMb: effectiveAvailableMb
+      }
+    );
+  }
+  return {
+    allowed: true,
+    effectiveAvailableMb: netAvailableMb,
+    requiredMinMb: minAvailableMb,
+    activeStartupRuns,
+    snapshot
+  };
+}
+
+// packages/cli/client/hostMemoryReservation.ts
+var MEMORY_RESERVATION_LOCK_ID = "__host_memory_reservation__";
+function resolveReservationsDir(runsDir) {
+  return join(runsDir, "reservations");
+}
+function defaultIsProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) throw new Error("Invalid PID");
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err && err.code === "ESRCH") {
+      return false;
+    }
+    return true;
+  }
+}
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+    }
+  }
+}
+function updateReservationFile(filePath, fs, updater) {
+  const record = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  updater(record);
+  const payload = JSON.stringify(record, null, 2);
+  if (fs.renameSync) {
+    const tmpPath = `${filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    fs.writeFileSync(tmpPath, payload);
+    fs.renameSync(tmpPath, filePath);
+  } else {
+    fs.writeFileSync(filePath, payload);
+  }
+  return record;
+}
+function scanActiveReservations(reservationsDir, deps) {
+  const { fs, nowMs, startupWindowMs, isProcessAlive } = deps;
+  if (!fs.existsSync(reservationsDir)) {
+    return { activeStartupRuns: 0, reservedStartupMb: 0 };
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(reservationsDir);
+  } catch (err) {
+    throw new Error(
+      `[host-memory-reservation] \u8BFB\u53D6\u9884\u7559\u76EE\u5F55\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let activeStartupRuns = 0;
+  let reservedStartupMb = 0;
+  for (const entry of entries) {
+    if (!entry.endsWith(".json") || !entry.startsWith("reservation-")) continue;
+    const filePath = join(reservationsDir, entry);
+    let record;
+    try {
+      const raw = fs.readFileSync(filePath, "utf8");
+      record = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `[host-memory-reservation] \u89E3\u6790\u9884\u7559\u8BB0\u5F55\u6587\u4EF6\u5931\u8D25 (${filePath}): ${err instanceof Error ? err.message : String(err)}\uFF0C\u62D2\u7EDD\u672A\u77E5\u5F53\u5F52\u96F6`
+      );
+    }
+    if (!record || typeof record !== "object") {
+      throw new Error(`[host-memory-reservation] \u9884\u7559\u8BB0\u5F55\u683C\u5F0F\u635F\u574F (${filePath})\uFF0C\u62D2\u7EDD\u672A\u77E5\u5F53\u5F52\u96F6`);
+    }
+    if (typeof record.reservedMb !== "number" || Number.isNaN(record.reservedMb) || !Number.isFinite(record.reservedMb) || record.reservedMb < 0) {
+      throw new Error(`[host-memory-reservation] \u9884\u7559\u8BB0\u5F55\u5305\u542B\u65E0\u6548 reservedMb (${filePath})`);
+    }
+    if (typeof record.createdAtMs !== "number" || Number.isNaN(record.createdAtMs) || !Number.isFinite(record.createdAtMs) || record.createdAtMs < 0) {
+      throw new Error(`[host-memory-reservation] \u9884\u7559\u8BB0\u5F55\u5305\u542B\u65E0\u6548 createdAtMs (${filePath})`);
+    }
+    if (record.status === "released" || record.status === "reclaimed") {
+      continue;
+    }
+    if (record.status !== "reserved" && record.status !== "active") {
+      throw new Error(`[host-memory-reservation] invalid status: ${filePath}`);
+    }
+    const ageMs = nowMs - record.createdAtMs;
+    const pid = record.childPid ?? record.holderPid;
+    if (!Number.isInteger(pid) || pid <= 0 || ageMs < 0) {
+      throw new Error(`[host-memory-reservation] invalid process/time: ${filePath}`);
+    }
+    const expectedStart = record.childPid ? record.childStartedAt : record.holderStartedAt;
+    let alive = true;
+    let actualStart;
+    try {
+      alive = isProcessAlive(pid);
+      if (alive && expectedStart) actualStart = deps.getProcessStartTime?.(pid);
+    } catch {
+    }
+    const reused = expectedStart && actualStart && Number.isFinite(actualStart.getTime()) && actualStart.toISOString() !== expectedStart;
+    if (!alive || reused || record.status === "active" && ageMs >= startupWindowMs) {
+      updateReservationFile(filePath, fs, (r) => {
+        r.status = "reclaimed";
+        r.reclaimedAt = new Date(nowMs).toISOString();
+        r.reason = !alive ? "stale_process_died" : reused ? "pid_reused" : "startup_window_elapsed_rss_accounted";
+      });
+      continue;
+    }
+    activeStartupRuns += 1;
+    reservedStartupMb += record.reservedMb;
+    if (!Number.isFinite(reservedStartupMb)) throw new Error("Invalid reservation total");
+  }
+  return { activeStartupRuns, reservedStartupMb };
+}
+function reserveHostMemory(deps) {
+  const fs = deps.fs ?? nodeFs;
+  const runsDir = deps.runsDir;
+  const reservationsDir = resolveReservationsDir(runsDir);
+  const now = deps.now ? deps.now() : /* @__PURE__ */ new Date();
+  let nowMs = now.getTime();
+  const minAvailableMb = deps.minAvailableMb ?? LOCAL_AGENT_RUN_MIN_AVAILABLE_MB;
+  const startupWindowMs = deps.startupWindowMs ?? STARTUP_WINDOW_MS;
+  const requestedMb = deps.requestedMb ?? STARTUP_WINDOW_RESERVED_MB_PER_RUN;
+  const isProcessAlive = deps.isProcessAlive ?? defaultIsProcessAlive;
+  const maxAttempts = deps.maxLockAttempts ?? 5;
+  const delayMs = deps.lockRetryDelayMs ?? 15;
+  for (const [name, value] of Object.entries({ requestedMb, minAvailableMb, startupWindowMs, maxAttempts, delayMs, nowMs })) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      throw new Error(`[host-memory-reservation] invalid ${name}: ${value}`);
+    }
+  }
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) throw new Error("Invalid lock attempts");
+  if (!deps.withLock) throw new Error("[host-memory-reservation] exclusive lock required");
+  fs.mkdirSync(reservationsDir, { recursive: true });
+  const locked = (fn) => {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = deps.withLock(MEMORY_RESERVATION_LOCK_ID, () => ({ value: fn() }), { strict: true });
+      if (result !== void 0) return result.value;
+      if (attempt + 1 < maxAttempts) sleepSync(delayMs);
+    }
+    throw new Error("[host-memory-reservation] exclusive lock timeout");
+  };
+  const executeReservation = () => {
+    nowMs = (deps.now ? deps.now() : /* @__PURE__ */ new Date()).getTime();
+    if (!Number.isFinite(nowMs)) throw new Error("Invalid reservation time");
+    const { activeStartupRuns, reservedStartupMb } = scanActiveReservations(reservationsDir, {
+      fs,
+      nowMs,
+      startupWindowMs,
+      isProcessAlive,
+      getProcessStartTime: deps.getProcessStartTime
+    });
+    assertHostMemoryAdmission({
+      readHostMemory: deps.readHostMemory,
+      hostMemoryDeps: deps.hostMemoryDeps,
+      minAvailableMb: minAvailableMb + reservedStartupMb + requestedMb,
+      now: () => new Date(nowMs)
+    });
+    const id = `res-${nowMs.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    const recordPath = join(reservationsDir, `reservation-${id}.json`);
+    const record = {
+      id,
+      runId: deps.runId,
+      status: "reserved",
+      reservedMb: requestedMb,
+      createdAt: new Date(nowMs).toISOString(),
+      createdAtMs: nowMs,
+      holderPid: process.pid,
+      holderStartedAt: deps.getProcessStartTime?.(process.pid)?.toISOString()
+    };
+    const payload = JSON.stringify(record, null, 2);
+    fs.writeFileSync(recordPath, payload, "utf8");
+    return {
+      id,
+      reservedMb: requestedMb,
+      recordPath,
+      associate(params) {
+        if (!params.runId || !Number.isInteger(params.pid) || params.pid <= 0) throw new Error("Invalid child association");
+        const validStart = !!params.processStartedAt && Number.isFinite(Date.parse(params.processStartedAt));
+        locked(() => updateReservationFile(recordPath, fs, (r) => {
+          if (r.status !== "reserved") throw new Error("Reservation is not reserved");
+          if (validStart) {
+            r.status = "active";
+            r.childStartedAt = params.processStartedAt;
+          }
+          if (params.runId) r.runId = params.runId;
+          if (typeof params.pid === "number") r.childPid = params.pid;
+        }));
+        if (!validStart) throw new Error("Child starttime unknown; reservation retained");
+      },
+      release(reason) {
+        locked(() => updateReservationFile(recordPath, fs, (r) => {
+          if (r.status === "reserved" || r.status === "active") {
+            r.status = "released";
+            r.releasedAt = (/* @__PURE__ */ new Date()).toISOString();
+            if (reason) r.reason = reason;
+          }
+        }));
+      }
+    };
+  };
+  if (deps.withLock) {
+    const withLock = deps.withLock;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const handle = withLock(MEMORY_RESERVATION_LOCK_ID, executeReservation, {
+        strict: true
+      });
+      if (handle !== void 0) {
+        return handle;
+      }
+      if (attempt < maxAttempts - 1) {
+        sleepSync(delayMs);
+      }
+    }
+    throw new Error(
+      `[host-memory-reservation] \u83B7\u53D6\u9884\u7559\u4E92\u65A5\u9501\u8D85\u65F6\uFF08\u5C1D\u8BD5 ${maxAttempts} \u6B21\uFF09\uFF0C\u62D2\u7EDD\u5E76\u53D1\u51FB\u7A7F`
+    );
+  }
+  throw new Error("[host-memory-reservation] exclusive lock required");
+}
+
 // packages/cli/client/localRuntimeHelpers.ts
 var REMOTE_DIALOG_SYNC_TIMEOUT_MS = 1e4;
 var remoteDialogSyncTimeoutMsForTest;
@@ -468,19 +1093,19 @@ function isRunTerminalStatus(status) {
 function resolveNoloHome(env, homedir = nodeHomedir) {
   const fromEnv = env?.NOLO_HOME;
   if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
-  return join(homedir(), ".nolo");
+  return join2(homedir(), ".nolo");
 }
 function resolveRunsDir(env, homedir = nodeHomedir) {
-  return join(resolveNoloHome(env, homedir), "runs");
+  return join2(resolveNoloHome(env, homedir), "runs");
 }
 function resolveRunRecordPath(runId, env, homedir = nodeHomedir) {
-  return join(resolveRunsDir(env, homedir), `${runId}.json`);
+  return join2(resolveRunsDir(env, homedir), `${runId}.json`);
 }
 function resolveRunLogPath(runId, env, homedir = nodeHomedir) {
-  return join(resolveRunsDir(env, homedir), `${runId}.log`);
+  return join2(resolveRunsDir(env, homedir), `${runId}.log`);
 }
 function resolveRunQueuePath(runId, env, homedir = nodeHomedir) {
-  return join(resolveRunsDir(env, homedir), `${runId}.queue.jsonl`);
+  return join2(resolveRunsDir(env, homedir), `${runId}.queue.jsonl`);
 }
 function defaultGenerateQueueEntryId() {
   const ts = Date.now().toString(36);
@@ -519,7 +1144,7 @@ function _serializeQueueEntries(entries) {
   return entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
 }
 var serializeQueueEntries = _serializeQueueEntries;
-function _countQueueMessagesLocked(queuePath, fs = nodeFs) {
+function _countQueueMessagesLocked(queuePath, fs = nodeFs2) {
   if (!fs.existsSync(queuePath)) return 0;
   try {
     const content = fs.readFileSync(queuePath, "utf8");
@@ -528,7 +1153,7 @@ function _countQueueMessagesLocked(queuePath, fs = nodeFs) {
     return 0;
   }
 }
-function _readQueueMessagesLocked(queuePath, fs = nodeFs) {
+function _readQueueMessagesLocked(queuePath, fs = nodeFs2) {
   if (!fs.existsSync(queuePath)) return [];
   try {
     const content = fs.readFileSync(queuePath, "utf8");
@@ -537,7 +1162,7 @@ function _readQueueMessagesLocked(queuePath, fs = nodeFs) {
     return [];
   }
 }
-function _readQueueEntriesLocked(queuePath, fs = nodeFs) {
+function _readQueueEntriesLocked(queuePath, fs = nodeFs2) {
   if (!fs.existsSync(queuePath)) return [];
   try {
     const content = fs.readFileSync(queuePath, "utf8");
@@ -604,13 +1229,13 @@ async function withQueueLock(queuePath, fnOrDeps, depsOrFnOrOpts, maybeOpts) {
     fn = depsOrFnOrOpts;
   }
   const deps = normalizeQueueDeps(rawDeps);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const staleLockMs = opts.staleLockMs ?? QUEUE_LOCK_STALE_MS;
   const retries = opts.retries ?? QUEUE_LOCK_RETRIES;
   const retryIntervalMs = opts.retryIntervalMs ?? QUEUE_LOCK_RETRY_INTERVAL_MS;
   const lockPath = `${queuePath}.lock`;
-  const tokenPath = join(lockPath, "owner.json");
+  const tokenPath = join2(lockPath, "owner.json");
   try {
     fs.mkdirSync(dirname(lockPath), { recursive: true });
   } catch {
@@ -703,7 +1328,7 @@ async function withQueueLock(queuePath, fnOrDeps, depsOrFnOrOpts, maybeOpts) {
 }
 async function appendRunQueue(queuePath, input, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const text = typeof input === "string" ? input : input.text;
   const entryId = typeof input === "object" && typeof input.id === "string" && input.id.trim() ? input.id.trim() : defaultGenerateQueueEntryId();
@@ -722,7 +1347,7 @@ async function appendRunQueue(queuePath, input, depsOrFs = {}) {
 }
 async function countQueueMessages(queuePath, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   if (!fs.existsSync(queuePath)) return 0;
   return await withQueueLock(queuePath, deps, async () => {
     return _countQueueMessagesLocked(queuePath, fs);
@@ -730,7 +1355,7 @@ async function countQueueMessages(queuePath, depsOrFs = {}) {
 }
 async function readQueueMessages(queuePath, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   if (!fs.existsSync(queuePath)) return [];
   return await withQueueLock(queuePath, deps, async () => {
     return _readQueueMessagesLocked(queuePath, fs);
@@ -738,7 +1363,7 @@ async function readQueueMessages(queuePath, depsOrFs = {}) {
 }
 async function readQueueEntries(queuePath, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   if (!fs.existsSync(queuePath)) return [];
   return await withQueueLock(queuePath, deps, async () => {
     return _readQueueEntriesLocked(queuePath, fs);
@@ -746,7 +1371,7 @@ async function readQueueEntries(queuePath, depsOrFs = {}) {
 }
 async function popAllQueueEntries(queuePath, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   return await withQueueLock(queuePath, deps, async () => {
     if (!fs.existsSync(queuePath)) return [];
     const content = fs.readFileSync(queuePath, "utf8");
@@ -757,7 +1382,7 @@ async function popAllQueueEntries(queuePath, depsOrFs = {}) {
 }
 async function popSingleQueueMessage(queuePath, depsOrFs = {}) {
   const deps = normalizeQueueDeps(depsOrFs);
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   return await withQueueLock(queuePath, deps, async () => {
     if (!fs.existsSync(queuePath)) return null;
     const content = fs.readFileSync(queuePath, "utf8");
@@ -792,15 +1417,19 @@ function defaultGenerateBatchId() {
 var LOCK_STALE_MS = 5e3;
 var TMP_STALE_MS = 6e4;
 function withRunRecordLock(runId, deps, fn, opts = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const lockPath = `${resolveRunRecordPath(runId, deps.env, deps.homedir)}.lock`;
   let held = false;
   try {
+    fs.mkdirSync(dirname(lockPath), { recursive: true });
     try {
       fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
       held = true;
-    } catch {
+    } catch (err) {
+      if (err?.code !== "EEXIST") {
+        throw err;
+      }
       try {
         const stat = fs.statSync?.(lockPath);
         const ageMs = stat ? now().getTime() - stat.mtimeMs : Number.POSITIVE_INFINITY;
@@ -824,7 +1453,7 @@ function withRunRecordLock(runId, deps, fn, opts = {}) {
   }
 }
 function writeRunRecord(record, deps = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const path = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
   fs.mkdirSync(resolveRunsDir(deps.env, deps.homedir), { recursive: true });
   const payload = JSON.stringify(record, null, 2);
@@ -846,7 +1475,7 @@ function writeRunRecord(record, deps = {}) {
 var FILE_EDIT_TOOL_NAMES = /* @__PURE__ */ new Set(["writeFile", "editFile"]);
 var DEFAULT_ACTIVITY_WRITE_INTERVAL_MS = 2e3;
 function createRunActivityTracker(runId, deps = {}, options = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const minWriteIntervalMs = options.minWriteIntervalMs ?? DEFAULT_ACTIVITY_WRITE_INTERVAL_MS;
   const keepAlive = options.keepAlive ?? true;
@@ -941,7 +1570,7 @@ function createRunActivityTracker(runId, deps = {}, options = {}) {
   return { onLoopEvent, getActivity, flush, dispose };
 }
 function readRunRecord(runId, deps = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const path = resolveRunRecordPath(runId, deps.env, deps.homedir);
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -963,7 +1592,7 @@ function backfillRunRecordParentDialog(runId, parentDialogId, deps = {}) {
   return updated === true;
 }
 function listRunRecords(deps = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const dir = resolveRunsDir(deps.env, deps.homedir);
   let entries = [];
   try {
@@ -1034,7 +1663,7 @@ function queryRunRecords(query, deps = {}) {
 }
 var DEFAULT_GC_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 async function gcRunRecords(deps = {}, options = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
   const nowMs = now instanceof Date ? now.getTime() : Date.parse(String(now));
   const retentionMs = typeof options.retentionMs === "number" && options.retentionMs >= 0 ? options.retentionMs : DEFAULT_GC_RETENTION_MS;
@@ -1049,7 +1678,7 @@ async function gcRunRecords(deps = {}, options = {}) {
     const jsonPath = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
     const logPath = resolveRunLogPath(record.runId, deps.env, deps.homedir);
     const queuePath = record.queuePath ?? resolveRunQueuePath(record.runId, deps.env, deps.homedir);
-    const msgPath = record.msgFile ?? join(resolveRunsDir(deps.env, deps.homedir), `${record.runId}.msg.md`);
+    const msgPath = record.msgFile ?? join2(resolveRunsDir(deps.env, deps.homedir), `${record.runId}.msg.md`);
     const logOk = tryUnlinkFile(fs, logPath);
     const msgOk = tryUnlinkFile(fs, msgPath);
     let queueOk = true;
@@ -1063,9 +1692,9 @@ async function gcRunRecords(deps = {}, options = {}) {
       }
     }
     const runsDirForLegacy = resolveRunsDir(deps.env, deps.homedir);
-    tryUnlinkFile(fs, join(runsDirForLegacy, `${record.runId}.report.md`));
-    tryUnlinkFile(fs, join(runsDirForLegacy, `${record.runId}.report.json`));
-    tryUnlinkFile(fs, record.resultFile ?? join(runsDirForLegacy, `${record.runId}.result.md`));
+    tryUnlinkFile(fs, join2(runsDirForLegacy, `${record.runId}.report.md`));
+    tryUnlinkFile(fs, join2(runsDirForLegacy, `${record.runId}.report.json`));
+    tryUnlinkFile(fs, record.resultFile ?? join2(runsDirForLegacy, `${record.runId}.result.md`));
     if (!logOk || !msgOk || !queueOk) {
       failedIds.push(record.runId);
       continue;
@@ -1082,7 +1711,7 @@ async function gcRunRecords(deps = {}, options = {}) {
     const statSync = fs.statSync;
     for (const entry of fs.readdirSync(dir)) {
       if (typeof entry !== "string" || !entry.endsWith(".tmp")) continue;
-      const tmpPath = join(dir, entry);
+      const tmpPath = join2(dir, entry);
       try {
         const stat = statSync?.(tmpPath);
         if (stat && nowMs - stat.mtimeMs <= TMP_STALE_MS) continue;
@@ -1143,7 +1772,7 @@ function rewriteMsgFileArg(args, messagePath) {
   }
   return result;
 }
-function resolveValidCliEntrypoint(cliEntrypointPath, fs = nodeFs) {
+function resolveValidCliEntrypoint(cliEntrypointPath, fs = nodeFs2) {
   if (cliEntrypointPath && fs.existsSync(cliEntrypointPath)) {
     return cliEntrypointPath;
   }
@@ -1152,11 +1781,11 @@ function resolveValidCliEntrypoint(cliEntrypointPath, fs = nodeFs) {
     return fallback;
   }
   const candidates = [
-    join(dirname(fallback), "cli", "index.ts"),
-    join(dirname(fallback), "cli", "index.js"),
-    join(dirname(fallback), "..", "packages", "cli", "index.ts"),
-    join(dirname(fallback), "..", "packages", "cli", "index.js"),
-    join(dirname(fallback), "..", "index.js")
+    join2(dirname(fallback), "cli", "index.ts"),
+    join2(dirname(fallback), "cli", "index.js"),
+    join2(dirname(fallback), "..", "packages", "cli", "index.ts"),
+    join2(dirname(fallback), "..", "packages", "cli", "index.js"),
+    join2(dirname(fallback), "..", "index.js")
   ];
   for (const cand of candidates) {
     if (fs.existsSync(cand)) {
@@ -1166,7 +1795,7 @@ function resolveValidCliEntrypoint(cliEntrypointPath, fs = nodeFs) {
   return fallback;
 }
 function buildAgentRunChildCommand(options, deps = {}) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   const execPath = process.execPath;
   const commandParts = options.commandPath ?? [];
   let strippedArgs = stripBackgroundFlag(options.rawArgs);
@@ -1183,10 +1812,27 @@ function buildAgentRunChildCommand(options, deps = {}) {
   }
   return { execPath, childArgs: [entrypoint, ...commandParts, ...strippedArgs] };
 }
+function emitHostMemoryNotice(mem, output) {
+  if (!mem || !output) return void 0;
+  let notice;
+  try {
+    notice = formatHostMemoryLine(mem);
+  } catch {
+    return void 0;
+  }
+  try {
+    output.write(`${notice}
+`);
+  } catch {
+    return notice;
+  }
+  return notice;
+}
 async function spawnLocalBackgroundRun(input, deps = {}) {
-  const env = deps.env ?? process.env;
   const homedir = deps.homedir ?? nodeHomedir;
-  const fs = deps.fs ?? nodeFs;
+  const env = deps.env ?? (deps.homedir ? { ...process.env, NOLO_HOME: join2(homedir(), ".nolo") } : process.env);
+  const resolvedDeps = { ...deps, env, homedir };
+  const fs = deps.fs ?? nodeFs2;
   const spawn = deps.spawn ?? nodeSpawn;
   const generateRunId = deps.generateRunId ?? defaultGenerateRunId;
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
@@ -1199,7 +1845,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
   fs.mkdirSync(runsDir, { recursive: true });
   let messagePath;
   if (typeof input.message === "string") {
-    messagePath = join(runsDir, `${runId}.msg.md`);
+    messagePath = join2(runsDir, `${runId}.msg.md`);
     fs.writeFileSync(messagePath, input.message);
   }
   const rawDodCommands = [];
@@ -1266,33 +1912,100 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     NOLO_AGENT_RUN_CHILD: "1",
     NOLO_AGENT_RUN_ID: runId
   };
+  let hostMemory = null;
+  let reservation;
   const logFd = fs.openSync(logPath, "a");
-  const proc = spawn(execPath, childArgs, {
-    cwd: input.cwd,
-    env: childEnv,
-    detached: true,
-    stdio: deps.shellApprovalHost ? ["ignore", logFd, logFd, "ipc"] : ["ignore", logFd, logFd]
+  const reservationFs = {
+    existsSync: (path) => fs.existsSync(path),
+    readFileSync: (path, encoding) => fs.readFileSync(path, encoding),
+    writeFileSync: (path, data, options) => fs.writeFileSync(path, data, options),
+    mkdirSync: (path, options) => fs.mkdirSync(path, options),
+    readdirSync: (path) => fs.readdirSync(path),
+    ...fs.renameSync ? { renameSync: (from, to) => fs.renameSync(from, to) } : {},
+    ...fs.statSync ? { statSync: (path) => ({ mtimeMs: fs.statSync(path).mtimeMs }) } : {}
+  };
+  let proc;
+  try {
+    reservation = reserveHostMemory({
+      runsDir,
+      runId,
+      fs: reservationFs,
+      now: resolvedDeps.now,
+      readHostMemory: () => hostMemory = (resolvedDeps.readHostMemory ?? readHostMemory)(),
+      getProcessStartTime: resolvedDeps.getProcessStartTime ?? defaultGetProcessStartTime,
+      withLock: (id, fn, opts) => withRunRecordLock(id, resolvedDeps, fn, opts)
+    });
+    proc = spawn(execPath, childArgs, {
+      cwd: input.cwd,
+      env: childEnv,
+      detached: true,
+      stdio: deps.shellApprovalHost ? ["ignore", logFd, logFd, "ipc"] : ["ignore", logFd, logFd]
+    });
+  } catch (error) {
+    try {
+      reservation?.release("spawn_sync_failed");
+    } finally {
+      finalizeRunRecord(runId, { status: "failed", exitCode: 1, note: String(error) }, resolvedDeps);
+    }
+    throw error;
+  } finally {
+    fs.closeSync?.(logFd);
+  }
+  proc.once?.("error", (error) => {
+    try {
+      reservation.release("child_error");
+    } catch (releaseError) {
+      finalizeRunRecord(runId, {
+        status: "failed",
+        exitCode: 1,
+        note: `${error}; reservation release failed: ${releaseError}`
+      }, resolvedDeps);
+      return;
+    }
+    finalizeRunRecord(runId, { status: "failed", exitCode: 1, note: String(error) }, resolvedDeps);
   });
+  const hostMemoryNotice = emitHostMemoryNotice(hostMemory, input.output);
+  if (typeof proc.pid === "number") {
+    let processStartedAt;
+    try {
+      processStartedAt = (resolvedDeps.getProcessStartTime ?? defaultGetProcessStartTime)(proc.pid);
+      if (processStartedAt && !Number.isFinite(processStartedAt.getTime())) processStartedAt = null;
+    } catch {
+      processStartedAt = null;
+    }
+    withRunRecordLock(runId, resolvedDeps, () => {
+      const latest = readRunRecord(runId, resolvedDeps) ?? record;
+      latest.pid = proc.pid;
+      if (processStartedAt) latest.processStartedAt = processStartedAt.toISOString();
+      writeRunRecord(latest, resolvedDeps);
+      return true;
+    }, { strict: true });
+    try {
+      const persisted = readRunRecord(runId, resolvedDeps);
+      reservation.associate({ runId, pid: proc.pid, processStartedAt: processStartedAt?.toISOString() });
+      if (persisted?.pid !== proc.pid || !persisted.processStartedAt) throw new Error("Child identity persistence failed");
+    } catch (error) {
+      throw new Error(`[host-memory-reservation] child ${proc.pid}, run ${runId}: association failed: ${error}`);
+    }
+  }
   if (deps.shellApprovalHost) {
     attachShellApprovalHost(proc, { ...deps.shellApprovalHost, binding: {
       ...deps.shellApprovalHost.binding,
       runId,
       agentKey: input.agentKey,
-      workspaceRoot: nodeFs.realpathSync(input.cwd ?? process.cwd())
+      workspaceRoot: nodeFs2.realpathSync(input.cwd ?? process.cwd())
     } });
     proc.channel?.unref?.();
   }
   proc.unref();
-  if (typeof proc.pid === "number") {
-    const processStartedAt = (deps.getProcessStartTime ?? defaultGetProcessStartTime)(proc.pid);
-    withRunRecordLock(runId, deps, () => {
-      const latest = readRunRecord(runId, deps) ?? record;
-      latest.pid = proc.pid;
-      if (processStartedAt) latest.processStartedAt = processStartedAt.toISOString();
-      writeRunRecord(latest, deps);
-    });
-  }
-  return { runId, pid: proc.pid, logPath, queuePath, batchId };
+  return {
+    runId,
+    pid: proc.pid,
+    logPath,
+    queuePath,
+    batchId,
+    ...hostMemoryNotice ? { hostMemoryNotice } : {}
+  };
 }
 function ackRunRecord(runId, deps = {}) {
   withRunRecordLock(runId, deps, () => {
@@ -1402,8 +2115,8 @@ function transitionRunToTerminal(runId, update, deps = {}, options = {}) {
     record2.endedAt = now().toISOString();
     if (typeof update.lastAssistantText === "string" && update.lastAssistantText) {
       try {
-        const fs = deps.fs ?? nodeFs;
-        const resultFile = join(resolveRunsDir(deps.env, deps.homedir), `${runId}.result.md`);
+        const fs = deps.fs ?? nodeFs2;
+        const resultFile = join2(resolveRunsDir(deps.env, deps.homedir), `${runId}.result.md`);
         const startedMs = Date.parse(record2.startedAt);
         const endedMs = Date.parse(record2.endedAt);
         const content = buildResultFileContent(
@@ -1570,7 +2283,7 @@ function formatDuration(startedAt, endedAt) {
   return `${seconds}s`;
 }
 function readLastLogLines(logPath, count, deps) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   try {
     const content = fs.readFileSync(logPath, "utf8");
     const lines = content.split("\n");
@@ -1581,7 +2294,7 @@ function readLastLogLines(logPath, count, deps) {
   }
 }
 function readLogContent(logPath, tailCount, deps) {
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   try {
     const content = fs.readFileSync(logPath, "utf8");
     if (typeof tailCount === "number" && tailCount > 0) {
@@ -1868,7 +2581,7 @@ async function runAgentLogsCommand(args, deps) {
 `);
     return 1;
   }
-  const fs = deps.fs ?? nodeFs;
+  const fs = deps.fs ?? nodeFs2;
   if (!fs.existsSync(record.logPath)) {
     deps.output.write(`Log not found: ${record.logPath}
 `);
@@ -1971,6 +2684,8 @@ async function runAgentKillCommand(args, deps) {
 
 export {
   createShellApprovalChild,
+  readHostMemory,
+  assertHostMemoryAdmission,
   setRemoteDialogSyncTimeoutForTest,
   remoteDialogSyncTimeout,
   resolveRuntimeServerUrl,
@@ -2008,6 +2723,7 @@ export {
   popQueueMessages,
   defaultGenerateRunId,
   defaultGenerateBatchId,
+  withRunRecordLock,
   writeRunRecord,
   createRunActivityTracker,
   readRunRecord,