@gmickel/gno 1.34.5 → 1.35.0

package/src/ingestion/sync.ts

@@ -69,6 +69,19 @@ import {
 } from "./frontmatter";
 import { buildLineOffsets } from "./position";
 import { processRecordContainer } from "./record-container";
+import {
+  createDirectoryAvailability,
+  createSourceContentReader,
+  findUnprovenAvailabilityPrefix,
+  isSourceAvailabilitySkip,
+  isUnprovenAbsenceCode,
+  memoizeDirectoryAvailability,
+  relPathUnderAnyPrefix,
+  resolveSourceAvailability,
+  type DirectoryAvailabilityPort,
+  type SourceContentReaderPort,
+  type SourceReadFailure,
+} from "./source-availability";
 import { getExcludedRanges } from "./strip";
 import { collectionToWalkConfig, DEFAULT_CHUNK_PARAMS } from "./types";
 import { defaultWalker } from "./walker";
@@ -616,6 +629,31 @@ class Semaphore {
   }
 }
 
+function summarizePathResults(
+  collection: string,
+  results: FileSyncResult[],
+  markedInactive: number,
+  startedAt: number,
+  errors: CollectionSyncResult["errors"]
+): CollectionSyncResult {
+  return {
+    collection,
+    filesProcessed: results.length,
+    filesAdded: results.filter((result) => result.status === "added").length,
+    filesUpdated: results.filter((result) => result.status === "updated")
+      .length,
+    filesUnchanged: results.filter((result) => result.status === "unchanged")
+      .length,
+    filesErrored: results.filter((result) => result.status === "error").length,
+    filesSkipped: results.filter((result) => result.status === "skipped")
+      .length,
+    filesMarkedInactive: markedInactive,
+    durationMs: Date.now() - startedAt,
+    files: results,
+    errors,
+  };
+}
+
 /**
  * Sync service implementation.
  */
