omnius 1.0.152 → 1.0.153

package/dist/index.js

@@ -529083,14 +529083,16 @@ async function scanOllamaProcesses(options2 = {}) {
   ]);
   const snapshots = [];
   for (const row of psRows) {
-    if (!isOllamaServeCommand(row.command))
+    const serve = isOllamaServeCommand(row.command);
+    const runner = !serve && isOllamaRunnerCommand(row.command);
+    if (!serve && !runner)
       continue;
-    const env2 = await readProcEnv(system, row.pid);
+    const env2 = serve ? await readProcEnv(system, row.pid) : { readable: false, values: {} };
     const ports = uniqueNumbers([
       ...portMap.get(row.pid) ?? [],
-      ...portsFromEnv(env2.values)
+      ...serve ? portsFromEnv(env2.values) : []
     ]);
-    const ollamaApiPorts = await probeOllamaPorts(system, ports);
+    const ollamaApiPorts = serve ? await probeOllamaPorts(system, ports) : [];
     snapshots.push({
       pid: row.pid,
       ppid: row.ppid,
@@ -529103,7 +529105,9 @@ async function scanOllamaProcesses(options2 = {}) {
       envReadable: env2.readable,
       env: env2.values,
       gpuMemoryMb: gpuMemoryByPid.get(row.pid) ?? null,
-      isOllamaServe: true
+      isOllamaServe: serve,
+      isOllamaRunner: runner,
+      runnerModelBlob: runner ? parseRunnerModelBlob(row.command) : null
     });
   }
   const decisions = classifyOllamaProcesses(snapshots, {
@@ -529223,6 +529227,20 @@ function classifyOllamaProcesses(processes, options2 = {}) {
     const hasPortEvidence = proc.ports.length > 0 && proc.ollamaApiPorts.length > 0;
     const lowCpu = proc.cpuPct === null || proc.cpuPct <= cpuThresholdPct;
     const oldEnough = proc.elapsedMs === null || proc.elapsedMs >= minAgeMs;
+    if (proc.isOllamaRunner) {
+      const liveServePids = new Set(processes.filter((p2) => p2.isOllamaServe).map((p2) => p2.pid));
+      const parentIsLiveServe = proc.ppid !== null && liveServePids.has(proc.ppid);
+      if (parentIsLiveServe) {
+        return decision(proc, "keep", "active-pool-owned", true, false, "deterministic", [`runner managed by live ollama serve pid=${proc.ppid}`]);
+      }
+      reasons.push(`orphan ollama runner (ppid=${proc.ppid ?? "?"} is not a live ollama serve)`);
+      if (proc.runnerModelBlob)
+        reasons.push(`holds model blob ${basename18(proc.runnerModelBlob)}`);
+      if (proc.gpuMemoryMb !== null && proc.gpuMemoryMb > 0) {
+        reasons.push(`holding ${proc.gpuMemoryMb} MB GPU memory`);
+      }
+      return decision(proc, "terminate", "orphan-runner", false, true, "deterministic", reasons);
+    }
     if (!proc.isOllamaServe) {
       return decision(proc, "keep", "unknown-ollama", false, false, "deterministic", ["not an ollama serve process"]);
     }
@@ -529577,6 +529595,14 @@ function isOllamaServeCommand(command) {
   const [exe, subcommand] = command.trim().split(/\s+/);
   return basename18(exe ?? "") === "ollama" && subcommand === "serve";
 }
+function isOllamaRunnerCommand(command) {
+  const [exe, subcommand] = command.trim().split(/\s+/);
+  return basename18(exe ?? "") === "ollama" && subcommand === "runner";
+}
+function parseRunnerModelBlob(command) {
+  const m2 = command.match(/--model\s+(\S+)/);
+  return m2?.[1] ?? null;
+}
 function portsFromEnv(env2) {
   const host = env2["OLLAMA_HOST"];
   if (!host)
@@ -530144,15 +530170,31 @@ var init_ollama_pool = __esm({
       const child = spawn23(config.ollamaBinary, ["serve"], {
         env: env2,
         stdio: ["ignore", "pipe", "pipe"],
-        detached: false
+        detached: true
       });
+      child.unref();
       const proc = {
         pid: child.pid ?? -1,
         kill: () => {
-          try {
-            child.kill("SIGTERM");
-          } catch {
-          }
+          const pid = child.pid;
+          if (!pid || pid <= 0)
+            return;
+          const tryKill = (target, sig) => {
+            try {
+              process.kill(target, sig);
+              return true;
+            } catch {
+              return false;
+            }
+          };
+          const groupKilled = tryKill(-pid, "SIGTERM");
+          if (!groupKilled)
+            tryKill(pid, "SIGTERM");
+          setTimeout(() => {
+            if (tryKill(-pid, "SIGKILL"))
+              return;
+            tryKill(pid, "SIGKILL");
+          }, 8e3).unref();
         }
       };
       child.stdout?.on("data", () => {
@@ -530242,6 +530284,65 @@ var init_ollama_pool = __esm({
         }, null));
         this.startReaper();
         this.scheduleStartupCleanupScan();
+        this.installProcessExitHooks();
+      }
+      /**
+       * Process-exit hooks that kill every spawned `ollama serve` subprocess
+       * group on Omnius shutdown. Catches all the ways the previous orphan
+       * runners were created:
+       *
+       *   - SIGTERM / SIGINT (systemd stop, Ctrl-C, kill PID)
+       *   - process.exit() from a fatal error path
+       *   - 'beforeExit' (graceful natural shutdown)
+       *
+       * The 'exit' listener is intentionally synchronous-only because Node has
+       * already started tearing down by then — it just fires `process.kill` on
+       * the recorded PGIDs and returns. Async work is impossible at that stage.
+       *
+       * Signal handlers also forward the signal after teardown so any other
+       * shutdown plumbing (web framework graceful close, etc.) still observes
+       * the original signal — we don't swallow it.
+       *
+       * Idempotent across multiple pool instances in the same process: every
+       * pool only kills its OWN pids.
+       */
+      installProcessExitHooks() {
+        if (process.env["NODE_ENV"] === "test" || process.env["VITEST"])
+          return;
+        if (process.env["OMNIUS_OLLAMA_PROCESS_EXIT_HOOK"] === "0")
+          return;
+        const killAllPoolOwnedSync = (sig) => {
+          for (const inst of this.instances) {
+            if (!inst.state.poolOwned)
+              continue;
+            const pid = inst.state.pid;
+            if (!pid || pid <= 0)
+              continue;
+            try {
+              process.kill(-pid, sig);
+            } catch {
+              try {
+                process.kill(pid, sig);
+              } catch {
+              }
+            }
+          }
+        };
+        const onSignal = (sig) => {
+          killAllPoolOwnedSync(sig);
+          process.removeListener("SIGTERM", onSigterm);
+          process.removeListener("SIGINT", onSigint);
+          try {
+            process.kill(process.pid, sig);
+          } catch {
+          }
+        };
+        const onSigterm = () => onSignal("SIGTERM");
+        const onSigint = () => onSignal("SIGINT");
+        process.on("SIGTERM", onSigterm);
+        process.on("SIGINT", onSigint);
+        process.on("exit", () => killAllPoolOwnedSync("SIGTERM"));
+        process.on("beforeExit", () => killAllPoolOwnedSync("SIGTERM"));
       }
       /**
        * Resolve the effective agent id for an acquire request. Explicit option
@@ -530834,7 +530935,7 @@ var init_ollama_pool = __esm({
           return;
         const handle2 = setTimeout(async () => {
           try {
-            const cleanupOnStart = process.env["OMNIUS_OLLAMA_CLEANUP_ON_START"] === "1";
+            const cleanupOnStart = process.env["OMNIUS_OLLAMA_CLEANUP_ON_START"] !== "0";
             const { cleanupStaleOllamaProcesses: cleanupStaleOllamaProcesses2 } = await Promise.resolve().then(() => (init_ollama_pool_cleanup(), ollama_pool_cleanup_exports));
             const report2 = await cleanupStaleOllamaProcesses2({
               dryRun: !cleanupOnStart,
@@ -530847,6 +530948,9 @@ var init_ollama_pool = __esm({
             if (stale.length > 0) {
               this.emit(cleanupOnStart ? "stale-process-cleanup" : "stale-processes-found", {
                 staleCount: stale.length,
+                // Surface orphan-runner counts separately so observability can
+                // alert on the VRAM-hostage failure mode specifically.
+                orphanRunnerCount: report2.decisions.filter((d2) => d2.classification === "orphan-runner" && d2.action === "terminate").length,
                 dryRun: report2.dryRun,
                 terminated: report2.terminated,
                 skipped: report2.skipped,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.152",
+  "version": "1.0.153",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.152",
+      "version": "1.0.153",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.152",
+  "version": "1.0.153",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",