@remnic/core 9.45.2 → 9.45.4

package/src/access-service-namespace.test.ts

@@ -1265,6 +1265,52 @@ test("offlineSyncFiles reports symlink requested paths as input errors", async (
   }
 });
 
+test("offlineSyncSnapshot and stream expose durable namespace deletion revisions", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-offline-snapshot-deletions-"));
+  try {
+    const relPath = "facts/deleted.md";
+    const filePath = path.join(root, relPath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, "deleted content");
+    const storage = new StorageManager(root);
+    await storage.deleteOfflineSyncFile(filePath);
+    const mtimeMs = (await storage.readDeletionRevisions()).get(relPath);
+    assert.ok(mtimeMs !== undefined);
+
+    const { service } = makeService();
+    (service as unknown as {
+      orchestrator: {
+        config: PluginConfig;
+        getStorage(namespace: string): Promise<StorageManager>;
+      };
+    }).orchestrator.getStorage = async () => storage;
+
+    const snapshot = await service.offlineSyncSnapshot({
+      namespace: "team",
+      principal: "reader",
+      includeContent: false,
+    });
+    const stream = await service.offlineSyncSnapshotStream({
+      namespace: "team",
+      principal: "reader",
+      includeContent: false,
+    });
+
+    assert.deepEqual(snapshot.deletions, [{ path: relPath, mtimeMs }]);
+    assert.deepEqual(stream.deletions, snapshot.deletions);
+
+    await writeFile(filePath, "recreated content");
+    const recreatedStream = await service.offlineSyncSnapshotStream({
+      namespace: "team",
+      principal: "reader",
+      includeContent: false,
+    });
+    assert.deepEqual(recreatedStream.deletions, []);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offlineSyncSnapshot does not trust client base capture time for server fast-base scans", async () => {
   const root = await mkdtemp(path.join(os.tmpdir(), "remnic-offline-snapshot-client-clock-"));
   try {
@@ -1294,6 +1340,9 @@ test("offlineSyncSnapshot does not trust client base capture time for server fas
       async drainPendingMemoryLifecycleEventsForSync() {
         return { folded: false, pendingDeferred: false };
       },
+      async readDeletionRevisions() {
+        return new Map<string, number>();
+      },
       async readOfflineSyncFile(targetPath: string) {
         return readFile(targetPath);
       },
@@ -1358,6 +1407,9 @@ test("offlineSyncSnapshot drains pending recall-impression spills so a recorded
       async drainPendingMemoryLifecycleEventsForSync() {
         return { folded: false, pendingDeferred: false };
       },
+      async readDeletionRevisions() {
+        return new Map<string, number>();
+      },
       async readOfflineSyncFile(targetPath: string) {
         return readFile(targetPath);
       },
@@ -1441,6 +1493,9 @@ test("offlineSyncSnapshot does NOT drain the global impression queue during a na
         lifecycleDrainCalls += 1;
         return { folded: false, pendingDeferred: false };
       },
+      async readDeletionRevisions() {
+        return new Map<string, number>();
+      },
       async readOfflineSyncFile(targetPath: string) {
         return readFile(targetPath);
       },

package/src/access-service-observe-idempotency.test.ts

@@ -35,7 +35,7 @@ interface ObserveProbe {
   }>;
 }
 
-function makeObserveProbe(memoryDir: string): ObserveProbe {
+function makeObserveProbe(memoryDir: string, projectScope = true): ObserveProbe {
   const contexts = new Map<string, CodingContext>();
   const lcmCalls: ObserveProbe["lcmCalls"] = [];
   const extractionCalls: ObserveProbe["extractionCalls"] = [];
@@ -47,7 +47,7 @@ function makeObserveProbe(memoryDir: string): ObserveProbe {
     namespacePolicies: [
       { name: "pi-geek", readPrincipals: ["pi-geek"], writePrincipals: ["pi-geek"] },
     ],
-    codingMode: { projectScope: true },
+    codingMode: { projectScope },
     memoryDir,
     // Disable objective-state snapshots so the probe doesn't need a writable
     // storage backend — the idempotency contract under test is LCM + extraction.
@@ -274,6 +274,38 @@ test("#1649 review fix: rebinding the session's ambient coding context makes the
   }
 });
 
+test("#2206 project-scope-off ignores ambient coding context in observe idempotency", async () => {
+  const memoryDir = mkdtempSync(join(tmpdir(), "remnic-observe-unscoped-replay-"));
+  try {
+    const probe = makeObserveProbe(memoryDir, false);
+    const service = new EngramAccessService(probe.orch);
+    const key = "observe-batch-unscoped-replay-#6";
+    const req = observeRequest({
+      idempotencyKey: key,
+      projectTag: "Acme/Webshop",
+    });
+
+    const first = await service.observe(req);
+    assert.equal(first.effectiveNamespace, "default");
+    assert.equal(first.scopeDebug?.codingOverlayApplied, false);
+    assert.equal(probe.contexts.size, 0, "disabled project scoping must not attach projectTag context");
+    probe.contexts.set(req.sessionKey, {
+      projectId: "tag:ignored-while-unscoped",
+      branch: "changed-branch",
+      rootPath: "/projects/ignored",
+      defaultBranch: "main",
+    });
+    assert.ok(probe.contexts.has(req.sessionKey), "the ambient context change must be injected");
+
+    const replay = await service.observe(req);
+    assert.equal(replay.idempotencyReplay, true);
+    assert.equal(probe.extractionCalls.length, 1);
+    assert.equal(probe.lcmCalls.length, 1);
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("#1649 review fix: projectTag observe replays correctly despite scope resolution side effects", async () => {
   // The fingerprint folds in the RESOLVED writeNamespace (not the raw ambient
   // context). resolveMemoryScopePlan seeds the session context from projectTag

package/src/access-service-observe-lcm-parity.test.ts

@@ -34,7 +34,7 @@ import { EngramAccessForbiddenError } from "./access-errors.js";
 import { Orchestrator } from "./orchestrator.js";
 import { ExtractionDeadlineError } from "./orchestration/extraction-run.js";
 import { SessionOwnershipError } from "./orchestration/session-context.js";
-import type { EngramAccessObserveRequest } from "./access-service.js";
+import type { EngramAccessObserveRequest, MemoryScopePlan } from "./access-service.js";
 import {
   combineNamespaces,
   lcmSessionKeyForNamespace,
@@ -957,6 +957,141 @@ test("#2128: post-flush retained cleanup stops on abort or deadline", async () =
     /replay extraction deadline exceeded \(retained_turn_cleanup\)/,
   );
 });
+test("#2206: an expired force-flush deadline stops before scope resolution", async () => {
+  const probe = makeParityProbe({ namespacesEnabled: false } as Partial<PluginConfig>);
+  const service = new EngramAccessService(probe.orch);
+  let scopeResolutionStarted = false;
+  const internals = service as unknown as {
+    resolveMemoryScopePlan: (request: unknown) => Promise<never>;
+  };
+  internals.resolveMemoryScopePlan = async () => {
+    scopeResolutionStarted = true;
+    throw new Error("scope resolution must not start");
+  };
+
+  await assert.rejects(
+    service.extractionForceFlush({
+      sessionKey: "expired-scope-resolution",
+      deadlineMs: 1,
+    }),
+    /scope_resolution/,
+  );
+  assert.equal(scopeResolutionStarted, false);
+});
+
+test("#2206: abort during scope resolution cancels pre-resolution observe preparations", async () => {
+  const probe = makeParityProbe(withSelfPolicyPrefix("pi-geek"));
+  const service = new EngramAccessService(probe.orch);
+  const abortController = new AbortController();
+  let releaseObserveScope!: () => void;
+  let signalObserveScopeStarted!: () => void;
+  let signalFlushScopeStarted!: () => void;
+  const observeScopeGate = new Promise<void>((resolve) => {
+    releaseObserveScope = resolve;
+  });
+  const observeScopeStarted = new Promise<void>((resolve) => {
+    signalObserveScopeStarted = resolve;
+  });
+  const flushScopeStarted = new Promise<void>((resolve) => {
+    signalFlushScopeStarted = resolve;
+  });
+  const internals = service as unknown as {
+    resolveMemoryScopePlan: (
+      request: EngramAccessObserveRequest & { messages?: unknown },
+    ) => Promise<MemoryScopePlan>;
+  };
+  const resolveMemoryScopePlan = internals.resolveMemoryScopePlan.bind(service);
+  internals.resolveMemoryScopePlan = async (request) => {
+    if (request.messages !== undefined) {
+      signalObserveScopeStarted();
+      await observeScopeGate;
+      return resolveMemoryScopePlan(request);
+    }
+    signalFlushScopeStarted();
+    return new Promise<never>(() => {});
+  };
+
+  const observe = service.observe(observeRequest({
+    sessionKey: "pi-geek:abort-scope-resolution",
+    namespace: "pi-geek",
+    authenticatedPrincipal: "pi-geek",
+    skipExtraction: false,
+  }));
+  await observeScopeStarted;
+  const flush = service.extractionForceFlush({
+    sessionKey: "pi-geek:abort-scope-resolution",
+    namespace: "pi-geek",
+    authenticatedPrincipal: "pi-geek",
+    abortSignal: abortController.signal,
+  });
+  await flushScopeStarted;
+  abortController.abort();
+
+  await assert.rejects(flush, /extraction force-flush aborted/);
+  releaseObserveScope();
+  const response = await observe;
+  assert.equal(response.extractionQueued, false);
+  assert.equal(probe.extractionCalls.length, 0);
+});
+
+test("#2206: scope-resolution deadline cancels preparations by raw projectTag and cwd hints", async () => {
+  const rawHintCases = [
+    { projectTag: "Acme/Webshop" },
+    { cwd: "/workspace/acme/webshop" },
+  ];
+
+  for (const rawHintCase of rawHintCases) {
+    const probe = makeParityProbe(withSelfPolicyPrefix("pi-geek"));
+    const service = new EngramAccessService(probe.orch);
+    let releaseObserveScope!: () => void;
+    let signalObserveScopeStarted!: () => void;
+    let flushScopeStarted = false;
+    const observeScopeGate = new Promise<void>((resolve) => {
+      releaseObserveScope = resolve;
+    });
+    const observeScopeStarted = new Promise<void>((resolve) => {
+      signalObserveScopeStarted = resolve;
+    });
+    const internals = service as unknown as {
+      resolveMemoryScopePlan: (
+        request: EngramAccessObserveRequest & { messages?: unknown },
+      ) => Promise<MemoryScopePlan>;
+    };
+    const resolveMemoryScopePlan = internals.resolveMemoryScopePlan.bind(service);
+    internals.resolveMemoryScopePlan = async (request) => {
+      if (request.messages !== undefined) {
+        signalObserveScopeStarted();
+        await observeScopeGate;
+        return resolveMemoryScopePlan(request);
+      }
+      flushScopeStarted = true;
+      throw new Error("scope resolution must not start");
+    };
+
+    const observe = service.observe(observeRequest({
+      sessionKey: "pi-geek:raw-hint-deadline",
+      authenticatedPrincipal: "pi-geek",
+      skipExtraction: false,
+      ...rawHintCase,
+    }));
+    await observeScopeStarted;
+    await assert.rejects(
+      service.extractionForceFlush({
+        sessionKey: "pi-geek:raw-hint-deadline",
+        authenticatedPrincipal: "pi-geek",
+        deadlineMs: Date.now() - 1,
+        ...rawHintCase,
+      }),
+      /scope_resolution/,
+    );
+    assert.equal(flushScopeStarted, false);
+    releaseObserveScope();
+    const response = await observe;
+    assert.equal(response.extractionQueued, false);
+    assert.equal(probe.extractionCalls.length, 0);
+  }
+});
+
 test("#2128: aborted or expired extraction force-flush never touches a buffer", async () => {
   const probe = makeParityProbe(withSelfPolicyPrefix("pi-geek"));
   const service = new EngramAccessService(probe.orch);
@@ -981,7 +1116,7 @@ test("#2128: aborted or expired extraction force-flush never touches a buffer",
       }),
     (error: unknown) =>
       error instanceof EngramAccessInputError &&
-      error.message === "extraction force-flush deadline exceeded before buffer drain",
+      error.message === "replay extraction deadline exceeded (scope_resolution)",
   );
   assert.equal(probe.extractionForceFlushCalls.length, 0);
 });
@@ -1017,7 +1152,7 @@ test("#2128: self-deps wires force-flush cancellation into the observe tracker",
       }),
     (error: unknown) =>
       error instanceof EngramAccessInputError &&
-      error.message === "extraction force-flush deadline exceeded before buffer drain",
+      error.message === "replay extraction deadline exceeded (scope_resolution)",
   );
   assert.deepEqual(cancellations, [{
     sessionKey: "pi-geek:cancel-hook",

package/src/access-service-observe-scope.test.ts

@@ -243,6 +243,166 @@ test("#2128 pending observe preparation is a force-flush barrier", async () => {
   assert.equal(waited, true);
 });
 
+test("#2206 scoped wait ignores unresolved preparations with a different hint", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const target = tracker.reserve("opaque-session", "projectTag:project-a");
+  const unrelated = tracker.reserve("opaque-session", "projectTag:project-b");
+  let settled = false;
+  const waitPromise = tracker
+    .wait(
+      "opaque-session",
+      "alice",
+      "alice-project-a",
+      undefined,
+      undefined,
+      "projectTag:project-a",
+    )
+    .then(() => {
+      settled = true;
+    });
+
+  target.release();
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  const settledBeforeUnrelatedRelease = settled;
+  unrelated.release();
+  await waitPromise;
+
+  assert.equal(settledBeforeUnrelatedRelease, true);
+});
+
+test("#2206 scoped wait fences a reservation that later resolves into the flushed scope", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const reservation = tracker.reserve("opaque-session", "cwd:/workspace/project/nested");
+  const unrelated = tracker.reserve("opaque-session", "cwd:/workspace/other/nested");
+
+  await tracker.wait(
+    "opaque-session",
+    "alice",
+    "alice-project",
+    undefined,
+    undefined,
+    "projectTag:Acme/Webshop",
+  );
+  assert.equal(reservation.isCancelled(), false, "the raw hint mismatch initially excludes the reservation");
+
+  reservation.setScope("alice", "alice-project");
+  unrelated.setScope("alice", "alice-other-project");
+
+  assert.equal(
+    reservation.isCancelled(),
+    true,
+    "a reservation existing at the wait boundary cannot enter the flushed scope later",
+  );
+  assert.equal(unrelated.isCancelled(), false, "the fence must not cancel a different resolved scope");
+  unrelated.release();
+  reservation.release();
+});
+
+test("#2206 resolved scope overrides a mismatched preparation hint", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const preparation = tracker.reserve("opaque-session", "cwd:/workspace/project/src");
+  preparation.setScope("alice", "alice-project");
+  let settled = false;
+  const waitPromise = tracker
+    .wait(
+      "opaque-session",
+      "alice",
+      "alice-project",
+      undefined,
+      undefined,
+      "projectTag:Acme/Webshop",
+    )
+    .then(() => {
+      settled = true;
+    });
+
+  await Promise.resolve();
+  assert.equal(settled, false);
+  preparation.release();
+  await waitPromise;
+  assert.equal(settled, true);
+});
+
+test("#2206 resolved scope mismatch overrides an identical preparation hint", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const unrelated = tracker.reserve("opaque-session", "projectTag:project-a");
+  unrelated.setScope("alice", "alice-project-b");
+  let settled = false;
+  const waitPromise = tracker
+    .wait(
+      "opaque-session",
+      "alice",
+      "alice-project-a",
+      undefined,
+      undefined,
+      "projectTag:project-a",
+    )
+    .then(() => {
+      settled = true;
+    });
+
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  const settledBeforeUnrelatedRelease = settled;
+  unrelated.release();
+  await waitPromise;
+
+  assert.equal(settledBeforeUnrelatedRelease, true);
+});
+
+test("#2206 unresolved preparation without a hint remains a conservative barrier", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const preparation = tracker.reserve("opaque-session");
+  let settled = false;
+  const waitPromise = tracker
+    .wait(
+      "opaque-session",
+      "alice",
+      "alice-project",
+      undefined,
+      undefined,
+      "projectTag:project-a",
+    )
+    .then(() => {
+      settled = true;
+    });
+
+  await Promise.resolve();
+  assert.equal(settled, false);
+  preparation.release();
+  await waitPromise;
+  assert.equal(settled, true);
+});
+
+test("#2206 raw-hint cancellation only cancels matching preparations", async () => {
+  const tracker = new PendingObserveExtractionTracker();
+  const unresolved = tracker.reserve("opaque-session", "projectTag:project-a");
+  const resolved = tracker.reserve("opaque-session", "projectTag:project-a");
+  const unrelated = tracker.reserve("opaque-session", "projectTag:project-b");
+  resolved.setScope("alice", "alice-project-a");
+  let releaseExtraction!: () => void;
+  const extraction = new Promise<void>((resolve) => {
+    releaseExtraction = resolve;
+  });
+  const unrelatedController = new AbortController();
+  tracker.track(
+    tracker.key("opaque-session", "alice", "alice-project-b"),
+    extraction,
+    unrelatedController,
+  );
+
+  tracker.cancelPreparations("opaque-session", "projectTag:project-a");
+
+  assert.equal(unresolved.isCancelled(), true);
+  assert.equal(resolved.isCancelled(), true);
+  assert.equal(unrelated.isCancelled(), false);
+  assert.equal(unrelatedController.signal.aborted, false);
+  unresolved.release();
+  resolved.release();
+  unrelated.release();
+  releaseExtraction();
+  await extraction;
+});
+
 test("#2128 scoped observe preparation cancellation preserves another project", () => {
   const tracker = new PendingObserveExtractionTracker();
   const projectA = tracker.reserve("opaque-session", "projectTag:project-a");
@@ -256,7 +416,6 @@ test("#2128 scoped observe preparation cancellation preserves another project",
   projectB.release();
 });
 
-
 test("#2128 cancellation matches resolved scope despite a different request hint", () => {
   const tracker = new PendingObserveExtractionTracker();
   const preparation = tracker.reserve("session-z", "cwd:/workspace/project/src");