@@ -624,17 +662,32 @@ export class SyncService {
   private readonly chunker: ChunkerPort;
   private readonly mimeDetector: MimeDetector;
   private readonly pipeline: ConversionPipeline;
+  private readonly sourceReaderFactory: (
+    mode: "any" | "local"
+  ) => SourceContentReaderPort;
+  private readonly directoryAvailabilityFactory: (
+    mode: "any" | "local"
+  ) => DirectoryAvailabilityPort;
 
   constructor(
     walker?: WalkerPort,
     chunker?: ChunkerPort,
     mimeDetector?: MimeDetector,
-    pipeline?: ConversionPipeline
+    pipeline?: ConversionPipeline,
+    sourceReaderFactory?: (mode: "any" | "local") => SourceContentReaderPort,
+    directoryAvailabilityFactory?: (
+      mode: "any" | "local"
+    ) => DirectoryAvailabilityPort
   ) {
     this.walker = walker ?? defaultWalker;
     this.chunker = chunker ?? defaultChunker;
     this.mimeDetector = mimeDetector ?? getDefaultMimeDetector();
     this.pipeline = pipeline ?? getDefaultPipeline();
+    this.sourceReaderFactory =
+      sourceReaderFactory ?? ((mode) => createSourceContentReader(mode));
+    this.directoryAvailabilityFactory =
+      directoryAvailabilityFactory ??
+      ((mode) => createDirectoryAvailability(mode));
   }
 
   private async selectRecordAdapter(
@@ -741,6 +794,28 @@ export class SyncService {
       const contentTypeRulesFingerprint =
         options.contentTypeRulesFingerprint ??
         fingerprintContentTypeMetadataRules(contentTypeRules);
+
+      // 2. Local mode performs one guarded content-boundary read. `any` keeps
+      // the legacy record-stream and sniff/read paths byte-for-byte unchanged.
+      // No availability syscall is added during discovery.
+      const availabilityMode = resolveSourceAvailability(collection, options);
+      let guardedBytes: Uint8Array | undefined;
+      if (availabilityMode === "local") {
+        const sourceRead = await this.sourceReaderFactory("local").readAll(
+          entry.absPath,
+          sourceSize
+        );
+        if (!sourceRead.ok) {
+          return await this.finishSourceAvailabilityFailure(
+            collection,
+            entry,
+            store,
+            sourceRead
+          );
+        }
+        guardedBytes = sourceRead.bytes;
+      }
+
       if (recordAdapter) {
         return await processRecordContainer({
           adapter: recordAdapter,
@@ -757,13 +832,16 @@ export class SyncService {
           sourceCtime,
           sourceMtime,
           sourceSize,
+          sourceBytes: guardedBytes,
           store,
         });
       }
 
-      const sniffBytes = new Uint8Array(
-        await Bun.file(entry.absPath).slice(0, 512).arrayBuffer()
-      );
+      const sniffBytes = guardedBytes
+        ? guardedBytes.subarray(0, Math.min(512, guardedBytes.byteLength))
+        : new Uint8Array(
+            await Bun.file(entry.absPath).slice(0, 512).arrayBuffer()
+          );
       const mime = this.mimeDetector.detect(entry.relPath, sniffBytes);
 
       const priorRecordDocuments = mustOk(
@@ -772,10 +850,9 @@ export class SyncService {
         { collection: collection.name, relPath: entry.relPath }
       );
 
-      // 2. Read byte-oriented files only after record-adapter selection.
-      const bytes = await Bun.file(entry.absPath).bytes();
+      const bytes = guardedBytes ?? (await Bun.file(entry.absPath).bytes());
 
-      // 3. Compute sourceHash
+      // 3. Compute sourceHash from source bytes. Local mode cannot reopen.
       const hasher = new Bun.CryptoHasher("sha256");
       hasher.update(bytes);
       const sourceHash = hasher.digest("hex");
@@ -1127,6 +1204,38 @@ export class SyncService {
     }
   }
 
+  /**
+   * Translate guarded-read failures into skip (cloud placeholder/partial) or
+   * fail-closed error outcomes. Never surfaces materialization refusal as a
+   * conversion error.
+   */
+  private async finishSourceAvailabilityFailure(
+    collection: Collection,
+    entry: WalkEntry,
+    store: StorePort,
+    failure: SourceReadFailure
+  ): Promise<FileSyncResult> {
+    const status = isSourceAvailabilitySkip(failure.code) ? "skipped" : "error";
+    await store
+      .recordError({
+        collection: collection.name,
+        relPath: entry.relPath,
+        code: failure.code,
+        message: failure.message,
+        details:
+          failure.errno === undefined || failure.errno === null
+            ? undefined
+            : { errno: failure.errno },
+      })
+      .catch(() => undefined);
+    return {
+      relPath: entry.relPath,
+      status,
+      errorCode: failure.code,
+      errorMessage: failure.message,
+    };
+  }
+
   private async readPreviousStructure(
     store: StorePort,
     existing: DocumentRow | null
@@ -1161,6 +1270,54 @@ export class SyncService {
     return result.files ?? [];
   }
 
+  /**
+   * Inactivate proven-absent index sources without requiring disk absence.
+   * Used when classification proves a path is no longer an eligible file
+   * source even if a directory/FIFO/device now occupies the path.
+   * Preserves record-container fan-out and typed-edge projection.
+   */
+  async inactivateAbsentSources(
+    collection: Collection,
+    store: StorePort,
+    relPaths: string[],
+    options: SyncOptions = {}
+  ): Promise<CollectionSyncResult> {
+    const startedAt = Date.now();
+    const syncOptions: SyncOptions = {
+      ...options,
+      contentTypeRules: options.contentTypeRules ?? [],
+      contentTypeRulesFingerprint:
+        options.contentTypeRulesFingerprint ??
+        fingerprintContentTypeMetadataRules(options.contentTypeRules ?? []),
+    };
+    const results: FileSyncResult[] = [];
+    const projectionSourceIds = new Set<number>();
+    let markedInactive = 0;
+
+    for (const relPath of relPaths) {
+      const outcome = await this.inactivateOneAbsentSource(
+        collection,
+        store,
+        relPath,
+        projectionSourceIds
+      );
+      results.push(outcome.result);
+      markedInactive += outcome.markedInactive;
+    }
+
+    const errors =
+      syncOptions.projectTypedEdges === false
+        ? []
+        : await this.projectTypedEdges(store, syncOptions, projectionSourceIds);
+    return summarizePathResults(
+      collection.name,
+      results,
+      markedInactive,
+      startedAt,
+      errors
+    );
+  }
+
   async syncPaths(
     collection: Collection,
     store: StorePort,
@@ -1178,6 +1335,10 @@ export class SyncService {
     const results: FileSyncResult[] = [];
     const projectionSourceIds = new Set<number>();
     let markedInactive = 0;
+    const availabilityMode = resolveSourceAvailability(collection, syncOptions);
+    const directoryAvailability = memoizeDirectoryAvailability(
+      this.directoryAvailabilityFactory(availabilityMode)
+    );
 
     for (const relPath of relPaths) {
       const recordDocumentsResult = await store.listRecordDocuments(
@@ -1195,20 +1356,79 @@ export class SyncService {
       }
       const recordDocuments = recordDocumentsResult.value;
       const existingResult = await store.getDocument(collection.name, relPath);
-      const existingDoc = existingResult.ok ? existingResult.value : null;
+      if (!existingResult.ok) {
+        results.push({
+          relPath,
+          status: "error",
+          errorCode: existingResult.error.code,
+          errorMessage: existingResult.error.message,
+        });
+        continue;
+      }
+      const existingDoc = existingResult.value;
       if (existingDoc) {
-        await this.collectProjectionSourceIds(
+        const collectError = await this.collectProjectionSourceIds(
           store,
           existingDoc.id,
           projectionSourceIds
         );
+        if (collectError) {
+          results.push({
+            relPath,
+            status: "error",
+            errorCode: collectError.code,
+            errorMessage: collectError.message,
+          });
+          continue;
+        }
       }
+      let recordCollectFailed: FileSyncResult | null = null;
       for (const recordDocument of recordDocuments) {
-        await this.collectProjectionSourceIds(
+        const collectError = await this.collectProjectionSourceIds(
           store,
           recordDocument.id,
           projectionSourceIds
         );
+        if (collectError) {
+          recordCollectFailed = {
+            relPath,
+            status: "error",
+            errorCode: collectError.code,
+            errorMessage: collectError.message,
+          };
+          break;
+        }
+      }
+      if (recordCollectFailed) {
+        results.push(recordCollectFailed);
+        continue;
+      }
+
+      // Direct syncPaths must not bypass directory-availability guards.
+      const unprovenPrefix = await findUnprovenAvailabilityPrefix(
+        collection.path,
+        relPath,
+        directoryAvailability
+      );
+      if (unprovenPrefix) {
+        const status = isSourceAvailabilitySkip(unprovenPrefix.code)
+          ? "skipped"
+          : "error";
+        await store
+          .recordError({
+            collection: collection.name,
+            relPath: unprovenPrefix.relPath || relPath,
+            code: unprovenPrefix.code,
+            message: unprovenPrefix.message,
+          })
+          .catch(() => undefined);
+        results.push({
+          relPath,
+          status,
+          errorCode: unprovenPrefix.code,
+          errorMessage: unprovenPrefix.message,
+        });
+        continue;
       }
 
       const absPath = join(collection.path, relPath);
@@ -1230,39 +1450,15 @@ export class SyncService {
           });
           continue;
         }
-        const activePaths = [
-          ...(existingDoc?.active ? [relPath] : []),
-          ...recordDocuments
-            .filter((document) => document.active)
-            .map((document) => document.relPath),
-        ];
-        if (activePaths.length > 0) {
-          const inactiveResult = await store.markInactive(
-            collection.name,
-            activePaths
-          );
-          if (!inactiveResult.ok) {
-            results.push({
-              relPath,
-              status: "error",
-              errorCode: inactiveResult.error.code,
-              errorMessage: inactiveResult.error.message,
-            });
-            continue;
-          }
-          markedInactive += inactiveResult.value;
-          results.push({
-            relPath,
-            status: "updated",
-            docid: existingDoc?.docid,
-          });
-          continue;
-        }
-        results.push({
+        const inactive = await this.inactivateOneAbsentSource(
+          collection,
+          store,
           relPath,
-          status: existingDoc ? "unchanged" : "skipped",
-          docid: existingDoc?.docid,
-        });
+          projectionSourceIds,
+          { existingDoc, recordDocuments }
+        );
+        results.push(inactive.result);
+        markedInactive += inactive.markedInactive;
         continue;
       }
 
@@ -1322,28 +1518,67 @@ export class SyncService {
         syncOptions
       );
       results.push(result);
+      if (result.status === "error" || result.status === "skipped") {
+        continue;
+      }
+      // Post-write projection identity must succeed so typed-edge cleanup can run.
       const currentResult = await store.getDocument(collection.name, relPath);
-      const currentDoc = currentResult.ok ? currentResult.value : null;
+      if (!currentResult.ok) {
+        results[results.length - 1] = {
+          relPath,
+          status: "error",
+          errorCode: currentResult.error.code,
+          errorMessage: currentResult.error.message,
+        };
+        continue;
+      }
+      const currentDoc = currentResult.value;
       if (currentDoc?.active) {
-        await this.collectProjectionSourceIds(
+        const collectError = await this.collectProjectionSourceIds(
           store,
           currentDoc.id,
           projectionSourceIds
         );
+        if (collectError) {
+          results[results.length - 1] = {
+            relPath,
+            status: "error",
+            errorCode: collectError.code,
+            errorMessage: collectError.message,
+          };
+          continue;
+        }
       }
       const currentDocuments = await store.listRecordDocuments(
         collection.name,
         relPath
       );
-      if (currentDocuments.ok) {
-        for (const recordDocument of currentDocuments.value) {
-          if (recordDocument.active) {
-            await this.collectProjectionSourceIds(
-              store,
-              recordDocument.id,
-              projectionSourceIds
-            );
-          }
+      if (!currentDocuments.ok) {
+        results[results.length - 1] = {
+          relPath,
+          status: "error",
+          errorCode: currentDocuments.error.code,
+          errorMessage: currentDocuments.error.message,
+        };
+        continue;
+      }
+      for (const recordDocument of currentDocuments.value) {
+        if (!recordDocument.active) {
+          continue;
+        }
+        const collectError = await this.collectProjectionSourceIds(
+          store,
+          recordDocument.id,
+          projectionSourceIds
+        );
+        if (collectError) {
+          results[results.length - 1] = {
+            relPath,
+            status: "error",
+            errorCode: collectError.code,
+            errorMessage: collectError.message,
+          };
+          break;
         }
       }
     }
@@ -1352,55 +1587,184 @@ export class SyncService {
       syncOptions.projectTypedEdges === false
         ? []
         : await this.projectTypedEdges(store, syncOptions, projectionSourceIds);
-    const added = results.filter((result) => result.status === "added").length;
-    const updated = results.filter(
-      (result) => result.status === "updated"
-    ).length;
-    const unchanged = results.filter(
-      (result) => result.status === "unchanged"
-    ).length;
-    const errored = results.filter(
-      (result) => result.status === "error"
-    ).length;
-    const skipped = results.filter(
-      (result) => result.status === "skipped"
-    ).length;
+    return summarizePathResults(
+      collection.name,
+      results,
+      markedInactive,
+      startedAt,
+      errors
+    );
+  }
+
+  /**
+   * Soft-delete active docs/record-container children for a proven-absent source.
+   * Does not inspect disk — callers prove absence of an indexable file source.
+   * Store lookup / backlink / mark failures surface as per-file errors (never
+   * silent null/skip) so callers cannot advance snapshot authority.
+   */
+  private async inactivateOneAbsentSource(
+    collection: Collection,
+    store: StorePort,
+    relPath: string,
+    projectionSourceIds: Set<number>,
+    preloaded?: {
+      existingDoc: { id: number; active: boolean; docid?: string } | null;
+      recordDocuments: Array<{ id: number; active: boolean; relPath: string }>;
+    }
+  ): Promise<{ result: FileSyncResult; markedInactive: number }> {
+    let existingDoc = preloaded?.existingDoc ?? null;
+    let recordDocuments = preloaded?.recordDocuments;
 
+    if (!preloaded) {
+      const recordDocumentsResult = await store.listRecordDocuments(
+        collection.name,
+        relPath
+      );
+      if (!recordDocumentsResult.ok) {
+        return {
+          result: {
+            relPath,
+            status: "error",
+            errorCode: recordDocumentsResult.error.code,
+            errorMessage: recordDocumentsResult.error.message,
+          },
+          markedInactive: 0,
+        };
+      }
+      recordDocuments = recordDocumentsResult.value;
+      const existingResult = await store.getDocument(collection.name, relPath);
+      if (!existingResult.ok) {
+        // ok:false is a hard per-file error — never treat as missing/skip.
+        return {
+          result: {
+            relPath,
+            status: "error",
+            errorCode: existingResult.error.code,
+            errorMessage: existingResult.error.message,
+          },
+          markedInactive: 0,
+        };
+      }
+      existingDoc = existingResult.value;
+      if (existingDoc) {
+        const collectError = await this.collectProjectionSourceIds(
+          store,
+          existingDoc.id,
+          projectionSourceIds
+        );
+        if (collectError) {
+          return {
+            result: {
+              relPath,
+              status: "error",
+              errorCode: collectError.code,
+              errorMessage: collectError.message,
+            },
+            markedInactive: 0,
+          };
+        }
+      }
+      for (const recordDocument of recordDocuments) {
+        const collectError = await this.collectProjectionSourceIds(
+          store,
+          recordDocument.id,
+          projectionSourceIds
+        );
+        if (collectError) {
+          return {
+            result: {
+              relPath,
+              status: "error",
+              errorCode: collectError.code,
+              errorMessage: collectError.message,
+            },
+            markedInactive: 0,
+          };
+        }
+      }
+    }
+
+    const docs = recordDocuments ?? [];
+    // Physical source path may own multiple logical docs (record containers).
+    // Deduplicate while preserving the primary source path first.
+    const activePathSet = new Set<string>();
+    if (existingDoc?.active) {
+      activePathSet.add(relPath);
+    }
+    for (const document of docs) {
+      if (document.active) {
+        activePathSet.add(document.relPath);
+      }
+    }
+    const activePaths = [...activePathSet];
+    if (activePaths.length > 0) {
+      const inactiveResult = await store.markInactive(
+        collection.name,
+        activePaths
+      );
+      if (!inactiveResult.ok) {
+        return {
+          result: {
+            relPath,
+            status: "error",
+            errorCode: inactiveResult.error.code,
+            errorMessage: inactiveResult.error.message,
+          },
+          markedInactive: 0,
+        };
+      }
+      return {
+        result: {
+          relPath,
+          status: "updated",
+          docid: existingDoc?.docid,
+        },
+        markedInactive: inactiveResult.value,
+      };
+    }
     return {
-      collection: collection.name,
-      filesProcessed: results.length,
-      filesAdded: added,
-      filesUpdated: updated,
-      filesUnchanged: unchanged,
-      filesErrored: errored,
-      filesSkipped: skipped,
-      filesMarkedInactive: markedInactive,
-      durationMs: Date.now() - startedAt,
-      files: results,
-      errors,
+      result: {
+        relPath,
+        status: existingDoc ? "unchanged" : "skipped",
+        docid: existingDoc?.docid,
+      },
+      markedInactive: 0,
     };
   }
 
+  /**
+   * Collect source doc ids that need typed-edge re-projection after a change.
+   * Backlink lookup failures are fatal for the caller (not silently ignored).
+   */
   private async collectProjectionSourceIds(
     store: StorePort,
     documentId: number,
     sourceIds: Set<number>
-  ): Promise<void> {
+  ): Promise<{ code: string; message: string } | null> {
     sourceIds.add(documentId);
     const [linkBacklinks, edgeBacklinks] = await Promise.all([
       store.getBacklinksForDoc(documentId),
       store.getEdgeBacklinksForDoc(documentId),
     ]);
-    if (linkBacklinks.ok) {
-      for (const backlink of linkBacklinks.value) {
-        sourceIds.add(backlink.sourceDocId);
-      }
+    if (!linkBacklinks.ok) {
+      return {
+        code: linkBacklinks.error.code,
+        message: linkBacklinks.error.message,
+      };
     }
-    if (edgeBacklinks.ok) {
-      for (const backlink of edgeBacklinks.value) {
-        sourceIds.add(backlink.sourceDocId);
-      }
+    if (!edgeBacklinks.ok) {
+      return {
+        code: edgeBacklinks.error.code,
+        message: edgeBacklinks.error.message,
+      };
+    }
+    for (const backlink of linkBacklinks.value) {
+      sourceIds.add(backlink.sourceDocId);
     }
+    for (const backlink of edgeBacklinks.value) {
+      sourceIds.add(backlink.sourceDocId);
+    }
+    return null;
   }
 
   private async projectTypedEdges(
@@ -1441,7 +1805,19 @@ export class SyncService {
     if (selectedSourceIds) {
       for (const documentId of selectedSourceIds) {
         if (!activeIds.has(documentId)) {
-          await store.setDocEdges(documentId, [], "frontmatter-relation");
+          // Clear typed edges for inactivated projection sources.
+          const clearResult = await store.setDocEdges(
+            documentId,
+            [],
+            "frontmatter-relation"
+          );
+          if (!clearResult.ok) {
+            errors.push({
+              relPath: `(doc:${documentId})`,
+              code: clearResult.error.code,
+              message: clearResult.error.message,
+            });
+          }
         }
       }
     }
@@ -1620,23 +1996,44 @@ export class SyncService {
       await gitPull(collection.path);
     }
 
-    // 2. Walk collection
+    // 2. Walk collection (local mode refuses dataless/unproven directory descent)
     const maxBytes = options.limits?.maxBytes ?? DEFAULT_LIMITS.maxBytes;
-    const walkConfig = collectionToWalkConfig(collection, maxBytes);
+    const availabilityMode = resolveSourceAvailability(collection, syncOptions);
+    const directoryAvailability = memoizeDirectoryAvailability(
+      this.directoryAvailabilityFactory(availabilityMode)
+    );
+    const walkConfig = {
+      ...collectionToWalkConfig(collection, maxBytes, syncOptions),
+      sourceAvailability: availabilityMode,
+      directoryAvailability,
+    };
     const { entries, skipped } = await this.walker.walk(walkConfig);
 
     // Track seen paths for marking inactive
     // Only include TOO_LARGE files (they exist but are unprocessable)
     // EXCLUDED files should NOT be in seenPaths - if config changes to exclude
     // a previously-included file, that doc SHOULD be marked inactive
+    // Unproven prefixes (dataless / availability-unknown dirs) preserve
+    // previously indexed descendants — never treat them as proven deletions.
     const seenPaths = new Set<string>();
+    const unprovenPrefixes: string[] = [];
     for (const skip of skipped) {
       if (skip.reason === "TOO_LARGE") {
         seenPaths.add(skip.relPath);
       }
+      if (skip.unprovenPrefix || isUnprovenAbsenceCode(skip.reason)) {
+        unprovenPrefixes.push(skip.relPath);
+      }
     }
 
-    // 3. Record TOO_LARGE errors and track in seenPaths
+    let added = 0;
+    let updated = 0;
+    let unchanged = 0;
+    let errored = 0;
+    let dynamicSkipped = 0;
+    const fileResults: FileSyncResult[] = [];
+
+    // 3. Record TOO_LARGE / availability-prefix outcomes for receipts
     for (const skip of skipped) {
       if (skip.reason === "TOO_LARGE") {
         const recordResult = await store.recordError({
@@ -1658,6 +2055,35 @@ export class SyncService {
           code: "TOO_LARGE",
           message: `File size ${skip.size} exceeds limit ${maxBytes}`,
         });
+        continue;
+      }
+      if (skip.unprovenPrefix || isUnprovenAbsenceCode(skip.reason)) {
+        const message =
+          skip.message ??
+          `Directory availability refused descent (${skip.reason})`;
+        await store
+          .recordError({
+            collection: collection.name,
+            relPath: skip.relPath,
+            code: skip.reason,
+            message,
+          })
+          .catch(() => undefined);
+        errors.push({
+          relPath: skip.relPath,
+          code: skip.reason,
+          message,
+        });
+        const isSkip = isSourceAvailabilitySkip(skip.reason);
+        fileResults.push({
+          relPath: skip.relPath === "" ? "." : skip.relPath,
+          status: isSkip ? "skipped" : "error",
+          errorCode: skip.reason,
+          errorMessage: message,
+        });
+        if (!isSkip) {
+          errored += 1;
+        }
       }
     }
 
@@ -1666,14 +2092,6 @@ export class SyncService {
       1,
       Math.min(MAX_CONCURRENCY, options.concurrency ?? DEFAULT_CONCURRENCY)
     );
-
-    let added = 0;
-    let updated = 0;
-    let unchanged = 0;
-    let errored = 0;
-    let dynamicSkipped = 0;
-    const fileResults: FileSyncResult[] = [];
-
     if (concurrency === 1) {
       // Sequential processing with batched transactions (Windows perf)
       for (let i = 0; i < entries.length; i += TX_BATCH_SIZE) {
@@ -1798,16 +2216,33 @@ export class SyncService {
       }
     }
 
-    // 5. Mark missing files as inactive
+    // 5. Mark missing files as inactive (inventory failures are hard errors).
     let markedInactive = 0;
+    let inventoryErrored = 0;
     const existingDocsResult = await store.listDocuments(collection.name);
-    if (existingDocsResult.ok) {
+    if (!existingDocsResult.ok) {
+      inventoryErrored += 1;
+      errors.push({
+        relPath: "",
+        code: existingDocsResult.error.code,
+        message: existingDocsResult.error.message,
+      });
+    } else {
       const missingPaths = existingDocsResult.value
-        .filter(
-          (document) =>
-            document.active &&
-            !seenPaths.has(document.recordSourcePath ?? document.relPath)
-        )
+        .filter((document) => {
+          if (!document.active) {
+            return false;
+          }
+          const sourcePath = document.recordSourcePath ?? document.relPath;
+          if (seenPaths.has(sourcePath)) {
+            return false;
+          }
+          // Absence under an unenumerated/unproven prefix is not proven deletion.
+          if (relPathUnderAnyPrefix(sourcePath, unprovenPrefixes)) {
+            return false;
+          }
+          return true;
+        })
         .map((d) => d.relPath);
 
       if (missingPaths.length > 0) {
@@ -1817,6 +2252,21 @@ export class SyncService {
         );
         if (markResult.ok) {
           markedInactive = markResult.value;
+        } else {
+          inventoryErrored += missingPaths.length;
+          errors.push({
+            relPath: missingPaths[0] ?? "",
+            code: markResult.error.code,
+            message: markResult.error.message,
+          });
+          for (const missingPath of missingPaths) {
+            fileResults.push({
+              relPath: missingPath,
+              status: "error",
+              errorCode: markResult.error.code,
+              errorMessage: markResult.error.message,
+            });
+          }
         }
       }
     }
@@ -1825,14 +2275,21 @@ export class SyncService {
       errors.push(...(await this.projectTypedEdges(store, syncOptions)));
     }
 
+    const walkerSkippedCount = skipped.filter(
+      (skip) =>
+        skip.reason === "TOO_LARGE" ||
+        skip.reason === "EXCLUDED" ||
+        isSourceAvailabilitySkip(skip.reason)
+    ).length;
+
     return {
       collection: collection.name,
-      filesProcessed: entries.length,
+      filesProcessed: entries.length + inventoryErrored,
       filesAdded: added,
       filesUpdated: updated,
       filesUnchanged: unchanged,
-      filesErrored: errored,
-      filesSkipped: skipped.length + dynamicSkipped,
+      filesErrored: errored + inventoryErrored,
+      filesSkipped: walkerSkippedCount + dynamicSkipped,
       filesMarkedInactive: markedInactive,
       durationMs: Date.now() - startTime,
       files: fileResults,