omnius 1.0.728 → 1.0.730

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 38123753 bytes
-sha256: e049258d999f7d4d056e6d5c2f2adade3356a8c217233909bd1b60ca6f35be27
+size: 38141493 bytes
+sha256: 129ae1a628f2ee04d633a2a2829eb8b968652fd68b8d93fadf28e3fc72eb1284

package/dist/update-worker.js

@@ -296100,21 +296100,32 @@ async function repairManagedDaemonUnit(port, preferredEntrypoint) {
     return false;
   }
 }
-async function portHolderPids(port) {
+function daemonListenerLsofArgs(port) {
+  return ["-nP", "-t", "-a", `-iTCP:${port}`, "-sTCP:LISTEN"];
+}
+function parsePidList(output) {
+  return output.split(/[\s\n]+/).map((value) => parseInt(value, 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+function parseSsListenerPids(output) {
+  return [...output.matchAll(/\bpid=(\d+)\b/g)].map((match2) => parseInt(match2[1], 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+async function daemonListenerPids(port, dependencies = { run: runUtilityCommand }) {
   try {
-    const lsof = await runUtilityCommand("lsof", ["-ti", `:${port}`], 3e3);
-    let output = lsof.stdout;
-    if (!output.trim()) {
-      const fuser = await runUtilityCommand("fuser", [`${port}/tcp`], 3e3);
-      output = `${fuser.stdout}
-${fuser.stderr}`;
-      if (!lsof.available && !fuser.available) return null;
+    const lsof = await dependencies.run("lsof", daemonListenerLsofArgs(port), 3e3);
+    if (lsof.available && (lsof.code === 0 || lsof.code === 1)) {
+      return [...new Set(parsePidList(lsof.stdout))];
     }
-    return output.split(/[\s\n]+/).map((value) => parseInt(value, 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+    const ss = await dependencies.run("ss", ["-H", "-ltnp", `sport = :${port}`], 3e3);
+    if (!ss.available || ss.code !== 0) return null;
+    const pids = [...new Set(parseSsListenerPids(ss.stdout))];
+    return ss.stdout.trim() && pids.length === 0 ? null : pids;
   } catch {
     return null;
   }
 }
+async function portHolderPids(port) {
+  return daemonListenerPids(port);
+}
 async function daemonPortIsFree(port) {
   return new Promise((resolve10) => {
     const probe = createNetServer();
@@ -296135,8 +296146,7 @@ async function daemonPortIsFree(port) {
 async function waitForDaemonStopped(port, attempts = DAEMON_GRACEFUL_STOP_ATTEMPTS) {
   for (let attempt = 0; attempt < attempts; attempt++) {
     const healthy = await isDaemonRunning(port);
-    const holders = await portHolderPids(port);
-    const portFree = holders === null ? await daemonPortIsFree(port) : holders.length === 0;
+    const portFree = await daemonPortIsFree(port);
     if (!healthy && portFree) return true;
     await delay(500);
   }
@@ -296152,42 +296162,44 @@ var DEFAULT_RECLAIM_DEPENDENCIES = {
   }),
   waitForFree: (port) => waitForDaemonStopped(port)
 };
-async function reclaimStaleDaemonEndpointClaim(port) {
+function removeDaemonLockIfUnchanged(port, expected) {
   const lockFile = daemonLockFile(port);
-  const record = readDaemonLock(lockFile);
-  if (!record) return true;
-  if (!await daemonPortIsFree(port)) return true;
-  if (!processIsAlive(record.pid)) {
-    const current2 = readDaemonLock(lockFile);
-    if (current2?.pid === record.pid && current2.token === record.token) {
-      try {
-        unlinkSync2(lockFile);
-      } catch {
-      }
-    }
+  const current = readDaemonLock(lockFile);
+  if (!current) return true;
+  if (current.pid !== expected.pid || current.token !== expected.token) return false;
+  try {
+    unlinkSync2(lockFile);
     return true;
+  } catch (error) {
+    return error.code === "ENOENT";
   }
-  const lease = listProcessLeases({ includeInactive: false }).find(
+}
+var DEFAULT_CLAIM_RECLAIM_DEPENDENCIES = {
+  readLock: (port) => readDaemonLock(daemonLockFile(port)),
+  portIsFree: (port) => daemonPortIsFree(port),
+  processIsAlive: (pid) => processIsAlive(pid),
+  leases: () => listProcessLeases({ includeInactive: false }),
+  stopLease: (leaseId, port) => stopProcessLease(leaseId, {
+    reason: `stale daemon endpoint claim on port ${port}`,
+    termGraceMs: 1e3
+  }),
+  removeLockIfUnchanged: (port, expected) => removeDaemonLockIfUnchanged(port, expected)
+};
+async function reclaimStaleDaemonEndpointClaim(port, verifiedStoppedPids = /* @__PURE__ */ new Set(), dependencies = DEFAULT_CLAIM_RECLAIM_DEPENDENCIES) {
+  const record = dependencies.readLock(port);
+  if (!record) return dependencies.portIsFree(port);
+  if (!await dependencies.portIsFree(port)) return false;
+  const clearExactClaim = async () => dependencies.removeLockIfUnchanged(port, record) && dependencies.portIsFree(port);
+  if (verifiedStoppedPids.has(record.pid) || !dependencies.processIsAlive(record.pid)) {
+    return clearExactClaim();
+  }
+  const lease = dependencies.leases().find(
     (item) => item.status === "active" && item.pid === record.pid && item.ownerKind === "daemon" && item.ownerId === `daemon:${port}`
   );
   if (!lease) return false;
-  const stopped = await stopProcessLease(lease.leaseId, {
-    reason: `stale daemon endpoint claim on port ${port}`,
-    termGraceMs: 1e3
-  });
+  const stopped = await dependencies.stopLease(lease.leaseId, port);
   if (stopped.action !== "killed" && stopped.action !== "dead") return false;
-  for (let attempt = 0; attempt < 20 && processIsAlive(record.pid); attempt++) {
-    await delay(100);
-  }
-  if (processIsAlive(record.pid)) return false;
-  const current = readDaemonLock(lockFile);
-  if (current?.pid === record.pid && current.token === record.token) {
-    try {
-      unlinkSync2(lockFile);
-    } catch {
-    }
-  }
-  return daemonPortIsFree(port);
+  return clearExactClaim();
 }
 async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies = DEFAULT_RECLAIM_DEPENDENCIES) {
   const holders = await dependencies.holderPids(port);
@@ -296269,9 +296281,9 @@ async function restartDaemon(port, expectedVersion, preferredEntrypoint) {
   const managed = await managedDaemonServiceMatchesPort(p);
   if (managed) {
     if (!await managedDaemonServiceOwnsPort(p)) {
-      const reclaimed = await reclaimOwnedDaemonListener(p);
-      if (!reclaimed.ok) return false;
-      await reclaimStaleDaemonEndpointClaim(p);
+      const reclaimed2 = await reclaimOwnedDaemonListener(p);
+      if (!reclaimed2.ok) return false;
+      await reclaimStaleDaemonEndpointClaim(p, new Set(reclaimed2.clearedPids));
     }
     await runUserSystemctl(["reset-failed", "omnius-daemon.service"]);
     const restarted = await runUserSystemctl(["restart", "omnius-daemon.service"]);
@@ -296286,15 +296298,13 @@ async function restartDaemon(port, expectedVersion, preferredEntrypoint) {
     }
     await runUserSystemctl(["stop", "omnius-daemon.service"]);
     if (!await waitForDaemonStopped(p)) {
-      const reclaimed = await reclaimOwnedDaemonListener(p);
-      if (!reclaimed.ok) return false;
+      const reclaimed2 = await reclaimOwnedDaemonListener(p);
+      if (!reclaimed2.ok) return false;
     }
   }
-  if (await isDaemonRunning(p)) {
-    const reclaimed = await reclaimOwnedDaemonListener(p);
-    if (!reclaimed.ok) return false;
-  }
-  if (!await reclaimStaleDaemonEndpointClaim(p)) return false;
+  const reclaimed = await reclaimOwnedDaemonListener(p);
+  if (!reclaimed.ok) return false;
+  if (!await reclaimStaleDaemonEndpointClaim(p, new Set(reclaimed.clearedPids))) return false;
   const pid = await startDaemon(p, preferredEntrypoint);
   if (!pid) return false;
   return (await waitForDaemonReady(p, expectedVersion)).ok;
@@ -296404,25 +296414,27 @@ async function startDaemon(port = getDaemonPort(), preferredEntrypoint) {
     }
   }
 }
-async function stopDaemonAtPort(port = getDaemonPort()) {
-  if (await managedDaemonServiceMatchesPort(port)) {
-    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (stopped.ok && await waitForDaemonStopped(port)) return true;
+var DEFAULT_DAEMON_STOP_DEPENDENCIES = {
+  managedServiceMatchesPort: (port) => managedDaemonServiceMatchesPort(port),
+  stopManagedService: async () => (await runUserSystemctl(["stop", "omnius-daemon.service"])).ok,
+  waitForStopped: (port) => waitForDaemonStopped(port),
+  reclaimListener: (port) => reclaimOwnedDaemonListener(port),
+  reclaimClaim: (port, verifiedStoppedPids) => reclaimStaleDaemonEndpointClaim(port, verifiedStoppedPids)
+};
+async function stopDaemonAtPort(port = getDaemonPort(), dependencies = DEFAULT_DAEMON_STOP_DEPENDENCIES) {
+  if (await dependencies.managedServiceMatchesPort(port)) {
+    const stopped = await dependencies.stopManagedService();
+    if (stopped && await dependencies.waitForStopped(port)) return true;
   }
-  const wasRunning = await isDaemonRunning(port);
-  const reclaimed = await reclaimOwnedDaemonListener(port);
+  const reclaimed = await dependencies.reclaimListener(port);
   if (!reclaimed.ok) return false;
-  const claimCleared = await reclaimStaleDaemonEndpointClaim(port);
-  return claimCleared && (wasRunning || reclaimed.action === "cleared");
+  const claimCleared = await dependencies.reclaimClaim(
+    port,
+    new Set(reclaimed.clearedPids)
+  );
+  return claimCleared && dependencies.waitForStopped(port);
 }
 async function quiesceDaemonForUpdate(port = getDaemonPort()) {
-  if (await managedDaemonServiceMatchesPort(port)) {
-    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (stopped.ok && await waitForDaemonStopped(port)) return true;
-  }
-  if (!await isDaemonRunning(port)) {
-    return daemonPortIsFree(port);
-  }
   return stopDaemonAtPort(port);
 }
 
@@ -296662,6 +296674,19 @@ function transition(current, patch, paths) {
 function permissionRemediation(evidence) {
   return /EACCES|EPERM|permission denied/i.test(evidence) ? "The discovered npm global prefix is not writable. Configure a user-owned npm prefix or rerun the explicit update from a privileged terminal; Omnius never silently elevates." : void 0;
 }
+async function quiesceDaemonWithRetry(quiesce, attempts = 3, pauseMs = 250) {
+  const boundedAttempts = Math.max(1, Math.min(5, Math.floor(attempts)));
+  for (let attempt = 1; attempt <= boundedAttempts; attempt++) {
+    try {
+      if (await quiesce()) return true;
+    } catch {
+    }
+    if (attempt < boundedAttempts && pauseMs > 0) {
+      await new Promise((resolve10) => setTimeout(resolve10, pauseMs));
+    }
+  }
+  return false;
+}
 function installGlobalPackageStreaming(input) {
   return new Promise((resolve10) => {
     const stderrTail = [];
@@ -296740,7 +296765,7 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
   try {
     if (dependencies.quiesceDaemon) {
       state = transition(state, { phase: "daemon_quiescing" }, paths);
-      if (!await dependencies.quiesceDaemon()) {
+      if (!await quiesceDaemonWithRetry(dependencies.quiesceDaemon)) {
         throw new Error(
           `Could not safely stop the daemon at ${state.daemon_endpoint ?? "the configured endpoint"} before updating`
         );

package/docs/DISCOVERY.json

@@ -5680,7 +5680,7 @@
       "id": "api.v1-chat",
       "kind": "api",
       "title": "/v1/chat",
-      "summary": "Stateful chat session with full agent tool access (OpenAI-compatible response shape)",
+      "summary": "Stateful direct chat with explicit autonomous-agent opt-in",
       "aliases": [
         "/v1/chat"
       ],
@@ -5729,8 +5729,8 @@
       ],
       "operations": {
         "post": {
-          "summary": "Stateful chat session with full agent tool access (OpenAI-compatible response shape)",
-          "description": "Drop-in replacement for OpenAI /v1/chat/completions and Ollama /api/chat. By default the request runs the FULL Omnius agent stack (tools, multi-agent, memory, skills) under the hood and returns an OpenAI chat.completion shape on success. Set tools=false to bypass the agent and forward straight to the configured backend (fast path).",
+          "summary": "Stateful direct chat with explicit autonomous-agent opt-in",
+          "description": "Drop-in replacement for OpenAI /v1/chat/completions and Ollama /api/chat. Requests use direct backend inference by default. Set tools=true or use_tools=true to explicitly run the full Omnius autonomous-agent stack. Explicit agent runs have a daemon-enforced whole-run deadline and duplicate-work suppression.",
           "tags": [
             "Chat"
           ],
@@ -5781,8 +5781,27 @@
                     },
                     "tools": {
                       "type": "boolean",
-                      "default": true,
-                      "description": "true (default) = full agent. false = direct backend chat. realtime=true also uses direct backend chat."
+                      "default": false,
+                      "description": "Set true to explicitly launch the full autonomous agent. Omitted or false uses direct backend chat."
+                    },
+                    "use_tools": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Omnius-native alias for tools=true; the built-in web UI uses this explicit opt-in."
+                    },
+                    "timeout_s": {
+                      "type": "number",
+                      "minimum": 0,
+                      "maximum": 3600,
+                      "default": 180,
+                      "description": "Per-backend-request liveness timeout passed to the agent CLI."
+                    },
+                    "agent_timeout_s": {
+                      "type": "number",
+                      "minimum": 0.05,
+                      "maximum": 3600,
+                      "default": 180,
+                      "description": "Daemon-enforced whole-agent wall-clock deadline. Distinct from timeout_s."
                     }
                   }
                 }

package/docs/DISCOVERY.md

@@ -115,7 +115,7 @@ Daemon equivalents are `GET /v1/discovery/bootstrap`, `GET /v1/discovery?q=<inte
 | `api.v1-audio-speech` | /v1/audio/speech | OpenAI-compatible alias of /v1/voice/tts (input/voice/response_format names) |
 | `api.v1-audio-transcriptions` | /v1/audio/transcriptions | OpenAI-compatible alias of /v1/asr/transcriptions |
 | `api.v1-audit` | /v1/audit | Query audit log |
-| `api.v1-chat` | /v1/chat | Stateful chat session with full agent tool access (OpenAI-compatible response shape) |
+| `api.v1-chat` | /v1/chat | Stateful direct chat with explicit autonomous-agent opt-in |
 | `api.v1-chat-attachments` | /v1/chat/attachments | Upload an attachment for a stateful chat |
 | `api.v1-chat-check-in` | /v1/chat/check-in | Send a steering check-in to the active chat session — returns model inference + queued steering_packet |
 | `api.v1-chat-completions` | /v1/chat/completions | OpenAI-compatible chat completion (with optional server-side agent loop) |

package/docs/rest/endpoints/chat.md

@@ -71,7 +71,7 @@ Realtime example:
 
 ## `/v1/chat`
 
-This is the Omnius stateful chat endpoint. By default it runs the full Omnius agent stack with tools, memory, skills, and multi-agent context. Set `tools: false` to use the fast direct backend path. `realtime: true` also uses the direct backend path.
+This is the Omnius stateful chat endpoint. It uses direct backend inference by default. Set `tools: true` or `use_tools: true` to explicitly launch the full Omnius agent stack with tools, memory, skills, and multi-agent context. `realtime: true` always uses the direct backend path. Explicit agent runs default to a 180-second daemon-owned wall-clock deadline and reject equivalent concurrent work even when callers omit `session_id`.
 
 Body fields:
 
@@ -81,7 +81,10 @@ Body fields:
 | `model` | string | Optional model override |
 | `session_id` | string | Reuse or name a session |
 | `stream` | boolean | Stream when supported |
-| `tools` | boolean | Full agent stack by default |
+| `tools` | boolean | Set true to explicitly launch the full agent stack |
+| `use_tools` | boolean | Omnius-native alias for `tools: true` |
+| `timeout_s` | number | Per-backend-request liveness timeout |
+| `agent_timeout_s` | number | Whole-agent daemon deadline, default 180 seconds and maximum 3600 |
 | `realtime` | boolean | Short ASR/TTS conversation mode |
 | `realtime_options` | object | Realtime settings |
 

package/npm-shrinkwrap.json

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

package/package.json

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