@remnic/core 9.45.3 → 9.45.5

package/src/access-operations-batch.ts

@@ -88,7 +88,7 @@ defineOperation({ name: "recall", description: "Semantic recall.", schema: stric
     if (input.tags !== undefined) { if (!Array.isArray(input.tags) || !input.tags.every((t) => typeof t === "string")) throw new EngramAccessInputError("tags must be an array of strings"); tags = input.tags; }
     let tagMatch: "any" | "all" | undefined;
     if (input.tagMatch !== undefined) { if (input.tagMatch !== "any" && input.tagMatch !== "all") throw new EngramAccessInputError("tagMatch must be one of: any, all"); tagMatch = input.tagMatch; }
-    const result = await ctx.service.recall({ query: typeof input.query === "string" ? input.query : "", sessionKey: optStr(input.sessionKey), authenticatedPrincipal: ctx.authenticatedPrincipal, namespace: optStr(input.namespace), topK: optNum(input.topK), mode: optStr(input.mode) as RecallPlanMode | "auto" | undefined, includeDebug: input.includeDebug === true, disclosure, cwd: optStr(input.cwd), projectTag: optStr(input.projectTag), asOf: optStr(input.asOf), ...(tags ? { tags } : {}), ...(tagMatch ? { tagMatch } : {}), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) });
+    const result = await ctx.service.recall({ query: typeof input.query === "string" ? input.query : "", sessionKey: optStr(input.sessionKey), authenticatedPrincipal: ctx.authenticatedPrincipal, sourceConnector: ctx.sourceConnector, namespace: optStr(input.namespace), topK: optNum(input.topK), mode: optStr(input.mode) as RecallPlanMode | "auto" | undefined, includeDebug: input.includeDebug === true, disclosure, cwd: optStr(input.cwd), projectTag: optStr(input.projectTag), asOf: optStr(input.asOf), ...(tags ? { tags } : {}), ...(tagMatch ? { tagMatch } : {}), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) });
     return { result };
   },
 });
