omnius 1.0.599 → 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) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.599",
+  "version": "1.0.600",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.599",
+      "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.599",
+  "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",