@remnic/core 9.45.2 → 9.45.4

package/src/access-service-offline-file-content.test.ts

@@ -1,8 +1,58 @@
 import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
 
 import { EngramAccessInputError, EngramAccessService } from "./access-service.js";
-import { OFFLINE_SYNC_MAX_MTIME_MS } from "./offline-sync.js";
+import { OFFLINE_SYNC_CHANGESET_FORMAT, OFFLINE_SYNC_MAX_MTIME_MS } from "./offline-sync.js";
+import { isEncryptedFile } from "./secure-store/index.js";
+import { ContentHashIndex } from "./storage/content-hash-index.js";
+import { StorageManager } from "./storage.js";
+import { withEntityCanonicalMutationLock } from "./storage/entity-canonical-id-lock.js";
+
+class RawEntityMutationProbeStorage extends StorageManager {
+  readonly probeEntitiesDir: string;
+  writeEntered = false;
+  deleteEntered = false;
+
+  constructor(memoryDir: string) {
+    super(memoryDir);
+    this.probeEntitiesDir = path.join(memoryDir, "entities");
+  }
+
+  override async readMemoryByPath(filePath: string) {
+    if (path.dirname(filePath) === this.probeEntitiesDir) return null;
+    return super.readMemoryByPath(filePath);
+  }
+
+  protected override tombstoneBlockedCaptureIndexOptions() {
+    const options = super.tombstoneBlockedCaptureIndexOptions();
+    return {
+      ...options,
+      parseMemory: (filePath: string, content: Buffer) =>
+        path.dirname(filePath) === this.probeEntitiesDir
+          ? null
+          : options.parseMemory?.(filePath, content) ?? null,
+    };
+  }
+
+  protected override async writeManagedStorageFile(
+    filePath: string,
+    write: () => Promise<void>,
+  ): Promise<void> {
+    this.writeEntered = true;
+    await super.writeManagedStorageFile(filePath, write);
+  }
+
+  protected override async deleteManagedStorageFile(
+    filePath: string,
+    deletionMtimeMs?: number | null,
+  ): Promise<boolean> {
+    this.deleteEntered = true;
+    return super.deleteManagedStorageFile(filePath, deletionMtimeMs);
+  }
+}
 
 function createOfflineService(): EngramAccessService {
   return new EngramAccessService({
@@ -18,6 +68,241 @@ function createOfflineService(): EngramAccessService {
   } as any);
 }
 
+function memoryFile(options: {
+  id: string;
+  body: string;
+  status?: string;
+  contentHash?: string;
+}): string {
+  return [
+    "---",
+    `id: ${options.id}`,
+    "category: fact",
+    ...(options.status ? [`status: ${options.status}`] : []),
+    ...(options.contentHash ? [`contentHash: ${options.contentHash}`] : []),
+    "---",
+    options.body,
+  ].join("\n");
+}
+
+function createManifestService(options: {
+  root: string;
+  storage: StorageManager;
+  namespacesEnabled?: boolean;
+}): { service: EngramAccessService; getStorageCalls: string[] } {
+  const getStorageCalls: string[] = [];
+  const service = new EngramAccessService({
+    config: {
+      memoryDir: options.root,
+      namespacesEnabled: options.namespacesEnabled === true,
+      defaultNamespace: "global",
+      sharedNamespace: "shared",
+      namespacePolicies: options.namespacesEnabled
+        ? [{ name: "team", readPrincipals: ["reader"], writePrincipals: [] }]
+        : [],
+      offlineSyncExcludes: [],
+    },
+    namespaceCatalog: {
+      async listNamespaces() {
+        return [];
+      },
+    },
+    async drainPendingRecallImpressions() {
+      return { folded: false, pendingDeferred: false };
+    },
+    async getStorage(namespace: string) {
+      getStorageCalls.push(namespace);
+      return options.storage;
+    },
+  } as unknown as ConstructorParameters<typeof EngramAccessService>[0]);
+  return { service, getStorageCalls };
+}
+
+test("offline manifest streams body-free active, archived, old, bad, and encrypted memory rows lazily", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-manifest-"));
+  try {
+    const activeBody = "active body must never leave the service";
+    const archivedBody = "archived body must never leave the service";
+    const oldBody = "legacy body must never leave the service";
+    const encryptedBody = "encrypted body must never leave the service";
+    const activeContentHash = ContentHashIndex.computeHash(activeBody);
+    const files = new Map<string, string>([
+      [
+        "facts/active.md",
+        memoryFile({
+          id: "active-memory",
+          body: activeBody,
+          status: "active",
+          contentHash: activeContentHash,
+        }),
+      ],
+      [
+        "archive/facts/archived.md",
+        memoryFile({ id: "archived-memory", body: archivedBody, status: "active" }),
+      ],
+      ["facts/old.md", memoryFile({ id: "old-memory", body: oldBody })],
+      ["facts/bad.md", `not valid memory frontmatter\n${activeBody}`],
+    ]);
+    for (const [relativePath, content] of files) {
+      const filePath = path.join(root, relativePath);
+      await mkdir(path.dirname(filePath), { recursive: true });
+      await writeFile(filePath, content);
+    }
+    const storage = new StorageManager(root);
+    await storage.ensureDirectories();
+    storage.setSecureStoreKey(Buffer.alloc(32, 11));
+    storage.setSecureStoreRequired(true);
+    const encryptedRelativePath = "facts/encrypted.md";
+    await storage.writeOfflineSyncFile(
+      path.join(root, encryptedRelativePath),
+      Buffer.from(memoryFile({ id: "encrypted-memory", body: encryptedBody, status: "active" })),
+    );
+    assert.equal(isEncryptedFile(await readFile(path.join(root, encryptedRelativePath))), true);
+
+    let digestReads = 0;
+    let bodyReads = 0;
+    const digestOfflineSyncFile = storage.digestOfflineSyncFile.bind(storage);
+    const readOfflineSyncFile = storage.readOfflineSyncFile.bind(storage);
+    storage.digestOfflineSyncFile = async (filePath: string) => {
+      digestReads += 1;
+      return digestOfflineSyncFile(filePath);
+    };
+    storage.readOfflineSyncFile = async (filePath: string) => {
+      bodyReads += 1;
+      return readOfflineSyncFile(filePath);
+    };
+    const { service } = createManifestService({ root, storage });
+
+    const manifest = await service.offlineSyncManifestStream();
+    assert.equal(manifest.format, "remnic-reconcile-manifest");
+    assert.equal(manifest.schemaVersion, 1);
+    assert.equal(Array.isArray(manifest.files), false);
+    assert.equal(digestReads, 0);
+    assert.equal(bodyReads, 0);
+
+    const iterator = manifest.files[Symbol.asyncIterator]();
+    const first = await iterator.next();
+    assert.equal(first.done, false);
+    assert.equal(first.value?.path, "archive/facts/archived.md");
+    assert.equal(digestReads, 1);
+    assert.equal(bodyReads, 1);
+
+    const rows = first.value ? [first.value] : [];
+    for await (const row of { [Symbol.asyncIterator]: () => iterator }) rows.push(row);
+    const rowsByPath = new Map(rows.map((row) => [row.path, row]));
+    assert.deepEqual(rowsByPath.get("facts/active.md")?.memory, {
+      id: "active-memory",
+      category: "fact",
+      contentHash: activeContentHash,
+      status: "active",
+    });
+    assert.notEqual(rowsByPath.get("facts/active.md")?.sha256, activeContentHash);
+    assert.equal(rowsByPath.get("archive/facts/archived.md")?.memory?.status, "archived");
+    assert.equal(
+      rowsByPath.get("facts/old.md")?.memory?.contentHash,
+      ContentHashIndex.computeHash(oldBody),
+    );
+    assert.equal(rowsByPath.get("facts/old.md")?.memory?.status, "active");
+    assert.equal(rowsByPath.get("facts/bad.md")?.memory, undefined);
+    assert.equal(rowsByPath.get(encryptedRelativePath)?.memory?.id, "encrypted-memory");
+    for (const row of rows) {
+      assert.equal("content" in row, false);
+      assert.equal("contentBase64" in row, false);
+      assert.doesNotMatch(JSON.stringify(row), /body must never leave the service/);
+      assert.equal(typeof row.sha256, "string");
+      assert.equal(typeof row.bytes, "number");
+      assert.equal(typeof row.mtimeMs, "number");
+    }
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline manifest uses snapshot namespace authorization and storage routing", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-manifest-namespace-"));
+  try {
+    const storage = new StorageManager(path.join(root, "namespaces", "team"));
+    await storage.ensureDirectories();
+    const { service, getStorageCalls } = createManifestService({
+      root,
+      storage,
+      namespacesEnabled: true,
+    });
+    await assert.rejects(
+      () => service.offlineSyncManifestStream({ namespace: "team", principal: "outsider" }),
+      /namespace is not readable: team/,
+    );
+    const manifest = await service.offlineSyncManifestStream({
+      namespace: "team",
+      principal: "reader",
+      includeTranscripts: false,
+    });
+    assert.equal(manifest.namespace, "team");
+    assert.deepEqual(getStorageCalls, ["team"]);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline file-transfer endpoints reject internal Remnic state paths", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-access-internal-state-"));
+  try {
+    const storage = new StorageManager(root);
+    await storage.ensureDirectories();
+    const { service } = createManifestService({ root, storage });
+    const internalPath = ".remnic/state/converge-cursors/peer.json";
+    const internalFilePath = path.join(root, internalPath);
+    await mkdir(path.dirname(internalFilePath), { recursive: true });
+    await writeFile(internalFilePath, "cursor");
+
+    await assert.rejects(
+      () => service.offlineSyncFiles({ paths: [internalPath] }),
+      (error) =>
+        error instanceof EngramAccessInputError
+        && /offline sync snapshot path is excluded/.test(error.message),
+    );
+    await assert.rejects(
+      () => service.offlineSyncFileContent({ path: internalPath, offset: 0, length: 1 }),
+      (error) =>
+        error instanceof EngramAccessInputError
+        && /offline sync file content path is excluded/.test(error.message),
+    );
+    await assert.rejects(
+      () => service.offlineSyncApplyFileContent({
+        sourceId: "peer",
+        path: internalPath,
+        sha256: "a".repeat(64),
+        bytes: 0,
+        mtimeMs: 0,
+        offset: 0,
+        content: Buffer.alloc(0),
+      }),
+      (error) =>
+        error instanceof EngramAccessInputError
+        && /offline sync file content path is excluded/.test(error.message),
+    );
+    const applyResult = await service.offlineSyncApply({
+      changeset: {
+        format: OFFLINE_SYNC_CHANGESET_FORMAT,
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        sourceId: "peer",
+        includeTranscripts: true,
+        changes: [{
+          type: "delete",
+          path: internalPath,
+          baseSha256: "b".repeat(64),
+        }],
+      },
+    });
+    assert.equal(applyResult.appliedDeletes, 0);
+    assert.equal(await readFile(internalFilePath, "utf8"), "cursor");
+
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline apply-file-content reports invalid metadata as input errors", async () => {
   const service = createOfflineService();
   await assert.rejects(
@@ -92,3 +377,62 @@ test("offline convergence completion refreshes authorized namespaces as one batc
   assert.deepEqual(result, { namespaces: ["global"], refreshed: true });
   assert.deepEqual(refreshed, [["global"]]);
 });
+
+test("offline raw entity writes wait for the canonical mutation lock", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-offline-entity-write-lock-"));
+  let writePromise: Promise<void> | undefined;
+  try {
+    await new StorageManager(root).ensureDirectories();
+    const storage = new RawEntityMutationProbeStorage(root);
+    const target = path.join(root, "entities", "project-replicated.md");
+    const content = Buffer.from(
+      "---\nid: project-replicated\n---\n\n# Replicated\n\n**Type:** project\n\nReplicated bytes.\n",
+      "utf8",
+    );
+
+    await withEntityCanonicalMutationLock(path.join(root, "state"), async () => {
+      writePromise = storage.writeOfflineSyncFile(target, content);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      assert.equal(
+        storage.writeEntered,
+        false,
+        "the raw entity write must not enter its managed-file mutation while the canonical lock is held",
+      );
+    });
+
+    assert.ok(writePromise);
+    await writePromise;
+    assert.deepEqual(await readFile(target), content);
+  } finally {
+    await writePromise?.catch(() => undefined);
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("offline raw entity deletes wait for the canonical mutation lock", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-offline-entity-delete-lock-"));
+  let deletePromise: Promise<void> | undefined;
+  try {
+    await new StorageManager(root).ensureDirectories();
+    const target = path.join(root, "entities", "project-replicated.md");
+    await writeFile(target, "# Replicated\n", "utf8");
+    const storage = new RawEntityMutationProbeStorage(root);
+
+    await withEntityCanonicalMutationLock(path.join(root, "state"), async () => {
+      deletePromise = storage.deleteOfflineSyncFile(target, null);
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      assert.equal(
+        storage.deleteEntered,
+        false,
+        "the raw entity delete must not enter its managed-file mutation while the canonical lock is held",
+      );
+    });
+
+    assert.ok(deletePromise);
+    await deletePromise;
+    await assert.rejects(() => readFile(target));
+  } finally {
+    await deletePromise?.catch(() => undefined);
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/access-service.ts

@@ -39,6 +39,10 @@ import {
   resolveCodingNamespaceOverlay,
   type CodingNamespaceOverlay,
 } from "./coding/coding-namespace.js";
+import {
+  resolveCodingContextFromOptions,
+  type InterruptibleCodingScopeInput,
+} from "./access-coding-context-resolution.js";
 import {
   handleCodingDecision,
   type DecisionSurfaceRequest,
@@ -72,7 +76,7 @@ import {
   type DeltaSurfaceResponse,
   type DeltaSurfaceStorage,
 } from "./coding/session-delta-surfaces.js";
-import { defaultGitInvoker } from "./coding/git-context.js";
+import { defaultGitInvokerSync } from "./coding/git-context.js";
 import {
   createCorrectionService,
   isCorrectionFeatureEnabled,
@@ -180,7 +184,7 @@ import type {
   Orchestrator,
   RecallInvocationOptions,
 } from "./orchestrator.js";
-import { parseEntityFile, StorageManager } from "./storage.js";
+import { parseEntityFile, parseFrontmatter, StorageManager } from "./storage.js";
 import {
   buildGraphSnapshot,
   type GraphSnapshotRequest,
@@ -283,6 +287,7 @@ import {
   buildOfflineSyncSnapshotFromBase,
   buildOfflineSyncSnapshotForPaths,
   iterateOfflineSyncSnapshotFileRecords,
+  filterOfflineSyncDeletionRevisions,
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   readOfflineSyncFileContentChunk,
   type OfflineSyncApplyFileContentChunkResult,
@@ -293,6 +298,10 @@ import {
   type OfflineSyncSnapshot,
 } from "./offline-sync.js";
 import { offlineSyncStorageForSnapshot } from "./offline-sync-impression-drain.js";
+import {
+  createOfflineSyncManifestStream,
+  type OfflineSyncManifestStreamResponse,
+} from "./access-offline-manifest.js";
 import {
   evaluateActionConfidence,
   type ActionConfidenceInput,
@@ -372,6 +381,8 @@ export interface EngramAccessRecallRequest {
   sessionKey?: string;
   namespace?: string;
   authenticatedPrincipal?: string;
+  /** Trusted connector identity resolved at the transport boundary. */
+  sourceConnector?: string;
   idempotencyKey?: string;
   topK?: number;
   mode?: RecallPlanMode | "auto";
@@ -781,6 +792,12 @@ export interface EngramAccessOfflineSyncSnapshotRequest {
   baseFiles?: OfflineSyncFileState[];
 }
 
+export interface EngramAccessOfflineSyncManifestRequest {
+  namespace?: string;
+  principal?: string;
+  includeTranscripts?: boolean;
+}
+
 export interface EngramAccessOfflineSyncFilesRequest {
   namespace?: string;
   principal?: string;
@@ -924,6 +941,7 @@ export interface CodingScopedWriteInput {
   cwd?: string;
   projectTag?: string;
 }
+
 export type { EngramAccessNamespaceWritableRequest } from "./access-namespace-preflight.js";
 /**
  * Internal, single-resolution plan describing the effective memory scope for a
@@ -1463,38 +1481,6 @@ export class EngramAccessService {
     return result.namespace;
   }
 
-  /**
-   * Resolve a coding context from `cwd`/`projectTag` WITHOUT persisting it to
-   * any session — the read-only half of `maybeAttachCodingContext`. Returns
-   * null when project scoping is off or nothing resolves. `projectTag` takes
-   * priority over `cwd` (matching `maybeAttachCodingContext`).
-   */
-  private async resolveCodingContextFromOptions(
-    options: CodingScopedWriteInput,
-  ): Promise<CodingContext | null> {
-    if (!this.orchestrator.config.codingMode?.projectScope) return null;
-    if (typeof options.projectTag === "string" && options.projectTag.trim().length > 0) {
-      const projectId = projectTagProjectId(options.projectTag);
-      return { projectId, branch: null, rootPath: projectId, defaultBranch: null };
-    }
-    if (typeof options.cwd === "string" && options.cwd.trim().length > 0) {
-      try {
-        const gitCtx = await resolveGitContext(options.cwd);
-        if (gitCtx) {
-          return {
-            projectId: gitCtx.projectId,
-            branch: gitCtx.branch,
-            rootPath: gitCtx.rootPath,
-            defaultBranch: gitCtx.defaultBranch,
-          };
-        }
-      } catch {
-        // resolveGitContext never throws, but stay defensive — not being in a
-        // repo is normal and must not break the write.
-      }
-    }
-    return null;
-  }
 
   /** Shared coding-scope derivation for the read/write resolvers below —
    *  coding context, overlay, principal, scope-profile plan for an IMPLICIT
@@ -1503,7 +1489,7 @@ export class EngramAccessService {
    *  of truth for the namespacesEnabled/projectScope gates (rule 22; keeps the
    *  scattered-config-read ratchet flat). READ-ONLY: never mutates session. */
   private async resolveCodingScopeInputs(
-    request: CodingScopedWriteInput & {
+    request: InterruptibleCodingScopeInput & {
       namespace?: string;
       sessionKey?: string;
       authenticatedPrincipal?: string;
@@ -1526,7 +1512,7 @@ export class EngramAccessService {
       resolveNamespaceCapabilities(this.orchestrator.config).namespaces &&
       this.orchestrator.config.codingMode?.projectScope
         ? this.orchestrator.getCodingContextForSession(request.sessionKey) ??
-          (await this.resolveCodingContextFromOptions(request))
+          (await resolveCodingContextFromOptions(request))
         : null;
     const overlay =
       hasSession &&
@@ -1702,7 +1688,7 @@ export class EngramAccessService {
    * precedence), falling back to the per-call `cwd`/`projectTag`.
    */
   private async resolveMemoryScopePlan(
-    request: CodingScopedWriteInput & {
+    request: InterruptibleCodingScopeInput & {
       namespace?: string;
       sessionKey?: string;
       authenticatedPrincipal?: string;
@@ -2393,6 +2379,16 @@ export class EngramAccessService {
       extractionWatermark,
       caps?.namespaces !== undefined ? undefined : this.extractionLivenessWarn,
     );
+    let scopedDegradedReason: string | null = null;
+    if (extraction.degraded) {
+      if (extraction.degradedReason?.includes("watermark unreadable")) {
+        scopedDegradedReason = "daemon extraction pipeline degraded; extraction watermark unreadable";
+      } else if (extraction.degradedReason?.includes("buffer unreadable")) {
+        scopedDegradedReason = "daemon extraction pipeline degraded; extraction buffer unreadable";
+      } else {
+        scopedDegradedReason = "daemon extraction pipeline degraded; backlog pending extraction";
+      }
+    }
     const visibleExtraction =
       caps?.namespaces !== undefined
         ? {
@@ -2401,7 +2397,7 @@ export class EngramAccessService {
             bufferedSessionCount: 0,
             pendingTurnCount: 0,
             oldestBufferedTurnAgeMs: null,
-            degradedReason: extraction.degraded ? "daemon extraction pipeline degraded" : null,
+            degradedReason: scopedDegradedReason,
           }
         : extraction;
     // ONE call: the corpus array and the flag describing it must not come from
@@ -2844,6 +2840,7 @@ export class EngramAccessService {
     namespace?: string;
     budget?: number;
     authenticatedPrincipal?: string;
+    sourceConnector?: string;
     /**
      * Disclosure depth used to shape per-result payload (issue #677
      * PR 3/4).  When set, each X-ray result is decorated with the
@@ -3229,12 +3226,9 @@ export class EngramAccessService {
         } satisfies DeltaSurfaceStorage;
       },
       gitInvoker: (cwd, args) => {
-        // Reuse the existing defaultGitInvoker (2s timeout, never throws —
-        // the discipline git-context.ts already established). It returns
-        // { stdout, exitCode } so the handler can recover from non-zero
-        // exits without a try/catch.
-        const invoker = defaultGitInvoker();
-        return invoker(cwd, args);
+        // Session-delta remains a synchronous pure calculation; use the
+        // bounded synchronous invoker rather than the abortable scope resolver.
+        return defaultGitInvokerSync()(cwd, args);
       },
       throwInputError: (msg) => { throw new EngramAccessInputError(msg); },
     });
@@ -3318,23 +3312,28 @@ export class EngramAccessService {
     }
   }
 
-  async correctionPlan(request: CorrectionRequest): Promise<CorrectionPlan> {
-    // Issue #1582 — resolve any `[m:xxxx]` handle in targetIds to its memory
-    // id against the caller's session BEFORE planning, so the planner only ever
-    // sees concrete ids. One shared resolve path (rule 22); a handle that
-    // misses or collides is an explicit input error, never silent (rule 34/51).
+  async correctionPlan(
+    request: CorrectionRequest,
+    opts?: { abortSignal?: AbortSignal },
+  ): Promise<CorrectionPlan> {
     if (request.targetIds?.some((id) => isHandleToken(id))) {
       const targetIds = request.targetIds.map((id) =>
         this.resolveMemoryIdOrHandleInput(id, request.sessionKey),
       );
-      return this.correctionService().plan({ ...request, targetIds });
+      return this.correctionService().plan({ ...request, targetIds }, opts);
     }
-    return this.correctionService().plan(request);
+    return this.correctionService().plan(request, opts);
   }
 
   async correctionApply(
     planId: string,
-    opts: { confirm?: boolean; namespace?: string; sessionKey?: string; principal?: string },
+    opts: {
+      confirm?: boolean;
+      namespace?: string;
+      sessionKey?: string;
+      principal?: string;
+      abortSignal?: AbortSignal;
+    },
   ): Promise<CorrectionOutcome> {
     return this.correctionService().apply(planId, opts);
   }
@@ -4019,12 +4018,9 @@ export class EngramAccessService {
       // Explicit namespace pins the scope (resolveMemoryScopePlan returns early),
       // so the coding context is irrelevant — skip it to avoid false conflicts
       // when the session context changes under a namespace-pinned observe.
-      // resolveCodingContextFromOptions self-gates on projectScope (no scattered
-      // config read here).
-      effectiveCodingContext =
-        (typeof this.orchestrator.getCodingContextForSession === "function"
-          ? this.orchestrator.getCodingContextForSession(request.sessionKey)
-          : null) ?? (await this.resolveCodingContextFromOptions(request));
+      // Reuse the write resolver's namespace/projectScope gates so context
+      // ignored by runObserve cannot change the retry fingerprint.
+      effectiveCodingContext = (await this.resolveCodingScopeInputs(request)).codingContext;
     }
     return this.handleIdempotentWrite<EngramAccessObserveResponse>({
       operation: "observe",
@@ -4330,6 +4326,10 @@ export class EngramAccessService {
   async extractionForceFlush(request: EngramAccessExtractionForceFlushRequest): Promise<EngramAccessExtractionForceFlushResponse> {
     return delegateExtractionForceFlush(this.accessObserveWriteSurface, request);
   }
+  cancelPendingObservePreparations(sessionKey: string, scopeHint?: string): void {
+    this.accessObserveWriteSurface.cancelPendingObservePreparations(sessionKey, scopeHint);
+  }
+
   cancelPendingObserveExtractions(
     sessionKey: string,
     principal?: string,
@@ -5469,6 +5469,8 @@ export class EngramAccessService {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const deletions = [...await storage.readDeletionRevisions()]
+      .map(([path, mtimeMs]) => ({ path, mtimeMs }));
     const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0
       ? buildOfflineSyncSnapshotFromBase
       : buildOfflineSyncSnapshot;
@@ -5482,6 +5484,7 @@ export class EngramAccessService {
       readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
       signal: options.signal,
       userExcludeRegexps: this.offlineSyncUserExcludes,
+      deletions,
     });
     return {
       namespace: resolvedNamespace,
@@ -5495,6 +5498,13 @@ export class EngramAccessService {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash("sha256").update(storage.dir).digest("hex").slice(0, 16);
+    const deletions = await filterOfflineSyncDeletionRevisions({
+      root: storage.dir,
+      deletions: [...await storage.readDeletionRevisions()]
+        .map(([path, mtimeMs]) => ({ path, mtimeMs })),
+      includeTranscripts: options.includeTranscripts !== false,
+      userExcludeRegexps: this.offlineSyncUserExcludes,
+    });
     return {
       namespace: resolvedNamespace,
       format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -5502,6 +5512,7 @@ export class EngramAccessService {
       createdAt: new Date().toISOString(),
       sourceId: `remnic:${resolvedNamespace}:${storageHash}`,
       includeTranscripts: options.includeTranscripts !== false,
+      deletions,
       files: iterateOfflineSyncSnapshotFileRecords({
         root: storage.dir,
         includeContent: options.includeContent === true,
@@ -5513,6 +5524,19 @@ export class EngramAccessService {
       }),
     };
   }
+  async offlineSyncManifestStream(
+    options: EngramAccessOfflineSyncManifestRequest & { signal?: AbortSignal } = {},
+  ): Promise<OfflineSyncManifestStreamResponse> {
+    const namespace = this.resolveReadableNamespace(options.namespace, options.principal);
+    return createOfflineSyncManifestStream(
+      this.orchestrator,
+      namespace,
+      this.offlineSyncUserExcludes,
+      options,
+      parseFrontmatter,
+    );
+  }
+
 
   async offlineSyncFiles(
     options: EngramAccessOfflineSyncFilesRequest,
@@ -5672,7 +5696,10 @@ export class EngramAccessService {
         readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
         readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
         writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
-        deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath),
+        deleteFile: async ({ filePath, mtimeMs }) =>
+          storage.deleteOfflineSyncFile(filePath, mtimeMs ?? null),
+        recordDeletionRevision: async ({ filePath, mtimeMs }) =>
+          storage.recordReplicatedDeletionRevision(filePath, mtimeMs),
       });
       return {
         namespace: resolvedNamespace,