omnius 1.0.598 → 1.0.600

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) {
@@ -678083,6 +678149,7 @@ __export(daemon_exports, {
   getDaemonStatus: () => getDaemonStatus,
   getLocalCliVersion: () => getLocalCliVersion,
   isDaemonRunning: () => isDaemonRunning,
+  reclaimOwnedDaemonListener: () => reclaimOwnedDaemonListener,
   recoverDaemonVersionBoundedly: () => recoverDaemonVersionBoundedly,
   releaseDaemonEndpointClaim: () => releaseDaemonEndpointClaim,
   releaseDaemonEndpointForCurrentProcess: () => releaseDaemonEndpointForCurrentProcess,
@@ -678094,6 +678161,7 @@ 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";
 import { join as join128 } from "node:path";
 import { homedir as homedir39 } from "node:os";
+import { createServer as createNetServer } from "node:net";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
 import { dirname as dirname42 } from "node:path";
 function getDaemonPort() {
@@ -678353,55 +678421,105 @@ ${fuser.stderr ?? ""}`;
     return null;
   }
 }
-function processCommandLine(pid) {
-  try {
-    return readFileSync94(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
-  } catch {
-    return "";
-  }
-}
-function isOwnedOmniusDaemon(pid, daemonPid) {
-  if (pid === daemonPid) return true;
-  if (listProcessLeases({ includeInactive: false }).some((lease) => lease.pid === pid && lease.ownerKind === "daemon")) {
-    return true;
-  }
-  const command = processCommandLine(pid);
-  return /(?:^|[\\/\s])omnius(?:[\\/\s]|$)|omnius-daemon|[\\/]dist[\\/]index\.js\b|launcher\.cjs\b/i.test(command);
-}
-async function ownedDaemonPids(port) {
-  const daemonPid = getDaemonPid();
-  const candidates = /* @__PURE__ */ new Set();
-  if (daemonPid) candidates.add(daemonPid);
-  const holders = await portHolderPids(port);
-  for (const pid of holders ?? []) candidates.add(pid);
-  return [...candidates].filter((pid) => processIsAlive(pid) && isOwnedOmniusDaemon(pid, daemonPid));
+async function daemonPortIsFree(port) {
+  return new Promise((resolve87) => {
+    const probe = createNetServer();
+    let settled = false;
+    const finish = (free) => {
+      if (settled) return;
+      settled = true;
+      resolve87(free);
+    };
+    probe.once("error", () => finish(false));
+    probe.once("listening", () => {
+      probe.close(() => finish(true));
+    });
+    probe.listen(port, "127.0.0.1");
+    probe.unref();
+  });
 }
 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);
-    if (!healthy && (holders === null || holders.length === 0)) return true;
+    const portFree = holders === null ? await daemonPortIsFree(port) : holders.length === 0;
+    if (!healthy && portFree) return true;
     await delay3(500);
   }
   return false;
 }
-async function gracefullyStopOwnedDaemon(port) {
-  const pids = await ownedDaemonPids(port);
-  for (const pid of pids) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
+async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies = DEFAULT_RECLAIM_DEPENDENCIES) {
+  const holders = await dependencies.holderPids(port);
+  if (holders === null) {
+    if (await dependencies.portIsFree(port)) {
+      return { ok: true, action: "free", port, clearedPids: [], blockedPids: [] };
     }
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids: [],
+      reason: "Could not identify the process holding the daemon port"
+    };
   }
-  if (await waitForDaemonStopped(port)) return true;
-  const survivors = await ownedDaemonPids(port);
-  for (const pid of survivors) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
+  const uniqueHolders = [...new Set(holders.filter((pid) => pid > 0 && pid !== process.pid))];
+  if (uniqueHolders.length === 0) {
+    if (await dependencies.portIsFree(port)) {
+      return { ok: true, action: "free", port, clearedPids: [], blockedPids: [] };
+    }
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids: [],
+      reason: "Daemon port is occupied but its holder could not be verified"
+    };
+  }
+  const ownerId = `daemon:${port}`;
+  const activeLeases = dependencies.leases().filter(
+    (lease) => lease.status === "active" && lease.ownerKind === "daemon" && lease.ownerId === ownerId && uniqueHolders.includes(lease.pid)
+  );
+  const leasesByPid = new Map(activeLeases.map((lease) => [lease.pid, lease]));
+  const blockedPids = uniqueHolders.filter((pid) => !leasesByPid.has(pid));
+  if (blockedPids.length > 0) {
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids,
+      reason: "Port holder is not an identity-verified Omnius daemon lease"
+    };
+  }
+  const clearedPids = [];
+  for (const pid of uniqueHolders) {
+    const lease = leasesByPid.get(pid);
+    const stopped = await dependencies.stopLease(lease.leaseId);
+    if (stopped.action !== "killed" && stopped.action !== "dead") {
+      return {
+        ok: false,
+        action: "failed",
+        port,
+        clearedPids,
+        blockedPids: [pid],
+        reason: stopped.reason || "Daemon lease identity could not be verified"
+      };
     }
+    clearedPids.push(pid);
   }
-  return waitForDaemonStopped(port, 10);
+  if (!await dependencies.waitForFree(port)) {
+    return {
+      ok: false,
+      action: "failed",
+      port,
+      clearedPids,
+      blockedPids: [],
+      reason: "Verified daemon stopped but the port did not become free"
+    };
+  }
+  return { ok: true, action: "cleared", port, clearedPids, blockedPids: [] };
 }
 async function restartDaemon(port, expectedVersion) {
   const p2 = port ?? getDaemonPort();
@@ -678417,9 +678535,15 @@ async function restartDaemon(port, expectedVersion) {
       if (started.ok && (await waitForDaemonReady(p2, expectedVersion)).ok) return true;
     }
     await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (!await waitForDaemonStopped(p2)) return false;
+    if (!await waitForDaemonStopped(p2)) {
+      const reclaimed = await reclaimOwnedDaemonListener(p2);
+      if (!reclaimed.ok) return false;
+    }
+  }
+  if (await isDaemonRunning(p2)) {
+    const reclaimed = await reclaimOwnedDaemonListener(p2);
+    if (!reclaimed.ok) return false;
   }
-  if (await isDaemonRunning(p2) && !await gracefullyStopOwnedDaemon(p2)) return false;
   const pid = await startDaemon(p2);
   if (!pid) return false;
   return (await waitForDaemonReady(p2, expectedVersion)).ok;
@@ -678496,7 +678620,7 @@ async function startDaemon(port = getDaemonPort()) {
     outFd = openSync4(join128(OMNIUS_DIR, "daemon.log"), "a");
     errFd = openSync4(join128(OMNIUS_DIR, "daemon.err.log"), "a");
     const leaseId = newProcessLeaseId("daemon");
-    const ownerId = `daemon:${getDaemonPort()}`;
+    const ownerId = `daemon:${daemonPort}`;
     const child = spawn28(daemonCommand.command, daemonCommand.args, {
       detached: true,
       stdio: ["ignore", outFd, errFd],
@@ -678670,17 +678794,17 @@ async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port
     }
     return finish(true, "unchanged", await getDaemonReportedVersion(port));
   }
-  const stalePid = getDaemonPid();
-  if (stalePid) {
-    try {
-      process.kill(stalePid, "SIGTERM");
-    } catch {
-    }
-    try {
-      unlinkSync22(PID_FILE);
-    } catch {
-    }
+  const reclaimed = await reclaimOwnedDaemonListener(port);
+  if (!reclaimed.ok) {
+    return finish(
+      false,
+      "failed",
+      null,
+      0,
+      process.platform === "linux" && reclaimed.action === "blocked"
+    );
   }
+  getDaemonPid();
   const pid = await startDaemon(port);
   if (!pid) {
     for (let i2 = 0; i2 < 20; i2++) {
@@ -678728,7 +678852,7 @@ async function getDaemonStatus() {
   }
   return { running, pid, port, uptime: uptime2, pidFile: PID_FILE };
 }
-var OMNIUS_DIR, PID_FILE, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS, DAEMON_VERSION_RECOVERY_ATTEMPTS, DAEMON_GRACEFUL_STOP_ATTEMPTS;
+var OMNIUS_DIR, PID_FILE, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS, DAEMON_VERSION_RECOVERY_ATTEMPTS, DAEMON_GRACEFUL_STOP_ATTEMPTS, DEFAULT_RECLAIM_DEPENDENCIES;
 var init_daemon = __esm({
   "packages/cli/src/daemon.ts"() {
     init_dist5();
@@ -678738,6 +678862,16 @@ var init_daemon = __esm({
     LOCK_INITIALIZATION_GRACE_MS = 5e3;
     DAEMON_VERSION_RECOVERY_ATTEMPTS = 2;
     DAEMON_GRACEFUL_STOP_ATTEMPTS = 20;
+    DEFAULT_RECLAIM_DEPENDENCIES = {
+      holderPids: (port) => portHolderPids(port),
+      portIsFree: (port) => daemonPortIsFree(port),
+      leases: () => listProcessLeases({ includeInactive: false }),
+      stopLease: (leaseId) => stopProcessLease(leaseId, {
+        reason: "stale daemon listener reclaim",
+        termGraceMs: 1e3
+      }),
+      waitForFree: (port) => waitForDaemonStopped(port)
+    };
   }
 });
 
@@ -678757,6 +678891,7 @@ __export(tray_exports, {
   runTrayForeground: () => runTrayForeground,
   startTray: () => startTray,
   stopTray: () => stopTray,
+  trayRequiresRestart: () => trayRequiresRestart,
   traySupport: () => traySupport,
   trayUpdatePresentation: () => trayUpdatePresentation,
   uninstallTrayAutostart: () => uninstallTrayAutostart,
@@ -679149,7 +679284,7 @@ start "" /b ${argv.map(windowsCmdQuote).join(" ")}\r
   }
   throw new Error(`Autostart is not supported on ${platform8}`);
 }
-function installTrayAutostart(endpoint) {
+function writeTrayAutostart(endpoint) {
   const launch = resolveTrayLaunchCommand();
   if (!launch) throw new Error("Could not resolve the installed Omnius CLI entrypoint");
   const paths = resolveTrayPaths();
@@ -679159,11 +679294,15 @@ function installTrayAutostart(endpoint) {
     buildAutostartContent(process.platform, launch, endpoint, assetPath("online")),
     { encoding: "utf8", mode: process.platform === "win32" ? 448 : 384 }
   );
+  return paths.autostartFile;
+}
+function installTrayAutostart(endpoint) {
+  const autostartFile = writeTrayAutostart(endpoint);
   if (process.platform === "darwin" && typeof process.getuid === "function") {
     spawnSync9("launchctl", ["bootout", `gui/${process.getuid()}/ai.omnius.tray`], { stdio: "ignore" });
-    spawnSync9("launchctl", ["bootstrap", `gui/${process.getuid()}`, paths.autostartFile], { stdio: "ignore" });
+    spawnSync9("launchctl", ["bootstrap", `gui/${process.getuid()}`, autostartFile], { stdio: "ignore" });
   }
-  return paths.autostartFile;
+  return autostartFile;
 }
 function uninstallTrayAutostart() {
   const paths = resolveTrayPaths();
@@ -679295,11 +679434,15 @@ async function getTrayStatus(explicitEndpoint) {
   }
   const state = readProcessState(paths.stateFile);
   const support = traySupport();
+  const requestedEndpoint = resolveTrayEndpoint(explicitEndpoint);
   return {
     running,
     ready: running && Boolean(state?.ready),
     pid: running ? pid : null,
-    endpoint: state?.endpoint || resolveTrayEndpoint(explicitEndpoint),
+    // A stopped indicator's cached state must not override an explicitly
+    // requested endpoint. This previously kept resurrecting an obsolete
+    // custom port (for example 11535) after the daemon had returned to 11435.
+    endpoint: running || !explicitEndpoint ? state?.endpoint || requestedEndpoint : requestedEndpoint,
     registered: existsSync117(paths.autostartFile),
     registrationFile: paths.autostartFile,
     ...state?.health ? { health: state.health } : {},
@@ -679308,16 +679451,26 @@ async function getTrayStatus(explicitEndpoint) {
     ...state?.error ? { error: state.error } : {}
   };
 }
+function trayRequiresRestart(existing, endpoint, liveHealth) {
+  return existing.endpoint !== endpoint || !existing.ready || Boolean(existing.error) || existing.health?.kind !== liveHealth.kind || existing.health?.version !== liveHealth.version;
+}
 async function startTray(explicitEndpoint) {
-  const existing = await getTrayStatus(explicitEndpoint);
-  if (existing.running) return existing;
+  const endpoint = resolveTrayEndpoint(explicitEndpoint);
+  const existing = await getTrayStatus(endpoint);
+  if (existing.running) {
+    const liveHealth = await pollTrayHealth(endpoint);
+    if (!trayRequiresRestart(existing, endpoint, liveHealth)) {
+      return { ...existing, health: liveHealth };
+    }
+    await stopTray();
+  }
   const support = traySupport();
   if (!support.supported) throw new Error(support.reason || "Tray is not supported on this host");
   verifyTrayHelper();
   const launch = resolveTrayLaunchCommand();
   if (!launch) throw new Error("Could not resolve the installed Omnius CLI entrypoint");
-  const endpoint = resolveTrayEndpoint(explicitEndpoint);
   const paths = resolveTrayPaths();
+  if (existing.registered) writeTrayAutostart(endpoint);
   mkdirSync70(paths.stateDir, { recursive: true, mode: 448 });
   mkdirSync70(paths.runtimeDir, { recursive: true, mode: 448 });
   try {
@@ -724408,7 +724561,15 @@ var indicator_command_exports = {};
 __export(indicator_command_exports, {
   runIndicatorCommand: () => runIndicatorCommand
 });
-function formatIndicatorStatus(status) {
+async function waitForOnlineHealth(endpoint, operations, attempts = 5) {
+  let health = await operations.health(endpoint);
+  for (let attempt = 1; health.kind !== "online" && attempt < attempts; attempt++) {
+    await operations.wait(200);
+    health = await operations.health(endpoint);
+  }
+  return health;
+}
+function formatIndicatorStatus(status, daemon) {
   const state = status.running ? status.ready ? "ready" : "starting" : "stopped";
   const pid = status.pid ? ` (PID ${status.pid})` : "";
   const health = status.health?.label ?? "not checked";
@@ -724419,6 +724580,12 @@ function formatIndicatorStatus(status) {
     `Endpoint: ${status.endpoint}.`,
     `Autostart: ${autostart}.`
   ];
+  if (daemon) {
+    const version5 = daemon.observedVersion ?? daemon.expectedVersion;
+    parts.push(
+      `Daemon: ${daemon.action}${version5 ? ` (v${version5})` : ""} on port ${daemon.port}.`
+    );
+  }
   if (status.error) parts.push(`Error: ${status.error}`);
   return parts.join(" ");
 }
@@ -724431,9 +724598,42 @@ async function runIndicatorCommand(rawAction, operations = DEFAULT_OPERATIONS) {
     };
   }
   try {
-    const status = action === "status" ? await operations.status() : await operations.start();
-    const level = status.error ? "error" : status.running && status.ready ? "info" : status.running ? "warning" : action === "start" ? "error" : "warning";
-    return { level, message: formatIndicatorStatus(status), status };
+    if (action === "status") {
+      const cached2 = await operations.status();
+      const health2 = await operations.health(cached2.endpoint);
+      const status2 = { ...cached2, health: health2 };
+      const level2 = status2.error ? "error" : status2.running && status2.ready && health2.kind === "online" ? "info" : "warning";
+      return { level: level2, message: formatIndicatorStatus(status2), status: status2 };
+    }
+    const daemon = await operations.ensureDaemon();
+    if (!daemon.ok) {
+      const observed = daemon.observedVersion ? `; observed v${daemon.observedVersion}` : "";
+      const migration = daemon.requiresPrivilegedMigration ? " Privileged service migration is required; run /daemon takeover." : "";
+      return {
+        level: "error",
+        message: `Indicator not started: daemon reconciliation failed on port ${daemon.port}${observed}.${migration}`,
+        daemon
+      };
+    }
+    const endpoint = `http://127.0.0.1:${daemon.port}`;
+    const daemonHealth = await waitForOnlineHealth(endpoint, operations);
+    if (daemonHealth.kind !== "online") {
+      return {
+        level: "error",
+        message: `Indicator not started: daemon did not become online at ${endpoint}. ` + daemonHealth.tooltip,
+        daemon
+      };
+    }
+    const started = await operations.start(endpoint);
+    const health = await waitForOnlineHealth(endpoint, operations);
+    const status = { ...started, endpoint, health };
+    const level = status.error ? "error" : status.running && status.ready && health.kind === "online" ? "info" : "error";
+    return {
+      level,
+      message: formatIndicatorStatus(status, daemon),
+      status,
+      daemon
+    };
   } catch (error) {
     return {
       level: "error",
@@ -724445,9 +724645,13 @@ var DEFAULT_OPERATIONS;
 var init_indicator_command = __esm({
   "packages/cli/src/tui/indicator-command.ts"() {
     init_tray();
+    init_daemon();
     DEFAULT_OPERATIONS = {
-      start: () => startTray(),
-      status: () => getTrayStatus()
+      ensureDaemon: () => ensureDaemonVersion(),
+      start: (endpoint) => startTray(endpoint),
+      status: () => getTrayStatus(),
+      health: (endpoint) => pollTrayHealth(endpoint),
+      wait: (ms) => new Promise((resolve87) => setTimeout(resolve87, ms))
     };
   }
 });

package/docs/guides/system-tray.md

@@ -25,6 +25,12 @@ From an active Omnius TUI, use the local slash command instead:
 start/stop/restart lifecycle remain available through the top-level
 `omnius tray` command.
 
+`/indicator` first reconciles the current Omnius daemon on its configured
+loopback port (11435 by default), waits for verified online health, repairs a
+stale tray endpoint/autostart registration, and only then starts the native
+indicator. Untracked processes occupying the port are reported as blockers and
+are never terminated automatically.
+
 The indicator polls the daemon's loopback-only `GET /health` route. It does not
 load a model or contact the configured inference backend. If the daemon uses a
 non-default port, Omnius discovers `OMNIUS_HOST`/`OMNIUS_PORT` from the current

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.598",
+  "version": "1.0.600",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.598",
+      "version": "1.0.600",
       "bundleDependencies": [
         "image-to-ascii"
       ],
@@ -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.598",
+  "version": "1.0.600",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",