@@ -115,7 +115,7 @@ defineOperation({ name: "recall_xray", description: "X-ray recall.", schema: str
     let budget: number | undefined;
     if (input.budget !== undefined) { const p = typeof input.budget === "number" ? input.budget : typeof input.budget === "string" ? Number(input.budget) : undefined; if (p === undefined || !Number.isFinite(p) || p <= 0 || !Number.isInteger(p)) throw new EngramAccessInputError("recall_xray: budget expects a positive integer"); budget = p; }
     const dr = optStr(input.disclosure);
-    return { result: await ctx.service.recallXray({ query: defStr(input.query, ""), sessionKey: optStr(input.sessionKey), namespace: optStr(input.namespace), budget, authenticatedPrincipal: ctx.authenticatedPrincipal, ...(dr && dr !== "" ? { disclosure: dr as RecallDisclosure } : {}), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) }) };
+    return { result: await ctx.service.recallXray({ query: defStr(input.query, ""), sessionKey: optStr(input.sessionKey), namespace: optStr(input.namespace), budget, authenticatedPrincipal: ctx.authenticatedPrincipal, sourceConnector: ctx.sourceConnector, ...(dr && dr !== "" ? { disclosure: dr as RecallDisclosure } : {}), ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) }) };
   },
 });
 defineOperation({ name: "namespace_writable", description: "Read-only preflight: is a namespace writable for the caller's principal?", allowedByOps: ["namespace_writable", "observe", "memory_store"], schema: strictSchema({ namespace: S.str, sessionKey: S.str, op: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => {
@@ -163,7 +163,7 @@ defineOperation({ name: "chatgpt_memory_inspector", description: "Memory inspect
     if (input.currentContextScopes !== undefined) ii.currentContextScopes = input.currentContextScopes as string[];
     if (input.allowUnverifiedPreview !== undefined) ii.allowUnverifiedPreview = input.allowUnverifiedPreview as boolean;
     const rsk = ii.sessionKey ?? (ctx.authenticatedPrincipal ? "remnic:chatgpt-memory-inspector:" + randomUUID() : undefined);
-    const xr = await ctx.service.recallXray({ query: ii.query, sessionKey: rsk, namespace: ii.namespace, currentContextScopes: ii.currentContextScopes, authenticatedPrincipal: ctx.authenticatedPrincipal, mode: "full", disclosure: "chunk", includeRecall: true, ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) });
+    const xr = await ctx.service.recallXray({ query: ii.query, sessionKey: rsk, namespace: ii.namespace, currentContextScopes: ii.currentContextScopes, authenticatedPrincipal: ctx.authenticatedPrincipal, ...(ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {}), mode: "full", disclosure: "chunk", includeRecall: true, ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}) });
     const x = xr.snapshotFound === true ? (xr.snapshot ?? null) : null;
     const r = xr.recall ?? { query: ii.query, namespace: ii.namespace ?? x?.namespace ?? "global", context: "", count: 0, memoryIds: [], results: [], fallbackUsed: false, sourcesUsed: [], disclosure: "chunk" as const };
     const ac = await ctx.service.actionConfidence(buildChatGptMemoryInspectorActionRequest(ii, r, x));

package/src/access-operations.ts

@@ -18,6 +18,7 @@ import { defineOperation } from "./access-boundary.js";
 import { memoryStoreRequestSchema, type MemoryStoreRequest } from "./access-schema.js";
 import { EngramAccessInputError } from "./access-service.js";
 import { CorrectionContractError } from "./correction/correction-contract.js";
+import { externalWikiSearchOperation } from "./external-wiki-access.js";
 import type {
   EngramAccessMemoryResponse,
   EngramAccessWriteResponse,
@@ -401,13 +402,16 @@ export const memoryCorrectPlanOperation = defineOperation<
   schema: memoryCorrectPlanSchema as z.ZodType<MemoryCorrectPlanInput>,
   handler: async (input, ctx) => {
     try {
-      const result = await ctx.service.correctionPlan({
-        text: input.text,
-        ...(input.targetIds ? { targetIds: input.targetIds } : {}),
-        ...(input.sessionKey ? { sessionKey: input.sessionKey } : {}),
-        ...(input.namespace ? { namespace: input.namespace } : {}),
-        ...(ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}),
-      });
+      const result = await ctx.service.correctionPlan(
+        {
+          text: input.text,
+          ...(input.targetIds ? { targetIds: input.targetIds } : {}),
+          ...(input.sessionKey ? { sessionKey: input.sessionKey } : {}),
+          ...(input.namespace ? { namespace: input.namespace } : {}),
+          ...(ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}),
+        },
+        ctx.abortSignal ? { abortSignal: ctx.abortSignal } : undefined,
+      );
       return { result };
     } catch (err) {
       if (err instanceof CorrectionContractError) throw new EngramAccessInputError(err.message);
@@ -461,6 +465,7 @@ export const memoryCorrectApplyOperation = defineOperation<
         ...(input.sessionKey ? { sessionKey: input.sessionKey } : {}),
         ...(input.namespace ? { namespace: input.namespace } : {}),
         ...(ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}),
+        ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
       });
       return { result };
     } catch (err) {
@@ -684,6 +689,7 @@ import "./relay/mission-access.js";
 export const REGISTERED_OPERATIONS = [
   memoryGetOperation.spec.name,
   memorySearchOperation.spec.name,
+  externalWikiSearchOperation.spec.name,
   memoryStoreOperation.spec.name,
   codingDecisionOperation.spec.name,
   codingArchitectureOperation.spec.name,

package/src/access-recall-concurrency.ts

@@ -13,7 +13,7 @@
  * module. `raceAbort` and `attachFlightAbort` need no host (they operate on the
  * caller signal / flight object alone).
  */
-import { abortError, throwIfAborted } from "./abort-error.js";
+import { abortError, raceAbort, throwIfAborted } from "./abort-error.js";
 import { hashAccessIdempotencyPayload } from "./access-idempotency.js";
 import {
   EngramAccessInputError,
@@ -27,6 +27,8 @@ import {
   toBudgetWarning,
 } from "./cross-namespace-budget.js";
 
+export { raceAbort } from "./abort-error.js";
+
 /**
  * Per-principal recall concurrency slot (issue #1906). `active` counts
  * in-flight recalls holding a permit; `waiters` is the FIFO queue of callers
@@ -199,32 +201,6 @@ export async function withRecallConcurrency<T>(
   }
 }
 
-/**
- * Race `p` against `signal` (issue #1906). A single-flight caller waits on
- * the shared flight promise but must be able to leave on its own abort. The
- * abort listener is removed as soon as the race settles (either `p` won or
- * the abort fired) so a settled-first promise never leaks a listener on a
- * long-lived signal.
- *
- * Pre-check the signal BEFORE building the race: an already-aborted signal
- * must win even when `p` is already fulfilled. `Promise.race` settles from
- * already-resolved members in array order, so a fulfilled `p` (index 0) would
- * otherwise beat the synchronously-rejected abort racer (index 1) and let an
- * aborted caller proceed into its own persistence + budget accounting before
- * the next abort check runs (round 15 #1).
- */
-export function raceAbort<T>(p: Promise<T>, signal?: AbortSignal): Promise<T> {
-  if (!signal) return p;
-  if (signal.aborted) return Promise.reject(abortError("operation aborted"));
-  let onAbort: (() => void) | undefined;
-  const racer = new Promise<never>((_resolve, reject) => {
-    onAbort = () => reject(abortError("operation aborted"));
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-  return Promise.race([p, racer]).finally(() => {
-    if (onAbort) signal.removeEventListener("abort", onAbort);
-  });
-}
 
 /**
  * Attach a caller to a single-flight recall (issue #1906 review). Increments

package/src/access-recall-surface.ts

@@ -862,6 +862,7 @@ export class AccessRecallSurface {
         contextComposition = composition;
       },
       ...(authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {}),
+      ...(request.sourceConnector ? { sourceConnector: request.sourceConnector } : {}),
       ...(asOf !== undefined ? { asOf } : {}),
       ...(request.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
       ...(request.abortSignal ? { abortSignal: request.abortSignal } : {}),
@@ -943,6 +944,7 @@ export class AccessRecallSurface {
     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
@@ -1095,6 +1097,7 @@ export class AccessRecallSurface {
           ...(authenticatedPrincipal
             ? { principalOverride: authenticatedPrincipal }
             : {}),
+          ...(request.sourceConnector ? { sourceConnector: request.sourceConnector } : {}),
           ...(request.currentContextScopes !== undefined
             ? { currentContextScopes: request.currentContextScopes }
             : {}),

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

@@ -474,10 +474,12 @@ test("health keeps namespace QMD failures scoped to the namespace", async () =>
   }
 });
 
-test("health surfaces extraction liveness as degraded when the buffer is non-empty and the watermark is stale", async () => {
+test("health surfaces extraction liveness as degraded when the buffer is non-empty and the watermark is stale", async (t) => {
+  const nowMs = Date.parse("2026-07-30T12:00:00.000Z");
+  t.mock.timers.enable({ apis: ["Date"], now: nowMs });
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-liveness-"));
   try {
-    const oldTs = new Date(Date.now() - 10_000).toISOString();
+    const oldTs = new Date(nowMs - 10_000).toISOString();
     const config = parseConfig({ memoryDir, qmdEnabled: false, extractionLiveness: { staleWindowMs: 1000 } });
     const service = new EngramAccessService({
       config,
@@ -506,16 +508,25 @@ test("health surfaces extraction liveness as degraded when the buffer is non-emp
     assert.equal(health.extraction.bufferedSessionCount, 3);
     assert.equal(health.extraction.pendingTurnCount, 12);
     assert.equal(health.extraction.lastExtractionAt, oldTs);
-    const oldestAge = health.extraction.oldestBufferedTurnAgeMs ?? -1;
-    assert.ok(
-      oldestAge >= 10_000 && oldestAge < 60_000,
-      `oldest buffered turn age reflects the ~10s offset, not merely non-negative (got ${oldestAge}ms)`,
-    );
+    assert.equal(health.extraction.oldestBufferedTurnAgeMs, 10_000);
     assert.ok(
       health.extraction.degradedReason !== null && health.extraction.degradedReason.length > 0,
       "degraded reason is populated",
     );
+    const scopedHealth = await tokenCapabilityStore.run(
+      { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+      () => service.health(),
+    );
+    assert.equal(scopedHealth.extraction.lastExtractionAt, null);
+    assert.equal(scopedHealth.extraction.degraded, true);
+    assert.equal(scopedHealth.extraction.bufferedSessionCount, 3);
+    assert.equal(scopedHealth.extraction.pendingTurnCount, 12);
+    assert.equal(scopedHealth.extraction.oldestBufferedTurnAgeMs, 10_000);
+    assert.match(scopedHealth.extraction.degradedReason ?? "", /3 buffered session/);
+    assert.match(scopedHealth.extraction.degradedReason ?? "", /12 turn\(s\) pending extraction/);
+    assert.doesNotMatch(scopedHealth.extraction.degradedReason ?? "", /last succeeded|unreadable/);
   } finally {
+    t.mock.timers.reset();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -672,6 +683,13 @@ test("health reports extraction liveness degraded when the buffer read fails (§
     assert.equal(health.extraction.degraded, true, "an unreadable buffer must not report a healthy pipeline");
     assert.match(health.extraction.degradedReason ?? "", /unreadable/);
     assert.match(health.extraction.degradedReason ?? "", /buffer file corrupt/);
+    const scopedHealth = await tokenCapabilityStore.run(
+      { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+      () => service.health(),
+    );
+    assert.equal(scopedHealth.extraction.lastExtractionAt, null);
+    assert.match(scopedHealth.extraction.degradedReason ?? "", /extraction buffer unreadable/);
+    assert.doesNotMatch(scopedHealth.extraction.degradedReason ?? "", /buffer file corrupt/);
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }
@@ -702,6 +720,13 @@ test("health reports extraction liveness degraded when the watermark (meta) read
     assert.equal(health.extraction.degraded, true, "an unreadable watermark must not report a healthy pipeline");
     assert.match(health.extraction.degradedReason ?? "", /watermark unreadable/);
     assert.match(health.extraction.degradedReason ?? "", /meta\.json unreadable/);
+    const scopedHealth = await tokenCapabilityStore.run(
+      { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+      () => service.health(),
+    );
+    assert.equal(scopedHealth.extraction.lastExtractionAt, null);
+    assert.match(scopedHealth.extraction.degradedReason ?? "", /extraction watermark unreadable/);
+    assert.doesNotMatch(scopedHealth.extraction.degradedReason ?? "", /meta\.json unreadable/);
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }

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,
@@ -910,19 +910,28 @@ test("#2128: post-flush retained cleanup is best effort and receives lifecycle g
   }]);
 });
 
-test("#2128: post-flush retained cleanup stops on abort or deadline", async () => {
+test("#2128: post-flush retained cleanup stops on abort or deadline", async (t) => {
   const probe = makeParityProbe(withSelfPolicyPrefix("pi-geek"));
-  (probe.orch as unknown as {
-    buffer: {
-      clearRetainedTurnsForSession(
+  let cleanupStarted: (() => void) | undefined;
+  const cleanupCalls: Array<{
+    sessionKey: string;
+    ownerPrincipal: string | undefined;
+    options: { abortSignal?: AbortSignal; deadlineMs?: number } | undefined;
+  }> = [];
+  Object.defineProperty(probe.orch, "buffer", {
+    configurable: true,
+    value: {
+      clearRetainedTurnsForSession: async (
         sessionKey: string,
         ownerPrincipal?: string,
         options?: { abortSignal?: AbortSignal; deadlineMs?: number },
-      ): Promise<void>;
-    };
-  }).buffer = {
-    clearRetainedTurnsForSession: async () => new Promise<void>(() => {}),
-  };
+      ) => {
+        cleanupCalls.push({ sessionKey, ownerPrincipal, options });
+        cleanupStarted?.();
+        return new Promise<void>(() => {});
+      },
+    },
+  });
   const service = new EngramAccessService(probe.orch);
   const abortController = new AbortController();
   setTimeout(() => abortController.abort(), 5).unref();
@@ -941,22 +950,173 @@ test("#2128: post-flush retained cleanup stops on abort or deadline", async () =
       ]),
     /extraction force-flush aborted/,
   );
+  assert.deepEqual(cleanupCalls[0], {
+    sessionKey: "pi-geek:cleanup-abort",
+    ownerPrincipal: "pi-geek",
+    options: { abortSignal: abortController.signal, deadlineMs: undefined },
+  });
 
+  const cleanupStartedPromise = new Promise<void>((resolve) => {
+    cleanupStarted = resolve;
+  });
+  t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: 0 });
+  const deadlineFlush = service.extractionForceFlush({
+    sessionKey: "pi-geek:cleanup-deadline",
+    authenticatedPrincipal: "pi-geek",
+    deadlineMs: 5,
+  });
+  await Promise.race([
+    cleanupStartedPromise,
+    new Promise<never>((_resolve, reject) =>
+      setImmediate(() => reject(new Error("deadline cleanup did not start"))),
+    ),
+  ]);
+  assert.deepEqual(cleanupCalls[1], {
+    sessionKey: "pi-geek:cleanup-deadline",
+    ownerPrincipal: "pi-geek",
+    options: { abortSignal: undefined, deadlineMs: 5 },
+  });
+  t.mock.timers.tick(5);
   await assert.rejects(
-    () =>
-      Promise.race([
-        service.extractionForceFlush({
-          sessionKey: "pi-geek:cleanup-deadline",
-          authenticatedPrincipal: "pi-geek",
-          deadlineMs: Date.now() + 5,
-        }),
-        new Promise<never>((_resolve, reject) =>
-          setTimeout(() => reject(new Error("deadline cleanup test timed out")), 100),
-        ),
-      ]),
+    deadlineFlush,
     /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 +1141,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 +1177,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",