omnius 1.0.152 → 1.0.154

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, {
@@ -529181,11 +529185,11 @@ async function cleanupStaleOllamaProcesses(options2 = {}) {
       continue;
     }
     try {
-      system.kill(proc.pid, "SIGTERM");
+      signalOllamaProcess(system, proc, "SIGTERM");
       await system.sleep(options2.graceMs ?? DEFAULT_GRACE_MS);
       let signal = "SIGTERM";
       if (system.isPidAlive(proc.pid)) {
-        system.kill(proc.pid, "SIGKILL");
+        signalOllamaProcess(system, proc, "SIGKILL");
         signal = "SIGKILL";
         await system.sleep(250);
       }
@@ -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"]);
     }
@@ -529264,6 +529282,23 @@ function decision(proc, action, classification, protectedProc, eligible, source,
     reasons
   };
 }
+function signalOllamaProcess(system, proc, signal) {
+  let delivered = false;
+  if (proc.isOllamaServe) {
+    try {
+      system.kill(-proc.pid, signal);
+      delivered = true;
+    } catch {
+    }
+  }
+  try {
+    system.kill(proc.pid, signal);
+    delivered = true;
+  } catch (err) {
+    if (!delivered)
+      throw err;
+  }
+}
 async function maybeApplyInference(scan, options2, system) {
   const mode = options2.useInference ?? "auto";
   if (mode === false || process.env["OMNIUS_OLLAMA_CLEANUP_INFERENCE"] === "0") {
@@ -529577,6 +529612,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 +530187,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 +530301,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 +530952,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 +530965,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,
@@ -582430,6 +582551,15 @@ ${CONTENT_BG_SEQ}`);
               return;
             }
             if (key?.name === "return" || key?.name === "enter") {
+              if (key?.shift) {
+                const currentLine2 = rl.line ?? "";
+                const cursor = typeof rl.cursor === "number" ? rl.cursor : currentLine2.length;
+                rl.line = currentLine2.slice(0, cursor) + "\n" + currentLine2.slice(cursor);
+                rl.cursor = cursor + 1;
+                self2.updateFooterHeight();
+                self2.renderFooterAndPositionInput();
+                return;
+              }
               const currentLine = rl.line ?? "";
               rl.line = "";
               rl.cursor = 0;
@@ -633985,6 +634115,12 @@ var init_direct_input = __esm({
               }
               break;
             }
+            if (remaining.length >= 2 && (remaining[1] === "\r" || remaining[1] === "\n")) {
+              this._insertText("\n");
+              i2 += 2;
+              if (remaining[1] === "\r" && remaining[2] === "\n") i2++;
+              continue;
+            }
             if (remaining.length === 1) {
               break;
             }
@@ -633992,6 +634128,21 @@ var init_direct_input = __esm({
             continue;
           }
           if (code8 < 32 || code8 === 127) {
+            if (code8 === 13) {
+              if (this._preSubmit?.()) {
+                i2++;
+                continue;
+              }
+              this._submit();
+              i2++;
+              if (this._buffer[i2] === "\n") i2++;
+              continue;
+            }
+            if (code8 === 10) {
+              this._insertText("\n");
+              i2++;
+              continue;
+            }
             this._handleControl(code8);
             i2++;
             continue;
@@ -634194,12 +634345,6 @@ var init_direct_input = __esm({
       /** Handle control characters (ASCII < 32 and DEL) */
       _handleControl(code8) {
         switch (code8) {
-          case 13:
-          // Enter (CR)
-          case 10:
-            if (this._preSubmit?.()) return;
-            this._submit();
-            return;
           case 127:
           // Backspace (DEL)
           case 8:

package/npm-shrinkwrap.json

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

package/package.json

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