sift-light 1.1.0 → 1.1.1-2

package/src/evidence-service.ts

@@ -1012,7 +1012,7 @@ export class EvidenceService {
       if (selected.unverified)
         throw new SiftLightError("Snapshot source revision is unverified; refresh the search");
       if (selected.expectedRevision) {
-        const doc = await access.load(path);
+        const doc = await access.load(path, selected.reference);
         if (
           doc.reference.origin.kind !== "worktree" ||
           !sameSourceRevision(selected.expectedRevision, doc.reference.origin.revision)

package/src/evidence-validation.ts

@@ -9,7 +9,7 @@ import { SourceAccess, SourceBudgetError, SyntaxQueue } from "./source-access.js
 import { SourceDocumentError, type SourceReference } from "./source-document.js";
 import { SnapshotStore } from "./snapshot-store.js";
 import type { AnalysisItem } from "./analysis-types.js";
-import type { SearchRequest, SearchScopeDetails, SearchSnapshot, SourceRevision } from "./types.js";
+import type { SearchRequest, SearchScopeDetails, SearchSnapshot } from "./types.js";
 import type {
   EvidenceCoverageStatus,
   EvidenceComparisonTarget,
@@ -46,7 +46,6 @@ interface ValidationTarget {
   key: string;
   path: string;
   expected?: SourceReference;
-  revision?: SourceRevision;
 }
 
 interface ClassifiedFailure {
@@ -156,10 +155,6 @@ function sourceKey(reference: SourceReference): string {
   return JSON.stringify([reference.path, reference.origin]);
 }
 
-function revisionKey(path: string, revision: SourceRevision): string {
-  return JSON.stringify([path, revision]);
-}
-
 function selectedIndex(
   index: number | undefined,
   count: number,
@@ -231,8 +226,8 @@ function snapshotTargets(
   const missing: EvidenceSourceStatus[] = [];
   const seen = new Set<string>();
   for (const path of selectedPaths) {
-    const revision = snapshot.sourceRevisions.get(path);
-    if (!revision) {
+    const reference = snapshot.sourceReferences?.get(path);
+    if (!reference) {
       const key = JSON.stringify(["missing", path]);
       if (!seen.has(key)) {
         seen.add(key);
@@ -240,82 +235,20 @@ function snapshotTargets(
           path,
           role: "source",
           status: "unknown",
-          reason: "Saved search has no source revision",
+          reason: "Saved search has no verified source content identity",
         });
       }
       continue;
     }
     addUniqueTarget(targets, seen, {
-      key: revisionKey(path, revision),
+      key: sourceKey(reference),
       path,
-      revision,
+      expected: reference,
     });
   }
   return { targets, missing };
 }
 
-async function validateSnapshotTarget(
-  target: ValidationTarget,
-  cwd: string,
-  policy: SearchPathPolicy,
-  signal?: AbortSignal,
-): Promise<EvidenceSourceStatus> {
-  if (!target.revision) throw new Error("Snapshot validation target omitted its revision");
-  try {
-    const absolute = resolve(cwd, target.path);
-    const canonical = await policy.resolveExistingPath(absolute);
-    if (!canonical) {
-      const result = await confirmWorktreeState(target.path, cwd, signal);
-      return { path: target.path, role: "source", ...result };
-    }
-    const before = await stat(absolute);
-    const beforeCanonical = canonical;
-    const after = await stat(absolute);
-    const afterCanonical = await realpath(absolute);
-    if (!before.isFile() || !after.isFile()) {
-      return {
-        path: target.path,
-        role: "source",
-        status: "stale",
-        reason: "Source is no longer a regular file",
-      };
-    }
-    if (
-      beforeCanonical !== afterCanonical ||
-      !sameSourceRevision(sourceRevisionFromStats(before), sourceRevisionFromStats(after))
-    ) {
-      return {
-        path: target.path,
-        role: "source",
-        status: "stale",
-        reason: "Source changed while checking its revision",
-      };
-    }
-    const current = sourceRevisionFromStats(after);
-    const unchanged = sameSourceRevision(target.revision, current);
-    return {
-      path: target.path,
-      role: "source",
-      status: unchanged ? "current" : "stale",
-      ...(unchanged ? {} : { reason: "Source revision changed" }),
-    };
-  } catch (error) {
-    if (isAbort(error, signal)) throw error;
-    const code = systemErrorCode(error);
-    if (code === "ENOENT") {
-      const classified = await confirmWorktreeState(target.path, cwd, signal);
-      return { path: target.path, role: "source", ...classified };
-    }
-    const classified = await failure(error, undefined, target.path, cwd, signal);
-    return {
-      path: target.path,
-      role: "source",
-      status: classified.status,
-      reason: classified.reason,
-    };
-  }
-}
-
 async function validateAnalysisTarget(
   target: ValidationTarget,
   access: SourceAccess,
@@ -426,13 +359,16 @@ export async function validateSavedEvidence(
     const selected = snapshotTargets(snapshot, options.matchIndex);
     targets = selected.targets;
     missing.push(...selected.missing);
-    const policy = new SearchPathPolicy(options.cwd);
     sources = [...missing];
-    let checked = 0;
     const maxFiles = options.maxFiles ?? MAX_STRUCTURE_FILES;
+    const access = new SourceAccess(options.cwd, options.queue, options.signal, {
+      maxFiles,
+    });
+    let checked = 0;
+    let budgetExhausted = false;
     for (const target of targets) {
       if (options.signal?.aborted) throw abortError();
-      if (checked >= maxFiles) {
+      if (budgetExhausted || checked >= maxFiles) {
         sources.push({
           path: target.path,
           role: "source",
@@ -442,7 +378,10 @@ export async function validateSavedEvidence(
         continue;
       }
       checked += 1;
-      sources.push(await validateSnapshotTarget(target, options.cwd, policy, options.signal));
+      const status = await validateAnalysisTarget(target, access, options.cwd, options.signal);
+      const { budgetReached, ...sourceStatus } = status;
+      sources.push(sourceStatus);
+      if (budgetReached) budgetExhausted = true;
     }
   }
 

package/src/inspect.ts

@@ -7,10 +7,12 @@ import {
   getSourceRevision,
   readSourceRange,
   sameSourceRevision,
+  sourceRangeFromBytes,
   SourceBudgetTooSmallError,
   SourceTooLargeError,
   type SourceRangeRead,
 } from "./source.js";
+import { readWorkspaceDocument, type SourceReference } from "./source-document.js";
 import { SnapshotStore } from "./snapshot-store.js";
 import {
   MAX_LINE_CHARACTERS,
@@ -40,6 +42,7 @@ export interface InspectionTarget {
   absolutePath: string;
   line: number;
   retainedMatch?: MatchRecord;
+  expectedReference?: SourceReference;
   expectedRevision?: SourceRevision;
   unverified: boolean;
 }
@@ -87,6 +90,7 @@ export function resolveInspectionTarget(
   const absolutePath = retainedMatch?.absolutePath ?? resolve(cwd, path);
   new SearchPathPolicy(cwd).assertPath(absolutePath);
   let expectedRevision: SourceRevision | undefined;
+  let expectedReference: SourceReference | undefined;
   if (input.cursor) {
     const { snapshot } = snapshots.resolve(input.cursor);
     retainedMatch ??= snapshot.matches.find(
@@ -96,13 +100,17 @@ export function resolveInspectionTarget(
       throw new CursorError("The requested line is not a retained match in this snapshot.");
     }
     expectedRevision = snapshot.sourceRevisions.get(absolutePath);
+    expectedReference = snapshot.sourceReferences?.get(absolutePath);
   }
   return {
     path,
     absolutePath,
     line,
-    unverified: input.cursor !== undefined && expectedRevision === undefined,
+    unverified:
+      input.cursor !== undefined &&
+      (expectedReference === undefined || expectedRevision === undefined),
     ...(retainedMatch ? { retainedMatch } : {}),
+    ...(expectedReference ? { expectedReference } : {}),
     ...(expectedRevision ? { expectedRevision } : {}),
   };
 }
@@ -209,19 +217,40 @@ export async function inspectSourceEvidence(
     endLine: target.line + 10,
   };
   try {
-    evidence.source = await readSourceRange(
-      target.absolutePath,
-      range.startLine,
-      range.endLine,
-      signal,
-      target.line,
-      {
-        maxBytes,
-        ...(target.retainedMatch?.occurrences[0]
-          ? { focus: target.retainedMatch.occurrences[0] }
-          : {}),
-      },
-    );
+    if (target.expectedReference) {
+      const document = await readWorkspaceDocument(
+        target.path,
+        cwd,
+        signal,
+        target.expectedReference.origin,
+      );
+      evidence.source = sourceRangeFromBytes(
+        document.bytes,
+        range.startLine,
+        range.endLine,
+        target.line,
+        {
+          maxBytes,
+          ...(target.retainedMatch?.occurrences[0]
+            ? { focus: target.retainedMatch.occurrences[0] }
+            : {}),
+        },
+      );
+    } else {
+      evidence.source = await readSourceRange(
+        target.absolutePath,
+        range.startLine,
+        range.endLine,
+        signal,
+        target.line,
+        {
+          maxBytes,
+          ...(target.retainedMatch?.occurrences[0]
+            ? { focus: target.retainedMatch.occurrences[0] }
+            : {}),
+        },
+      );
+    }
   } catch (error) {
     if (signal?.aborted || (error instanceof Error && error.name === "AbortError"))
       throw abortError();