omnius 1.0.599 → 1.0.601

package/dist/index.js

@@ -630870,6 +630870,23 @@ function mergeRanges(ranges) {
 function rangeLabel(ranges) {
   return ranges.map((r2) => r2.end === Infinity || r2.start === 0 ? "whole file" : `lines ${r2.start}-${r2.end}`).join(", ");
 }
+function sameRange(a2, b) {
+  return a2.start === b.start && a2.end === b.end;
+}
+function rangeCovers(observed, requested) {
+  const requestedWhole = requested.start === 0 || requested.end === Infinity;
+  const observedWhole = observed.start === 0 || observed.end === Infinity;
+  if (requestedWhole)
+    return observedWhole;
+  if (observedWhole)
+    return true;
+  return observed.start <= requested.start && requested.end <= observed.end;
+}
+function rangeWidth(range) {
+  if (range.start === 0 || range.end === Infinity)
+    return Infinity;
+  return Math.max(0, range.end - range.start + 1);
+}
 function looksLikePartialCapture(content) {
   return /\[(?:oversize\s+(?:output|llmContent)|Tool output truncated|GREP_PARTIAL)\b/i.test(content);
 }
@@ -630895,16 +630912,36 @@ var init_evidenceLedger = __esm({
     "use strict";
     EvidenceLedger = class {
       entries = /* @__PURE__ */ new Map();
+      /** Exact replay bodies, independently range-bound from aggregate receipts. */
+      readBodies = /* @__PURE__ */ new Map();
+      recordBody(path16, body, reset) {
+        const prior = reset ? [] : this.readBodies.get(path16) ?? [];
+        const retained = prior.filter((candidate) => !sameRange(candidate.range, body.range));
+        retained.push(body);
+        retained.sort((a2, b) => b.lastReadTurn - a2.lastReadTurn);
+        this.readBodies.set(path16, retained.slice(0, 16));
+      }
       /** Record a successful read. `fileVersion` is the file's current writeCount. */
       recordRead(input) {
-        const { path: path16, content, range, fileVersion, turn } = input;
+        const { path: path16, content, fileVersion, turn } = input;
         if (!path16 || !content)
           return;
+        const reportedRange = input.artifactMaterialization?.sourceRange;
+        const materializedRange = reportedRange && typeof reportedRange.endLine === "number" ? {
+          startLine: reportedRange.startLine,
+          endLine: reportedRange.endLine
+        } : void 0;
+        const requestedWhole = input.range.start === 0 || input.range.end === Infinity;
+        const range = !requestedWhole && materializedRange ? {
+          start: materializedRange.startLine,
+          end: materializedRange.endLine
+        } : { ...input.range };
         const inferredPartial = input.artifactMaterialization?.status === "partial" || input.fidelity === "partial" || looksLikePartialCapture(content);
         const built = input.fidelity === "extract" ? { text: content, fidelity: "extract" } : inferredPartial ? { text: content, fidelity: "partial" } : { text: content, fidelity: "full" };
         const materialization = input.artifactMaterialization ?? (inferredPartial ? inferredPartialMaterialization(content) : void 0);
         const existing = this.entries.get(path16);
-        if (existing && existing.readVersion === fileVersion && !existing.stale) {
+        const sameRevision = existing && existing.readVersion === fileVersion && !existing.stale && (!existing.contentHash || !input.contentHash || existing.contentHash === input.contentHash);
+        if (existing && sameRevision) {
           if (built.fidelity === "extract" && existing.fidelity === "full") {
             const keepExistingCompleteExtract = existing.derivedExtract?.complete === true && input.extractComplete !== true;
             this.entries.set(path16, {
@@ -630926,6 +630963,14 @@ var init_evidenceLedger = __esm({
             return;
           }
           if (built.fidelity === "partial" && existing.fidelity === "full") {
+            this.recordBody(path16, {
+              range,
+              content: built.text,
+              ...input.contentHash ? { contentHash: input.contentHash } : {},
+              fidelity: "partial",
+              lastReadTurn: turn,
+              ...materialization ? { artifactMaterialization: materialization } : {}
+            }, false);
             this.entries.set(path16, {
               ...existing,
               lastReadTurn: turn,
@@ -630934,9 +630979,20 @@ var init_evidenceLedger = __esm({
             return;
           }
           const keepNew = existing.fidelity === "partial" && built.fidelity !== "partial" || built.text.length >= existing.content.length;
+          if (built.fidelity !== "extract") {
+            this.recordBody(path16, {
+              range,
+              content: built.text,
+              ...input.contentHash ? { contentHash: input.contentHash } : {},
+              fidelity: built.fidelity,
+              lastReadTurn: turn,
+              ...materialization ? { artifactMaterialization: materialization } : {}
+            }, false);
+          }
           this.entries.set(path16, {
             ...existing,
             content: keepNew ? built.text : existing.content,
+            contentRange: keepNew ? range : existing.contentRange,
             contentHash: input.contentHash ?? existing.contentHash,
             fidelity: keepNew ? built.fidelity : existing.fidelity,
             ...keepNew && materialization ? { artifactMaterialization: materialization } : existing.artifactMaterialization ? { artifactMaterialization: existing.artifactMaterialization } : {},
@@ -630948,12 +631004,25 @@ var init_evidenceLedger = __esm({
           });
           return;
         }
+        if (built.fidelity !== "extract") {
+          this.recordBody(path16, {
+            range,
+            content: built.text,
+            ...input.contentHash ? { contentHash: input.contentHash } : {},
+            fidelity: built.fidelity,
+            lastReadTurn: turn,
+            ...materialization ? { artifactMaterialization: materialization } : {}
+          }, true);
+        } else {
+          this.readBodies.delete(path16);
+        }
         this.entries.set(path16, {
           path: path16,
           contentHash: input.contentHash,
           readVersion: fileVersion,
           mtimeMs: input.mtimeMs ?? 0,
           lastReadTurn: turn,
+          contentRange: range,
           ranges: [range],
           content: built.text,
           fidelity: built.fidelity,
@@ -630974,6 +631043,19 @@ var init_evidenceLedger = __esm({
         const e2 = this.entries.get(path16);
         return !!e2 && !e2.stale && e2.fidelity !== "partial";
       }
+      /**
+       * Resolve a replay body only when that body's own provenance fully covers
+       * the requested range. Aggregate `EvidenceEntry.ranges` are receipts only.
+       */
+      resolveFreshRead(input) {
+        const entry = this.entries.get(input.path);
+        if (!entry || entry.stale)
+          return void 0;
+        if (input.contentHash && input.contentHash !== entry.contentHash) {
+          return void 0;
+        }
+        return (this.readBodies.get(input.path) ?? []).filter((body) => body.fidelity === "full" && (!input.contentHash || body.contentHash === input.contentHash) && rangeCovers(body.range, input.requestedRange)).sort((a2, b) => rangeWidth(a2.range) - rangeWidth(b.range) || b.lastReadTurn - a2.lastReadTurn)[0];
+      }
       /**
        * Validate evidence freshness against the real filesystem via stat().
        * If the file's mtime has changed since we last read it (external mutation
@@ -631022,6 +631104,7 @@ var init_evidenceLedger = __esm({
         const cap = Math.max(1, Math.min(200, Math.floor(maxEntries)));
         return [...this.entries.values()].sort((a2, b) => b.lastReadTurn - a2.lastReadTurn).slice(0, cap).map((entry) => ({
           ...entry,
+          contentRange: { ...entry.contentRange },
           ranges: entry.ranges.map((range) => ({ ...range })),
           ...entry.derivedExtract ? {
             derivedExtract: {
@@ -631053,6 +631136,7 @@ var init_evidenceLedger = __esm({
       }
       clear() {
         this.entries.clear();
+        this.readBodies.clear();
       }
       /**
        * Render the evidence block for the ACTIVE CONTEXT FRAME. Freshest reads
@@ -631077,8 +631161,10 @@ var init_evidenceLedger = __esm({
         let used = lines.join("\n").length;
         for (const e2 of sorted) {
           const selectedExtract = !e2.stale && e2.derivedExtract?.complete === true ? e2.derivedExtract : void 0;
-          const renderedRanges = selectedExtract?.ranges ?? e2.ranges;
-          const header = e2.stale ? `▸ ${e2.path} @v${e2.readVersion} [STALE — changed since read; re-read needed] (${rangeLabel(e2.ranges)})` : selectedExtract ? `▸ ${e2.path} @v${e2.readVersion} [DERIVED EXTRACT — contract complete; canonical full source retained] (${rangeLabel(renderedRanges)}):` : e2.fidelity === "partial" ? `▸ ${e2.path} @v${e2.readVersion} [PARTIAL — successful output was capped; do not infer omitted text is absent] (${rangeLabel(e2.ranges)})` : `▸ ${e2.path} @v${e2.readVersion} [FRESH${e2.contentHash ? ` sha256=${e2.contentHash}` : ""}] (${rangeLabel(e2.ranges)}):`;
+          const renderedRanges = selectedExtract?.ranges ?? [e2.contentRange];
+          const coverage = rangeLabel(e2.ranges);
+          const bodyRange = rangeLabel(renderedRanges);
+          const header = e2.stale ? `▸ ${e2.path} @v${e2.readVersion} [STALE — changed since read; re-read needed] (${rangeLabel(e2.ranges)})` : selectedExtract ? `▸ ${e2.path} @v${e2.readVersion} [DERIVED EXTRACT — contract complete; canonical full source retained] (${rangeLabel(renderedRanges)}):` : e2.fidelity === "partial" ? `▸ ${e2.path} @v${e2.readVersion} [PARTIAL — successful output was capped; do not infer omitted text is absent] (body ${bodyRange}; coverage ${coverage})` : `▸ ${e2.path} @v${e2.readVersion} [FRESH${e2.contentHash ? ` sha256=${e2.contentHash}` : ""}] (body ${bodyRange}; coverage ${coverage}):`;
           if (compact6) {
             const receipt2 = `- evidence_id=file:${e2.path}@v${e2.readVersion} outcome=${e2.stale ? "stale" : "fresh"} fidelity=${e2.fidelity} sha256=${e2.contentHash ?? "unknown"} ranges=${rangeLabel(renderedRanges)}`;
             if (used + receipt2.length + 1 <= maxChars) {
@@ -651412,20 +651498,6 @@ ${blob}
           const p2 = pathForResult(idx);
           if (p2 && latestIdxForPath.get(p2) === idx)
             continue;
-          if (p2 && content.length >= 100) {
-            try {
-              this._evidenceLedger.recordRead({
-                path: this._normalizeEvidencePath(p2),
-                content,
-                contentHash: this._extractFileReadSha256(content) ?? void 0,
-                range: { start: 0, end: Number.POSITIVE_INFINITY },
-                fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
-                mtimeMs: this._statMtimeMsForToolPath(p2),
-                turn: this._taskState?.toolCallCount ?? 0
-              });
-            } catch {
-            }
-          }
           const meta = metaForResult(idx);
           let stub;
           if (p2) {
@@ -651585,20 +651657,6 @@ ${blob}
           if (covered)
             return cov.fingerprint;
         }
-        if (!iv.whole && Number.isFinite(iv.end)) {
-          let best = null;
-          const requestedLength = Math.max(1, iv.end - iv.start + 1);
-          for (const cov of intervals) {
-            if (cov.whole || !Number.isFinite(cov.end))
-              continue;
-            const overlap = Math.max(0, Math.min(iv.end, cov.end) - Math.max(iv.start, cov.start) + 1);
-            if (overlap / requestedLength >= 0.8 && (!best || overlap > best.overlap)) {
-              best = { fingerprint: cov.fingerprint, overlap };
-            }
-          }
-          if (best)
-            return best.fingerprint;
-        }
         return exactFingerprint;
       }
       /** Register a read's region under the fingerprint that cached its result. */
@@ -652779,16 +652837,12 @@ ${notice}`;
           this._emitSteeringLifecycle(record, gatesOldPlan ? `admitted at turn ${turn}; old-plan actions are gated pending structured reconciliation` : `admitted at turn ${turn}; awaiting structured reconciliation`);
         }
       }
-      _canonicalReadEvidencePayload(canonicalPath2, contentHash2) {
-        const evidence = this._evidenceLedger.get(canonicalPath2);
-        if (evidence && !evidence.stale && evidence.contentHash === contentHash2 && evidence.fidelity === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(evidence.content, "utf8"), evidence.content.split("\n").length, this._branchRoutingContextWindow())) {
-          return evidence.content;
-        }
-        const branch = this._branchEvidenceByPath.get(canonicalPath2);
-        if (branch && branch.contentHash === contentHash2 && branch.taskEpoch === this._taskEpoch && branch.contractComplete) {
-          return branch.output;
-        }
-        return null;
+      _canonicalReadEvidencePayload(canonicalPath2, contentHash2, requestedRange) {
+        return this._evidenceLedger.resolveFreshRead({
+          path: canonicalPath2,
+          requestedRange,
+          contentHash: contentHash2
+        })?.content ?? null;
       }
       _rehydrateResolvedReadEvidence(input) {
         return [
@@ -658897,27 +658951,26 @@ ${cachedResult}`,
                           let branchEvidenceResult = null;
                           if (normalizedDispatchName === "file_read" && this._fileReadMode(tc.arguments) !== "extract") {
                             const exactReadFingerprint = this._buildToolFingerprint("file_read", tc.arguments);
+                            const exactReadInterval = this._readIntervalFromArgs("file_read", tc.arguments);
+                            const requestedReadRange = exactReadInterval && !exactReadInterval.whole ? {
+                              start: exactReadInterval.start,
+                              end: exactReadInterval.end
+                            } : {
+                              start: 0,
+                              end: Number.POSITIVE_INFINITY
+                            };
                             const exactReadKey = this._resolveReadCoverageFingerprint("file_read", tc.arguments, exactReadFingerprint);
                             const priorRead = exactFileReadObservations.get(exactReadKey);
                             if (priorRead) {
                               const currentRead = this._fileReadDiskIdentity(tc.arguments);
                               if (currentRead && currentRead.contentHash === priorRead.contentHash) {
                                 exactFileReadObservations.set(exactReadKey, currentRead);
-                                const canonicalPayload = this._canonicalReadEvidencePayload(currentRead.canonicalPath, currentRead.contentHash);
+                                const canonicalPayload = this._canonicalReadEvidencePayload(currentRead.canonicalPath, currentRead.contentHash, requestedReadRange);
                                 if (canonicalPayload) {
-                                  const evidence = this._evidenceLedger.get(currentRead.canonicalPath);
-                                  const fullSource = evidence?.fidelity === "full" && evidence.content === canonicalPayload;
-                                  const delivered = fullSource ? canonicalPayload : this._rehydrateResolvedReadEvidence({
-                                    fingerprint: exactReadKey,
-                                    canonicalPath: currentRead.canonicalPath,
-                                    contentHash: currentRead.contentHash,
-                                    payload: canonicalPayload,
-                                    turn
-                                  });
                                   branchEvidenceResult = {
                                     success: true,
-                                    output: delivered,
-                                    llmContent: delivered,
+                                    output: canonicalPayload,
+                                    llmContent: canonicalPayload,
                                     beforeHash: currentRead.contentHash,
                                     runtimeAuthored: true,
                                     noop: true,
@@ -658930,16 +658983,15 @@ ${cachedResult}`,
                                   this.emit({
                                     type: "status",
                                     toolName: normalizedDispatchName,
-                                    content: fullSource ? `Exact unchanged file_read served as canonical full source: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}` : `Exact unchanged file_read reused complete branch evidence: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
+                                    content: `Unchanged file_read served from range-safe canonical source: ${currentRead.path} sha256=${currentRead.contentHash.slice(0, 12)}`,
                                     turn,
                                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                                   });
                                 } else {
-                                  exactFileReadObservations.delete(exactReadKey);
                                   this.emit({
                                     type: "status",
                                     toolName: normalizedDispatchName,
-                                    content: `Exact read cache lacks model-visible source; executing requested read: ${currentRead.path}`,
+                                    content: `Read cache has no body covering the requested range; executing requested read: ${currentRead.path}`,
                                     turn,
                                     timestamp: (/* @__PURE__ */ new Date()).toISOString()
                                   });
@@ -659265,6 +659317,14 @@ ${diagnostic}`;
                     const rLimit = typeof tc.arguments?.["limit"] === "number" ? tc.arguments["limit"] : void 0;
                     const start3 = rOffset === void 0 && rLimit === void 0 ? 0 : Math.max(1, rOffset ?? 1);
                     const end = rOffset === void 0 && rLimit === void 0 ? Number.POSITIVE_INFINITY : rLimit !== void 0 ? Math.max(1, rOffset ?? 1) + Math.max(0, rLimit) - 1 : Number.POSITIVE_INFINITY;
+                    const requestedWhole = start3 === 0;
+                    const reportedRange = result.artifactMaterialization?.sourceRange;
+                    const materializedRange = reportedRange && typeof reportedRange.endLine === "number" ? {
+                      startLine: reportedRange.startLine,
+                      endLine: reportedRange.endLine
+                    } : void 0;
+                    const effectiveStart = !requestedWhole && materializedRange ? materializedRange.startLine : start3;
+                    const effectiveEnd = !requestedWhole && materializedRange ? materializedRange.endLine : end;
                     this._evidenceLedger.recordRead({
                       path: this._normalizeEvidencePath(p2),
                       content: result.output,
@@ -659283,8 +659343,8 @@ ${diagnostic}`;
                         path: this._normalizeEvidencePath(p2),
                         contentHash: result.beforeHash,
                         sourceRange: {
-                          startLine: start3 || 1,
-                          endLine: end === Number.POSITIVE_INFINITY ? Number.MAX_SAFE_INTEGER : end
+                          startLine: effectiveStart || 1,
+                          endLine: effectiveEnd === Number.POSITIVE_INFINITY ? Number.MAX_SAFE_INTEGER : effectiveEnd
                         },
                         turn
                       });
@@ -659295,8 +659355,14 @@ ${diagnostic}`;
                         this._inlineReadArtifacts.delete(oldest);
                       }
                     }
-                    if (result.partial !== true && result.artifactMaterialization?.status !== "partial") {
-                      this._registerReadCoverage("file_read", tc.arguments, toolFingerprint);
+                    if (result.runtimeAuthored !== true && result.partial !== true && result.artifactMaterialization?.status !== "partial" && this._fileReadMode(tc.arguments) !== "extract") {
+                      const coverageArgs = !requestedWhole && materializedRange ? {
+                        ...tc.arguments,
+                        offset: effectiveStart,
+                        limit: Math.max(0, effectiveEnd - effectiveStart + 1)
+                      } : tc.arguments;
+                      const exactCoverageFingerprint = this._buildToolFingerprint("file_read", coverageArgs);
+                      this._registerReadCoverage("file_read", coverageArgs, this._resolveReadCoverageFingerprint("file_read", coverageArgs, exactCoverageFingerprint));
                     }
                   }
                   if (this._fileSummaryStore && result.success && result.output && result.output.length > 100) {
@@ -678074,6 +678140,8 @@ ${AGENTS_END}`;
 var daemon_exports = {};
 __export(daemon_exports, {
   claimDaemonEndpoint: () => claimDaemonEndpoint,
+  daemonPortFromServiceEnvironment: () => daemonPortFromServiceEnvironment,
+  daemonServiceMatchesPort: () => daemonServiceMatchesPort,
   ensureDaemon: () => ensureDaemon,
   ensureDaemonVersion: () => ensureDaemonVersion,
   forceKillDaemon: () => forceKillDaemon,
@@ -678089,7 +678157,8 @@ __export(daemon_exports, {
   releaseDaemonEndpointForCurrentProcess: () => releaseDaemonEndpointForCurrentProcess,
   restartDaemon: () => restartDaemon,
   startDaemon: () => startDaemon,
-  stopDaemon: () => stopDaemon
+  stopDaemon: () => stopDaemon,
+  stopDaemonAtPort: () => stopDaemonAtPort
 });
 import { spawn as spawn28 } from "node:child_process";
 import { existsSync as existsSync116, readFileSync as readFileSync94, writeFileSync as writeFileSync60, mkdirSync as mkdirSync69, unlinkSync as unlinkSync22, openSync as openSync4, closeSync as closeSync4, writeSync as writeSync3, statSync as statSync46, renameSync as renameSync17 } from "node:fs";
@@ -678213,7 +678282,9 @@ async function isDaemonRunning(port) {
     const resp = await fetch(`http://127.0.0.1:${p2}/health`, {
       signal: AbortSignal.timeout(2e3)
     });
-    return resp.ok;
+    if (!resp.ok) return false;
+    const health = await resp.json();
+    return health.status === "ok" && (typeof health.boot_version === "string" || typeof health.version === "string");
   } catch {
     return false;
   }
@@ -678279,12 +678350,49 @@ async function runUserSystemctl(args, timeout2 = 2e4) {
     return { available: false, ok: false };
   }
 }
+async function readUserSystemctl(args, timeout2 = 5e3) {
+  try {
+    const { spawnSync: spawnSync11 } = await import("node:child_process");
+    const result = spawnSync11("systemctl", ["--user", ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: timeout2
+    });
+    return result.status === 0 ? result.stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
 async function hasManagedDaemonService() {
   const enabled2 = await runUserSystemctl(["is-enabled", "omnius-daemon.service"], 5e3);
   if (enabled2.ok) return true;
   const active = await runUserSystemctl(["is-active", "omnius-daemon.service"], 5e3);
   return active.ok;
 }
+function daemonPortFromServiceEnvironment(value2) {
+  const host = value2.match(/(?:^|\s)OMNIUS_HOST=(?:"([^"]+)"|'([^']+)'|([^\s]+))/)?.slice(1).find(Boolean);
+  const direct = value2.match(/(?:^|\s)OMNIUS_PORT=(?:"(\d+)"|'(\d+)'|(\d+))/)?.slice(1).find(Boolean);
+  const candidate = host?.match(/:(\d+)$/)?.[1] ?? direct;
+  if (!candidate) return null;
+  const port = Number(candidate);
+  return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : null;
+}
+function daemonServiceMatchesPort(requestedPort, effectiveEnvironment) {
+  const effectivePort2 = daemonPortFromServiceEnvironment(effectiveEnvironment);
+  return effectivePort2 === null ? requestedPort === DEFAULT_PORT2 : effectivePort2 === requestedPort;
+}
+async function managedDaemonServiceMatchesPort(port) {
+  if (!await hasManagedDaemonService()) return false;
+  const environment = await readUserSystemctl([
+    "show",
+    "omnius-daemon.service",
+    "--property",
+    "Environment",
+    "--value"
+  ]);
+  if (environment === null) return false;
+  return daemonServiceMatchesPort(port, environment);
+}
 function systemdQuote(value2) {
   return /[\s"\\]/.test(value2) ? `"${value2.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : value2;
 }
@@ -678382,6 +678490,43 @@ async function waitForDaemonStopped(port, attempts = DAEMON_GRACEFUL_STOP_ATTEMP
   }
   return false;
 }
+async function reclaimStaleDaemonEndpointClaim(port) {
+  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 {
+        unlinkSync22(lockFile);
+      } catch {
+      }
+    }
+    return true;
+  }
+  const lease = listProcessLeases({ includeInactive: false }).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
+  });
+  if (stopped.action !== "killed" && stopped.action !== "dead") return false;
+  for (let attempt = 0; attempt < 20 && processIsAlive(record.pid); attempt++) {
+    await delay3(100);
+  }
+  if (processIsAlive(record.pid)) return false;
+  const current = readDaemonLock(lockFile);
+  if (current?.pid === record.pid && current.token === record.token) {
+    try {
+      unlinkSync22(lockFile);
+    } catch {
+    }
+  }
+  return daemonPortIsFree(port);
+}
 async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies = DEFAULT_RECLAIM_DEPENDENCIES) {
   const holders = await dependencies.holderPids(port);
   if (holders === null) {
@@ -678457,7 +678602,7 @@ async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies =
 }
 async function restartDaemon(port, expectedVersion) {
   const p2 = port ?? getDaemonPort();
-  const managed = await hasManagedDaemonService();
+  const managed = await managedDaemonServiceMatchesPort(p2);
   if (managed) {
     const restarted = await runUserSystemctl(["restart", "omnius-daemon.service"]);
     if (restarted.ok && (await waitForDaemonReady(p2, expectedVersion)).ok) return true;
@@ -678478,6 +678623,7 @@ async function restartDaemon(port, expectedVersion) {
     const reclaimed = await reclaimOwnedDaemonListener(p2);
     if (!reclaimed.ok) return false;
   }
+  if (!await reclaimStaleDaemonEndpointClaim(p2)) return false;
   const pid = await startDaemon(p2);
   if (!pid) return false;
   return (await waitForDaemonReady(p2, expectedVersion)).ok;
@@ -678584,7 +678730,7 @@ async function startDaemon(port = getDaemonPort()) {
         projectRoot: process.cwd(),
         lifecycle: "daemon",
         persistent: true,
-        reason: `shared API daemon on port ${getDaemonPort()}`,
+        reason: `shared API daemon on port ${daemonPort}`,
         command: [daemonCommand.command, ...daemonCommand.args].join(" "),
         cwd: process.cwd()
       });
@@ -678629,6 +678775,17 @@ function stopDaemon() {
     return false;
   }
 }
+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;
+  }
+  const wasRunning = await isDaemonRunning(port);
+  const reclaimed = await reclaimOwnedDaemonListener(port);
+  if (!reclaimed.ok) return false;
+  const claimCleared = await reclaimStaleDaemonEndpointClaim(port);
+  return claimCleared && (wasRunning || reclaimed.action === "cleared");
+}
 async function forceKillDaemon(port) {
   const p2 = port ?? getDaemonPort();
   let killed = 0;
@@ -678738,6 +678895,9 @@ async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port
       process.platform === "linux" && reclaimed.action === "blocked"
     );
   }
+  if (!await reclaimStaleDaemonEndpointClaim(port)) {
+    return finish(false, "failed", null, 0, process.platform === "linux");
+  }
   getDaemonPid();
   const pid = await startDaemon(port);
   if (!pid) {
@@ -678822,9 +678982,11 @@ __export(tray_exports, {
   resolveTrayEndpoint: () => resolveTrayEndpoint,
   resolveTrayLaunchCommand: () => resolveTrayLaunchCommand,
   resolveTrayPaths: () => resolveTrayPaths,
+  resolveTrayRegistrationCommand: () => resolveTrayRegistrationCommand,
   runTrayForeground: () => runTrayForeground,
   startTray: () => startTray,
   stopTray: () => stopTray,
+  trayProcessCommandLooksOwned: () => trayProcessCommandLooksOwned,
   trayRequiresRestart: () => trayRequiresRestart,
   traySupport: () => traySupport,
   trayUpdatePresentation: () => trayUpdatePresentation,
@@ -678840,6 +679002,7 @@ import {
   mkdirSync as mkdirSync70,
   openSync as openSync5,
   readFileSync as readFileSync95,
+  realpathSync,
   renameSync as renameSync18,
   unlinkSync as unlinkSync23,
   writeFileSync as writeFileSync61,
@@ -678855,7 +679018,8 @@ function trayUpdatePresentation(currentVersion, latestVersion, state = null) {
       title: `Updating to v${state.target_version} — ${state.phase.replaceAll("_", " ")}`,
       tooltip: `Operation ${state.operation_id}; progress is shared with the dashboard and CLI`,
       enabled: false,
-      targetVersion: state.target_version
+      targetVersion: state.target_version,
+      action: "update-omnius"
     };
   }
   if (state?.status === "failed" && state.target_version === latestVersion) {
@@ -678863,7 +679027,8 @@ function trayUpdatePresentation(currentVersion, latestVersion, state = null) {
       title: `Update to v${state.target_version} failed — retry`,
       tooltip: state.remediation || state.error || "Open the tray logs for update diagnostics",
       enabled: true,
-      targetVersion: state.target_version
+      targetVersion: state.target_version,
+      action: "update-omnius"
     };
   }
   if (currentVersion && latestVersion) {
@@ -678871,13 +679036,15 @@ function trayUpdatePresentation(currentVersion, latestVersion, state = null) {
       title: `Update Omnius to v${latestVersion}`,
       tooltip: `Install and verify the global package, executable, daemon, and tray (current v${currentVersion})`,
       enabled: true,
-      targetVersion: latestVersion
+      targetVersion: latestVersion,
+      action: "update-omnius"
     };
   }
   return {
-    title: currentVersion ? `Omnius v${currentVersion} is up to date` : "Check for Omnius updates",
-    tooltip: "Automatic update checks use the same cached registry result as the CLI and dashboard",
-    enabled: false
+    title: currentVersion ? `Check for Omnius updates (v${currentVersion})` : "Check for Omnius updates",
+    tooltip: "Check npm now; automatic checks continue in the background",
+    enabled: Boolean(currentVersion),
+    action: "check-update"
   };
 }
 function uidSuffix() {
@@ -678928,19 +679095,6 @@ function normalizeTrayEndpoint(value2) {
     return null;
   }
 }
-function systemdDaemonEnvironment() {
-  if (process.platform !== "linux") return "";
-  try {
-    const result = spawnSync9(
-      "systemctl",
-      ["--user", "show", SERVICE_LABEL, "--property", "Environment", "--value"],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }
-    );
-    return result.status === 0 ? result.stdout.trim() : "";
-  } catch {
-    return "";
-  }
-}
 function endpointFromServiceEnvironment(value2) {
   const host = value2.match(/(?:^|\s)OMNIUS_HOST=(?:"([^"]+)"|'([^']+)'|([^\s]+))/)?.slice(1).find(Boolean);
   const port = value2.match(/(?:^|\s)OMNIUS_PORT=(?:"(\d+)"|'(\d+)'|(\d+))/)?.slice(1).find(Boolean);
@@ -678952,7 +679106,6 @@ function resolveTrayEndpoint(explicit) {
     process.env["OMNIUS_TRAY_ENDPOINT"],
     process.env["OMNIUS_HOST"],
     process.env["OMNIUS_PORT"],
-    endpointFromServiceEnvironment(systemdDaemonEnvironment()),
     DEFAULT_ENDPOINT
   ];
   for (const candidate of candidates) {
@@ -679092,6 +679245,30 @@ function readProcessState(path16) {
     return null;
   }
 }
+function processCommandLine(pid) {
+  try {
+    if (process.platform === "linux") {
+      return readFileSync95(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
+    }
+    if (process.platform !== "win32") {
+      return spawnSync9("ps", ["-p", String(pid), "-o", "command="], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 2e3
+      }).stdout.trim();
+    }
+    return spawnSync9("wmic", ["process", "where", `ProcessId=${pid}`, "get", "CommandLine", "/value"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).stdout;
+  } catch {
+    return "";
+  }
+}
+function trayProcessCommandLooksOwned(command) {
+  return /(?:^|\s)tray\s+run(?:\s|$)/i.test(command) && (/(?:^|[\\/\s])omnius(?:[\\/\s]|$)/i.test(command) || /[\\/]dist[\\/]index\.js\b|launcher\.cjs\b/i.test(command));
+}
 function writeProcessState(paths, state) {
   mkdirSync70(paths.runtimeDir, { recursive: true, mode: 448 });
   const temporary = `${paths.stateFile}.${process.pid}.tmp`;
@@ -679166,6 +679343,34 @@ function resolveTrayLaunchCommand() {
   }
   return null;
 }
+function installedOmniusLaunchCommand() {
+  try {
+    const result = spawnSync9(process.platform === "win32" ? "where" : "which", ["omnius"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+    const first2 = result.stdout?.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    return first2 && existsSync117(first2) ? commandForEntrypoint2(realpathSync(first2)) : null;
+  } catch {
+    return null;
+  }
+}
+function resolveTrayRegistrationCommand() {
+  return installedOmniusLaunchCommand() ?? resolveTrayLaunchCommand();
+}
+function registrationIconPath(launch) {
+  const extension3 = process.platform === "win32" ? "ico" : "png";
+  const entrypoints = [...launch.args, launch.command].filter((candidate) => existsSync117(candidate));
+  for (const entrypoint of entrypoints) {
+    const real = realpathSync(entrypoint);
+    for (const packageRoot of [dirname43(real), join129(dirname43(real), "..")]) {
+      const candidate = join129(packageRoot, "assets", "tray", `omnius-online.${extension3}`);
+      if (existsSync117(candidate)) return candidate;
+    }
+  }
+  return assetPath("online");
+}
 function desktopExecQuote(value2) {
   return `"${value2.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("$", "\\$").replaceAll("`", "\\`")}"`;
 }
@@ -679219,13 +679424,13 @@ start "" /b ${argv.map(windowsCmdQuote).join(" ")}\r
   throw new Error(`Autostart is not supported on ${platform8}`);
 }
 function writeTrayAutostart(endpoint) {
-  const launch = resolveTrayLaunchCommand();
+  const launch = resolveTrayRegistrationCommand();
   if (!launch) throw new Error("Could not resolve the installed Omnius CLI entrypoint");
   const paths = resolveTrayPaths();
   mkdirSync70(dirname43(paths.autostartFile), { recursive: true });
   writeFileSync61(
     paths.autostartFile,
-    buildAutostartContent(process.platform, launch, endpoint, assetPath("online")),
+    buildAutostartContent(process.platform, launch, endpoint, registrationIconPath(launch)),
     { encoding: "utf8", mode: process.platform === "win32" ? 448 : 384 }
   );
   return paths.autostartFile;
@@ -679247,44 +679452,12 @@ function uninstallTrayAutostart() {
   unlinkSync23(paths.autostartFile);
   return true;
 }
-function runServiceControl(action) {
-  try {
-    if (process.platform === "linux") {
-      const result = spawnSync9("systemctl", ["--user", action, SERVICE_LABEL], {
-        stdio: "ignore",
-        timeout: 1e4
-      });
-      return result.status === 0;
-    }
-    if (process.platform === "darwin" && typeof process.getuid === "function") {
-      const domain = `gui/${process.getuid()}`;
-      const plist = join129(homedir40(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-      if (action === "stop") {
-        return spawnSync9("launchctl", ["bootout", `${domain}/${LAUNCHD_LABEL}`], { stdio: "ignore", timeout: 1e4 }).status === 0;
-      }
-      if (action === "restart") {
-        return spawnSync9("launchctl", ["kickstart", "-k", `${domain}/${LAUNCHD_LABEL}`], { stdio: "ignore", timeout: 1e4 }).status === 0;
-      }
-      spawnSync9("launchctl", ["bootstrap", domain, plist], { stdio: "ignore", timeout: 1e4 });
-      return spawnSync9("launchctl", ["kickstart", `${domain}/${LAUNCHD_LABEL}`], { stdio: "ignore", timeout: 1e4 }).status === 0;
-    }
-    if (process.platform === "win32") {
-      const args = action === "stop" ? ["/End", "/TN", WINDOWS_TASK_NAME] : ["/Run", "/TN", WINDOWS_TASK_NAME];
-      return spawnSync9("schtasks", args, { stdio: "ignore", timeout: 1e4 }).status === 0;
-    }
-  } catch {
-  }
-  return false;
-}
 async function controlDaemon(action, endpoint) {
-  if (runServiceControl(action)) return true;
-  if (action === "stop") return stopDaemon();
-  if (action === "restart") {
-    stopDaemon();
-    await new Promise((resolve87) => setTimeout(resolve87, 500));
-  }
   const port = Number(new URL(endpoint).port);
-  return await startDaemon(Number.isInteger(port) && port > 0 ? port : void 0) !== null;
+  if (!Number.isInteger(port) || port <= 0) return false;
+  if (action === "stop") return stopDaemonAtPort(port);
+  if (action === "restart") return restartDaemon(port, getLocalCliVersion());
+  return (await ensureDaemonVersion(getLocalCliVersion(), port)).ok;
 }
 function openExternal(target) {
   try {
@@ -679328,7 +679501,7 @@ function menuForHealth(health, endpoint, registered, update2) {
     title: update2.title,
     tooltip: update2.tooltip,
     enabled: update2.enabled,
-    action: "update-omnius"
+    action: update2.action
   };
   return {
     healthItem,
@@ -679396,7 +679569,9 @@ async function startTray(explicitEndpoint) {
     if (!trayRequiresRestart(existing, endpoint, liveHealth)) {
       return { ...existing, health: liveHealth };
     }
-    await stopTray();
+    if (!await stopTray()) {
+      throw new Error(`Could not stop the existing Omnius indicator on ${existing.endpoint}`);
+    }
   }
   const support = traySupport();
   if (!support.supported) throw new Error(support.reason || "Tray is not supported on this host");
@@ -679447,16 +679622,49 @@ async function stopTray() {
     }
     return false;
   }
+  const state = readProcessState(paths.stateFile);
+  if (state?.pid !== pid || !trayProcessCommandLooksOwned(processCommandLine(pid))) {
+    return false;
+  }
   try {
     process.kill(pid, "SIGTERM");
   } catch {
     return false;
   }
   for (let i2 = 0; i2 < 30; i2++) {
-    if (!isProcessAlive2(pid)) return true;
+    if (!isProcessAlive2(pid)) {
+      try {
+        unlinkSync23(paths.pidFile);
+      } catch {
+      }
+      try {
+        unlinkSync23(paths.stateFile);
+      } catch {
+      }
+      return true;
+    }
     await new Promise((resolve87) => setTimeout(resolve87, 100));
   }
-  return !isProcessAlive2(pid);
+  if (!trayProcessCommandLooksOwned(processCommandLine(pid))) return false;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  for (let i2 = 0; i2 < 20; i2++) {
+    if (!isProcessAlive2(pid)) {
+      try {
+        unlinkSync23(paths.pidFile);
+      } catch {
+      }
+      try {
+        unlinkSync23(paths.stateFile);
+      } catch {
+      }
+      return true;
+    }
+    await new Promise((resolve87) => setTimeout(resolve87, 100));
+  }
+  return false;
 }
 async function runTrayForeground(explicitEndpoint) {
   const support = traySupport();
@@ -679553,6 +679761,7 @@ async function runTrayForeground(explicitEndpoint) {
       menuState.updateItem.title = updateView.title;
       menuState.updateItem.tooltip = updateView.tooltip;
       menuState.updateItem.enabled = updateView.enabled;
+      menuState.updateItem.action = updateView.action;
       const autostartRegistered = existsSync117(paths.autostartFile);
       const autostartChanged = menuState.autostartItem.checked !== autostartRegistered;
       if (autostartChanged) menuState.autostartItem.checked = autostartRegistered;
@@ -679621,6 +679830,22 @@ async function runTrayForeground(explicitEndpoint) {
             await tray?.sendAction({ type: "update-item", item: menuState.updateItem });
             break;
           }
+          case "check-update": {
+            const currentVersion = health.version;
+            if (!currentVersion) break;
+            availableUpdate = await checkForUpdate(currentVersion, true);
+            updateView = trayUpdatePresentation(
+              currentVersion,
+              availableUpdate?.latestVersion,
+              readUpdateState()
+            );
+            menuState.updateItem.title = updateView.title;
+            menuState.updateItem.tooltip = updateView.tooltip;
+            menuState.updateItem.enabled = updateView.enabled;
+            menuState.updateItem.action = updateView.action;
+            await tray?.sendAction({ type: "update-item", item: menuState.updateItem });
+            break;
+          }
           case "quit":
             await shutdown();
             break;
@@ -679642,7 +679867,7 @@ async function runTrayForeground(explicitEndpoint) {
     releaseTrayPid(paths);
   }
 }
-var DEFAULT_ENDPOINT, TRAY_HELPER_VERSION, POLL_INTERVAL_MS, START_WAIT_MS, SERVICE_LABEL, LAUNCHD_LABEL, WINDOWS_TASK_NAME, EXPECTED_HELPER_SHA256;
+var DEFAULT_ENDPOINT, TRAY_HELPER_VERSION, POLL_INTERVAL_MS, START_WAIT_MS, EXPECTED_HELPER_SHA256;
 var init_tray = __esm({
   "packages/cli/src/tray.ts"() {
     init_daemon();
@@ -679652,9 +679877,6 @@ var init_tray = __esm({
     TRAY_HELPER_VERSION = "2.1.4";
     POLL_INTERVAL_MS = 1e4;
     START_WAIT_MS = 5e3;
-    SERVICE_LABEL = "omnius-daemon.service";
-    LAUNCHD_LABEL = "ai.omnius.daemon";
-    WINDOWS_TASK_NAME = "OmniusDaemon";
     EXPECTED_HELPER_SHA256 = {
       aix: void 0,
       android: void 0,
@@ -679693,6 +679915,26 @@ function output(status, json = false) {
 `);
   else printStatus(status);
 }
+function endpointPort(endpoint) {
+  const port = Number(new URL(endpoint).port);
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new Error(`Invalid tray daemon endpoint: ${endpoint}`);
+  }
+  return port;
+}
+async function ensureTrayDaemonOnline(endpoint) {
+  const port = endpointPort(endpoint);
+  const daemon = await ensureDaemonVersion(getLocalCliVersion(), port);
+  if (!daemon.ok) {
+    throw new Error(`Could not reconcile the Omnius daemon on port ${port}`);
+  }
+  for (let attempt = 0; attempt < 10; attempt++) {
+    const health = await pollTrayHealth(endpoint);
+    if (health.kind === "online") return;
+    await new Promise((resolve87) => setTimeout(resolve87, 200));
+  }
+  throw new Error(`Omnius daemon did not become online at ${endpoint}`);
+}
 async function trayCommand(options2) {
   const raw = options2.subCommand || "status";
   if (!SUBCOMMANDS.has(raw)) {
@@ -679701,10 +679943,12 @@ async function trayCommand(options2) {
   const subCommand = raw;
   const endpoint = resolveTrayEndpoint(options2.endpoint);
   if (subCommand === "run") {
+    await ensureTrayDaemonOnline(endpoint);
     await runTrayForeground(endpoint);
     return;
   }
   if (subCommand === "install") {
+    await ensureTrayDaemonOnline(endpoint);
     const registrationFile = installTrayAutostart(endpoint);
     const status = await startTray(endpoint);
     if (!options2.json) process.stdout.write(`Registered tray autostart: ${registrationFile}
@@ -679721,6 +679965,7 @@ async function trayCommand(options2) {
     return;
   }
   if (subCommand === "start") {
+    await ensureTrayDaemonOnline(endpoint);
     output(await startTray(endpoint), options2.json);
     return;
   }
@@ -679732,7 +679977,11 @@ async function trayCommand(options2) {
     return;
   }
   if (subCommand === "restart") {
-    await stopTray();
+    await ensureTrayDaemonOnline(endpoint);
+    const status = await getTrayStatus(endpoint);
+    if (status.running && !await stopTray()) {
+      throw new Error(`Could not stop the existing Omnius indicator on ${status.endpoint}`);
+    }
     output(await startTray(endpoint), options2.json);
     return;
   }
@@ -679742,6 +679991,7 @@ var SUBCOMMANDS;
 var init_tray2 = __esm({
   "packages/cli/src/commands/tray.ts"() {
     init_tray();
+    init_daemon();
     SUBCOMMANDS = /* @__PURE__ */ new Set([
       "install",
       "uninstall",
@@ -724558,9 +724808,18 @@ async function runIndicatorCommand(rawAction, operations = DEFAULT_OPERATIONS) {
         daemon
       };
     }
+    operations.register?.(endpoint);
     const started = await operations.start(endpoint);
+    if (!started.running || !started.ready || started.endpoint !== endpoint || started.error) {
+      return {
+        level: "error",
+        message: `Indicator did not bind to ${endpoint}. ` + formatIndicatorStatus(started, daemon),
+        status: started,
+        daemon
+      };
+    }
     const health = await waitForOnlineHealth(endpoint, operations);
-    const status = { ...started, endpoint, health };
+    const status = { ...started, health };
     const level = status.error ? "error" : status.running && status.ready && health.kind === "online" ? "info" : "error";
     return {
       level,
@@ -724582,6 +724841,7 @@ var init_indicator_command = __esm({
     init_daemon();
     DEFAULT_OPERATIONS = {
       ensureDaemon: () => ensureDaemonVersion(),
+      register: (endpoint) => installTrayAutostart(endpoint),
       start: (endpoint) => startTray(endpoint),
       status: () => getTrayStatus(),
       health: (endpoint) => pollTrayHealth(endpoint),

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.599",
+  "version": "1.0.601",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.599",
+      "version": "1.0.601",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -4084,9 +4084,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.12.34",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.34.tgz",
-      "integrity": "sha512-GqXJqY/xJkJmuloTrnV1ZEXG3fqte+VjkUqoRNZXcrUidiUOP4fMSIHHY4tsqZBK++kVyWmt/AAfSUuy57/eSA==",
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.0.tgz",
+      "integrity": "sha512-jhunvfHWxd7J5EFfSgH4xsYJzSe/lfqbUCxiyyeaQasUsXeEHXtzVid+7EOGByc5JnFa23SSFL3Y2RV/z1T+eQ==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"
@@ -7675,9 +7675,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.21.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.1.tgz",
-      "integrity": "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==",
+      "version": "8.21.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.2.tgz",
+      "integrity": "sha512-54dMVAo4WIe6SKy3vBgN+9bJZqqQ8IMRevAkOLQALhi49qkkQDQfWdAZ8KQlXiEabw88ARXXdUrlvtbKQX+aKw==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/package.json

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