negotium 0.6.7 → 0.6.9

package/dist/registry.js

@@ -133,7 +133,7 @@ var codexRegistryOperations = {
     return { sessionId: threadId, rolloutPath };
   },
   async forkSession({ parentSessionId }) {
-    const { forkCodexSession } = await import("./chunk-f124y9d0.js");
+    const { forkCodexSession } = await import("./chunk-bhxdah5c.js");
     return await forkCodexSession(parentSessionId);
   },
   async cleanupRollouts({ sessionIds }) {

package/dist/runtime/src/mcp/factories/system-health.ts

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { cpus, freemem, loadavg, totalmem } from "node:os";
+import { cpus, loadavg } from "node:os";
 import { promisify } from "node:util";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { errMsg } from "#platform/error";
@@ -7,12 +7,34 @@ import { mcpOk } from "../mcp-helpers";
 
 const execFileAsync = promisify(execFile);
 
+export interface SystemHealthMemory {
+  /** 앱 실사용 (btop 방식, 회수 불가) = active + wired */
+  usedBytes: number;
+  /** 파일 캐시/버퍼 등 압박 시 즉시 반환 가능 = inactive + speculative + purgeable */
+  cacheBytes: number;
+  /** 압축된 익명 메모리 (스왑 압박 시 지표) */
+  compressorBytes: number;
+  /** available = total - used(active+wired) */
+  availableBytes: number;
+  totalBytes: number;
+  /** active만 (breakdown 표시용) */
+  activeBytes: number;
+  /** wired만 (breakdown 표시용) */
+  wiredBytes: number;
+}
+
+export interface SystemHealthMemoryPressure {
+  /** normal / warning / critical / unknown */
+  level: string;
+  /** macOS 공식 "System-wide memory free percentage" (0~100), 없으면 null */
+  freePct: number | null;
+}
+
 export interface SystemHealthSnapshot {
   cpuLoad: [number, number, number];
   cpuCount: number;
-  memoryTotal: number;
-  memoryFree: number;
-  memoryPressure: string;
+  memory: SystemHealthMemory;
+  memoryPressure: SystemHealthMemoryPressure;
   swap: string;
   disk: string;
   thermal: string;
@@ -33,13 +55,82 @@ async function shell(command: string, args: string[]): Promise<string> {
   return stdout.trim();
 }
 
-async function getMemoryPressure(): Promise<string> {
+async function getMemoryPressure(): Promise<SystemHealthMemoryPressure> {
+  // level: 스와핑 압박 레벨 (macOS가 실제 판정하는 공식 지표)
+  let level = "unknown";
+  try {
+    const l = await shell("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"]);
+    level = l === "4" ? "critical" : l === "2" ? "warning" : "normal";
+  } catch {
+    /* keep unknown */
+  }
+
+  // freePct: `memory_pressure` 명령의 "System-wide memory free percentage"
+  let freePct: number | null = null;
   try {
-    const level = await shell("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"]);
-    return level === "4" ? "critical" : level === "2" ? "warning" : "normal";
+    const out = await shell("memory_pressure", []);
+    const m = out.match(/System-wide memory free percentage:\s*(\d+)%/);
+    if (m) freePct = Number(m[1]);
   } catch {
-    return "unknown";
+    /* keep null */
   }
+
+  return { level, freePct };
+}
+
+async function getTotalMemBytes(): Promise<number> {
+  try {
+    return Number(await shell("sysctl", ["-n", "hw.memsize"]));
+  } catch {
+    return 0;
+  }
+}
+
+async function getVmStatMemory(): Promise<SystemHealthMemory> {
+  const [out, totalFromSysctl] = await Promise.all([shell("vm_stat", []), getTotalMemBytes()]);
+  const extract = (label: string): number => {
+    const m = out.match(new RegExp(`${label.replace(/\s/g, "\\s")}:\\s+(\\d+)`));
+    return m ? Number(m[1]) : 0;
+  };
+
+  // page size를 헤더에서 동적 추출 (Apple Silicon 16384 / Intel 4096)
+  const pageSize = Number(out.match(/page size of (\d+) bytes/)?.[1]) || 16384;
+  const pagesFree = extract("Pages free");
+  const pagesActive = extract("Pages active");
+  const pagesInactive = extract("Pages inactive");
+  const pagesSpeculative = extract("Pages speculative");
+  const pagesWired = extract("Pages wired down");
+  const pagesPurgeable = extract("Pages purgeable");
+  const pagesCompressor = extract("Pages occupied by compressor");
+
+  // btop 공식: used = (active + wired). inactive/compressor/purgeable 제외.
+  const activeBytes = pagesActive * pageSize;
+  const wiredBytes = pagesWired * pageSize;
+  const usedBytes = activeBytes + wiredBytes;
+  const cacheBytes = (pagesInactive + pagesSpeculative + pagesPurgeable) * pageSize;
+  const compressorBytes = pagesCompressor * pageSize;
+  // total은 hw.memsize 우선 (page 합산은 부정확). 실패 시 page 합산 폴백.
+  const totalBytes =
+    totalFromSysctl ||
+    (pagesFree +
+      pagesActive +
+      pagesInactive +
+      pagesSpeculative +
+      pagesWired +
+      pagesPurgeable +
+      pagesCompressor) *
+      pageSize;
+  const availableBytes = Math.max(0, totalBytes - usedBytes);
+
+  return {
+    usedBytes,
+    cacheBytes,
+    compressorBytes,
+    availableBytes,
+    totalBytes,
+    activeBytes,
+    wiredBytes,
+  };
 }
 
 async function getSwapUsage(): Promise<string> {
@@ -95,19 +186,19 @@ async function getDisk(): Promise<string> {
 
 export const defaultSystemHealthMcpHost: SystemHealthMcpHost = {
   async readSystemHealth() {
-    const [memoryPressure, swap, thermal, disk, processCount] = await Promise.all([
+    const [memoryPressure, swap, thermal, disk, processCount, memory] = await Promise.all([
       getMemoryPressure(),
       getSwapUsage(),
       getThermal(),
       getDisk(),
       getProcessCount(),
+      getVmStatMemory(),
     ]);
     const load = loadavg();
     return {
       cpuLoad: [load[0] ?? 0, load[1] ?? 0, load[2] ?? 0],
       cpuCount: cpus().length,
-      memoryTotal: totalmem(),
-      memoryFree: freemem(),
+      memory,
       memoryPressure,
       swap,
       disk,
@@ -126,25 +217,36 @@ export function createSystemHealthMcpServer(
     [
       "시스템 상태를 조회합니다.",
       "- CPU 부하 (load average 1/5/15분)",
-      "- 메모리 사용량 + 압력 (normal/warning/critical)",
+      "- 메모리: 앱 실사용(active+wired) / 파일캐시(반환가능) / available / 압력(free%·level)",
       "- 스왑 사용량",
       "- 디스크 사용률 (/)",
       "- 열 상태 (thermal)",
       "- 프로세스 수",
+      "",
+      "⚠️ Chromium/playwright 등 무거운 프로세스 실행 가능 여부는 '메모리 사용%'가 아니라",
+      "   메모리 압력 레벨(normal/warning/critical) + available GB 로 판단할 것.",
+      "   (파일 캐시는 압박 시 즉시 반환되므로 used%에 겁먹지 말 것)",
     ].join("\n"),
     {},
     async () => {
       const snapshot = await host.readSystemHealth();
-      const used = snapshot.memoryTotal - snapshot.memoryFree;
-      const memoryPercent = ((used / snapshot.memoryTotal) * 100).toFixed(1);
+      const { memory } = snapshot;
+      const usedPct =
+        memory.totalBytes > 0 ? ((memory.usedBytes / memory.totalBytes) * 100).toFixed(1) : "0.0";
       const [load1, load5, load15] = snapshot.cpuLoad;
+      const pressureStr =
+        snapshot.memoryPressure.freePct !== null
+          ? `${snapshot.memoryPressure.level} (free ${snapshot.memoryPressure.freePct}%)`
+          : snapshot.memoryPressure.level;
       return mcpOk(
         [
           "시스템 상태",
           "",
           `CPU 부하:      ${load1.toFixed(2)} / ${load5.toFixed(2)} / ${load15.toFixed(2)}  (1/5/15분, 코어 ${snapshot.cpuCount}개)`,
-          `메모리:        ${fmtBytes(used)} / ${fmtBytes(snapshot.memoryTotal)} (${memoryPercent}%)  여유: ${fmtBytes(snapshot.memoryFree)}`,
-          `메모리 압력:   ${snapshot.memoryPressure}`,
+          `메모리 실사용: ${fmtBytes(memory.usedBytes)} / ${fmtBytes(memory.totalBytes)} (${usedPct}%)  available: ${fmtBytes(memory.availableBytes)}`,
+          `  (active ${fmtBytes(memory.activeBytes)} + wired ${fmtBytes(memory.wiredBytes)})`,
+          `파일 캐시:     ${fmtBytes(memory.cacheBytes)} (압박 시 반환 가능)  |  압축 ${fmtBytes(memory.compressorBytes)}`,
+          `메모리 압력:   ${pressureStr}`,
           `스왑:          ${snapshot.swap}`,
           `디스크(/):     ${snapshot.disk}`,
           `열 상태:       ${snapshot.thermal}`,

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.6.7";
+export const NEGOTIUM_VERSION = "0.6.9";

package/dist/types/packages/core/src/mcp/factories/system-health.d.ts

@@ -1,10 +1,30 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface SystemHealthMemory {
+    /** 앱 실사용 (btop 방식, 회수 불가) = active + wired */
+    usedBytes: number;
+    /** 파일 캐시/버퍼 등 압박 시 즉시 반환 가능 = inactive + speculative + purgeable */
+    cacheBytes: number;
+    /** 압축된 익명 메모리 (스왑 압박 시 지표) */
+    compressorBytes: number;
+    /** available = total - used(active+wired) */
+    availableBytes: number;
+    totalBytes: number;
+    /** active만 (breakdown 표시용) */
+    activeBytes: number;
+    /** wired만 (breakdown 표시용) */
+    wiredBytes: number;
+}
+export interface SystemHealthMemoryPressure {
+    /** normal / warning / critical / unknown */
+    level: string;
+    /** macOS 공식 "System-wide memory free percentage" (0~100), 없으면 null */
+    freePct: number | null;
+}
 export interface SystemHealthSnapshot {
     cpuLoad: [number, number, number];
     cpuCount: number;
-    memoryTotal: number;
-    memoryFree: number;
-    memoryPressure: string;
+    memory: SystemHealthMemory;
+    memoryPressure: SystemHealthMemoryPressure;
     swap: string;
     disk: string;
     thermal: string;

package/dist/types/packages/core/src/version.d.ts

@@ -1 +1 @@
-export declare const NEGOTIUM_VERSION = "0.6.7";
+export declare const NEGOTIUM_VERSION = "0.6.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "negotium",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "type": "module",
   "description": "Install the Negotium multi-agent runtime and CLI with one package",
   "license": "Apache-2.0",