nolo-cli 0.159.0-alpha.4 → 0.160.0-alpha.1

package/{chunk-B5JIGIKM.js → chunk-K25WQPP3.js}

@@ -14050,8 +14050,11 @@ function detectExecShellSynchronousWarnings(command, shell) {
 }
 
 // packages/agent-runtime/workspaceShell.ts
-import { resolve } from "node:path";
+import { createWriteStream, mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname, join as join4, resolve } from "node:path";
 import { spawn as spawnChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
 
 // packages/agent-runtime/runtimeCompat.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
@@ -14987,39 +14990,168 @@ function truncateToolOutput(value, limit = 2e4, options) {
 ${tail}`;
 }
 var DEFAULT_MAX_STREAM_BUFFER_BYTES = 5 * 1024 * 1024;
-function readNodeStream(stream, maxBytes = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
+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 createSink = options.spillSinkFactory ?? ((path) => createWriteStream(path));
   return new Promise((resolveStream, rejectStream) => {
     const chunks2 = [];
     let totalBytes = 0;
     let settled = false;
+    let truncated = false;
+    let spillState = spillPath ? "idle" : "disabled";
+    let spillError = null;
+    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 finalize2 = (truncated = false) => {
+    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 head3 of headChunks) writeToSink(head3);
+      writeToSink(crossingChunk);
+    };
+    const finalize2 = (wasTruncated) => {
       if (settled) return;
       settled = true;
-      let text2 = Buffer.concat(chunks2).toString("utf8");
-      if (truncated) {
-        text2 += `
+      const truncatedNow = wasTruncated || truncated;
+      const baseText = Buffer.concat(chunks2).toString("utf8");
+      const done4 = () => {
+        let text2 = baseText;
+        if (truncatedNow) {
+          const notes = [`output exceeded ${formatLimit} buffer limit`];
+          if (spillState === "ok") {
+            notes.push(`full output: ${spillPath}`);
+          } else if (spillPath) {
+            notes.push(
+              `spill failed${spillError ? ` (${spillError})` : ""}; output incomplete`
+            );
+          }
+          text2 += `
 
-[stream pipe truncated: output exceeded ${formatLimit} buffer limit]`;
+[stream pipe truncated: ${notes.join("; ")}]`;
+        }
+        resolveStream(text2);
+      };
+      const sink = spillSink;
+      if (!sink || spillState !== "open") {
+        done4();
+        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";
+        }
+        done4();
+      };
+      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);
       }
-      resolveStream(text2);
     };
     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 = chunks2.slice();
         if (remaining > 0) {
           chunks2.push(buf.subarray(0, remaining));
         }
-        try {
-          if (typeof stream.destroy === "function") {
-            stream.destroy();
-          }
-        } catch {
-        }
-        finalize2(true);
+        totalBytes += buf.length;
+        truncated = true;
+        openSpill(headChunks, buf);
         return;
       }
       totalBytes += buf.length;
@@ -15028,6 +15160,19 @@ function readNodeStream(stream, maxBytes = DEFAULT_MAX_STREAM_BUFFER_BYTES) {
     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();
       rejectStream(error);
     });
     stream.on("end", () => finalize2(false));
@@ -15140,8 +15285,12 @@ async function runWorkspaceCommand(args2) {
     process.removeListener("SIGINT", cleanupChildOnHostSignal);
   };
   exitPromise.then(detachSignalCleanup, detachSignalCleanup);
-  const stdoutCapture = stdoutPromiseResult(readNodeStream(proc.stdout));
-  const stderrCapture = stdoutPromiseResult(readNodeStream(proc.stderr));
+  const stdoutCapture = stdoutPromiseResult(
+    readNodeStream(proc.stdout, { spillPath: join4(tmpdir(), `nolo-stream-${randomUUID()}.log`) })
+  );
+  const stderrCapture = stdoutPromiseResult(
+    readNodeStream(proc.stderr, { spillPath: join4(tmpdir(), `nolo-stream-${randomUUID()}-stderr.log`) })
+  );
   const killChild = (signal) => {
     if (detached && typeof proc.pid === "number") {
       try {
@@ -15550,11 +15699,11 @@ async function invokeCapability(capabilityOrName, input, ctx = {}) {
 }
 
 // packages/agent-runtime/localWorkspaceTools.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { createHash as createHash4 } from "node:crypto";
 import { lstat, mkdir, readdir as readdir2, readFile as readFile3, realpath, stat as stat3, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4, sep } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4, sep } from "node:path";
 import { spawn as spawnChildProcess3 } from "node:child_process";
 
 // packages/core/readRangeLedger.ts
@@ -16836,7 +16985,7 @@ function resolveRipgrepBinary(env = process.env) {
   const fromEnv = asOptionalTrimmedString(env.NOLO_BUNDLED_RG);
   if (fromEnv) {
     try {
-      if (existsSync3(fromEnv)) return fromEnv;
+      if (existsSync4(fromEnv)) return fromEnv;
     } catch {
     }
   }
@@ -16942,6 +17091,7 @@ ${tail}`,
   };
 }
 var READ_FILE_LEDGER_MAX_RECORDS = 64;
+var READ_FILE_LEDGER_MAX_KEYS = 256;
 async function readFileTool(args2) {
   const parsed = parseWorkspaceToolArguments(args2.call.arguments);
   const requestedPath = requireWorkspaceToolPath(parsed);
@@ -16980,6 +17130,8 @@ async function readFileTool(args2) {
     const retainedCap = resolveHistoricalToolContentCap("readFile", 0);
     const retained = filterRetainedLedgerRecords(entry.records, retainedCap);
     if (retained.length > 0 && isLineRangeCovered(requestRange, retained)) {
+      ledger.delete(relativePath);
+      ledger.set(relativePath, entry);
       return {
         content: `[readFile] ${relativePath} lines ${requestRange.startLine}-${requestRange.endLine} were already delivered earlier and the file is unchanged; not resending. Pass force:true to refetch.`,
         metadata: {
@@ -17012,10 +17164,16 @@ async function readFileTool(args2) {
     const persistedChars = truncatedRead.content.length + "\n\n[tool metadata]\n".length + JSON.stringify(metadata).length;
     const records = entry?.records ?? [];
     records.push({ ...requestRange, chars: persistedChars });
+    ledger.delete(relativePath);
     ledger.set(relativePath, {
       fingerprint,
       records: records.slice(-READ_FILE_LEDGER_MAX_RECORDS)
     });
+    while (ledger.size > READ_FILE_LEDGER_MAX_KEYS) {
+      const oldestKey = ledger.keys().next().value;
+      if (oldestKey === void 0) break;
+      ledger.delete(oldestKey);
+    }
   }
   return { content: truncatedRead.content, metadata };
 }
@@ -17028,7 +17186,7 @@ async function writeFileTool(args2) {
     requestedPath,
     ...args2.confirmExternalFileAccess ? { confirmExternalFileAccess: args2.confirmExternalFileAccess } : {}
   });
-  await mkdir(dirname(absolutePath), { recursive: true });
+  await mkdir(dirname2(absolutePath), { recursive: true });
   await writeFile(absolutePath, content, "utf8");
   const relativePath = normalizeWorkspaceRelativePath({
     workspaceRoot: resolve4(args2.workspaceRoot),
@@ -17485,7 +17643,7 @@ async function execShellTool(args2) {
   );
 }
 var LAUNCH_PROCESS_STREAM_RING_CHARS = 65536;
-var LAUNCH_PROCESS_STREAM_CAPTURE_MAX_CHARS = 4e6;
+var LAUNCH_PROCESS_STREAM_CAPTURE_MAX_CHARS = 1e6;
 function createLaunchProcessStreamCapture() {
   let ring = "";
   let full = null;
@@ -18709,7 +18867,7 @@ var normalizeContextBlockScopes = (legacyBlocks = void 0, scopes = void 0) => {
 };
 
 // packages/agent-runtime/localAutoCompaction.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 function toPlanCompressionMessages(history) {
   return history.map((message, index) => ({
     id: typeof message.id === "string" && message.id.length > 0 ? message.id : `local-${index}`,
@@ -18944,7 +19102,7 @@ async function maybeAutoCompactLocalHistory(args2) {
     };
   }
   emitPhase({ kind: "compaction-start" });
-  const compactionAttemptId = randomUUID();
+  const compactionAttemptId = randomUUID2();
   let compactionT0 = Date.now();
   let compactionInputTokens;
   let compactionPrevSummaryTokens;
@@ -21787,7 +21945,7 @@ function resolveSessionKey(args2) {
 }
 
 // packages/agent-runtime/devin/devinProvider.ts
-import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import { randomBytes, randomUUID as randomUUID3 } from "node:crypto";
 var CLIENT_NAME = "chisel";
 var CLIENT_VERSION = "3000.11.3";
 function writeVarint(fieldNum, value) {
@@ -21847,7 +22005,7 @@ function encodeDevinClientMetadata(token) {
   ]);
 }
 function devinId(id, purpose) {
-  return id?.sessionKey && isStableSessionIdentityEnabled() ? deriveStableUuid(id.sessionKey, purpose) : randomUUID2();
+  return id?.sessionKey && isStableSessionIdentityEnabled() ? deriveStableUuid(id.sessionKey, purpose) : randomUUID3();
 }
 function encodeDevinChatMessage(msg, identity2, index = 0) {
   const source = msg.role === "assistant" ? 2 : msg.role === "tool" ? 4 : 1;
@@ -21941,7 +22099,7 @@ ${item.text}`;
   const chatMessageBuffers = coalesced.map((m, i) => encodeDevinChatMessage(m, identity2, i));
   const completionConfig = buildCompletionConfig({ temperature });
   const modelConfig = Buffer.concat([
-    writeStringField(1, randomUUID2()),
+    writeStringField(1, randomUUID3()),
     writeVarint(2, 1),
     writeVarint(3, 4)
   ]);
@@ -21953,7 +22111,7 @@ ${item.text}`;
     writeMessageField(8, completionConfig),
     ...tools.map((tool) => writeMessageField(10, encodeDevinToolDefinition(tool))),
     writeMessageField(15, modelConfig),
-    writeStringField(16, randomUUID2()),
+    writeStringField(16, randomUUID3()),
     writeVarint(20, 1),
     writeStringField(21, model)
   ]);

package/{chunk-QV3VGSX6.js → chunk-SNAWGDXT.js}

@@ -324,6 +324,233 @@ import { dirname, isAbsolute as isAbsolute2, join, resolve } from "node:path";
 import * as nodeFs 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/localRuntimeHelpers.ts
 var REMOTE_DIALOG_SYNC_TIMEOUT_MS = 1e4;
 var remoteDialogSyncTimeoutMsForTest;
@@ -1183,6 +1410,29 @@ function buildAgentRunChildCommand(options, deps = {}) {
   }
   return { execPath, childArgs: [entrypoint, ...commandParts, ...strippedArgs] };
 }
+function safeReadHostMemory(reader) {
+  try {
+    return reader();
+  } catch {
+    return null;
+  }
+}
+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;
@@ -1266,6 +1516,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     NOLO_AGENT_RUN_CHILD: "1",
     NOLO_AGENT_RUN_ID: runId
   };
+  const hostMemory = safeReadHostMemory(deps.readHostMemory ?? readHostMemory);
   const logFd = fs.openSync(logPath, "a");
   const proc = spawn(execPath, childArgs, {
     cwd: input.cwd,
@@ -1283,6 +1534,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     proc.channel?.unref?.();
   }
   proc.unref();
+  const hostMemoryNotice = emitHostMemoryNotice(hostMemory, input.output);
   if (typeof proc.pid === "number") {
     const processStartedAt = (deps.getProcessStartTime ?? defaultGetProcessStartTime)(proc.pid);
     withRunRecordLock(runId, deps, () => {
@@ -1292,7 +1544,14 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
       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, () => {

package/{chunk-SCQT4CRF.js → chunk-UY73HNIN.js}

@@ -170,7 +170,7 @@ import {
   runExecShellGates,
   validateConfiguredRootExecutionLease,
   verifyOwnerRouteAck
-} from "./chunk-B5JIGIKM.js";
+} from "./chunk-K25WQPP3.js";
 import {
   accumulateGeminiChunks,
   buildGeminiGenerateContentRequest,
@@ -298,7 +298,7 @@ import {
   terminateRunProcess,
   transitionRunToTerminal,
   withQueueLock
-} from "./chunk-QV3VGSX6.js";
+} from "./chunk-SNAWGDXT.js";
 import {
   TASK_PREVIEW_MAX,
   formatListRunsCard,
@@ -10766,7 +10766,7 @@ function createCliLocalRuntimeAdapter(deps) {
   const recordRunExecutionIsolation = async () => {
     try {
       const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4 } = await import("node:fs");
-      const { resolveRunsDir } = await import("./agentRunControl-USFIAK7X.js");
+      const { resolveRunsDir } = await import("./agentRunControl-XBSNHHZE.js");
       const fact = resolveLocalRunExecutionIsolationFact({
         // F1：显式点名宿主执行的 run 在审计里必须与 docker 沙盒区分开
         // （reason: host-explicit-writes vs docker-workload）。
@@ -10798,7 +10798,7 @@ function createCliLocalRuntimeAdapter(deps) {
     dockerWorkloadReleased = true;
     dockerWorkloadLoad = null;
     if (loaded) {
-      const { resolveRunsDir } = await import("./agentRunControl-USFIAK7X.js");
+      const { resolveRunsDir } = await import("./agentRunControl-XBSNHHZE.js");
       const exportRunDiff = deps.exportDockerRunDiffArtifact ?? exportDockerRunDiffArtifact;
       const warn = (message) => process.stderr.write(`[nolo] ${message}
 `);