@remnic/core 9.45.2 → 9.45.4

package/src/access-mcp.test.ts

@@ -7,7 +7,7 @@
  */
 
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -1283,3 +1283,97 @@ test("MCP graph_edge_decay_run: unrestricted and legacy tokens reach the handler
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+function readMcpResult(response: unknown): Record<string, unknown> {
+  assert.ok(response && typeof response === "object" && "result" in response);
+  const result = response.result;
+  assert.ok(result && typeof result === "object");
+  return Object.fromEntries(Object.entries(result));
+}
+
+test("MCP external_wiki_search exposes aliases and dispatches the stable result", async () => {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-mcp-external-wiki-"));
+  await mkdir(path.join(rootDir, "wiki"), { recursive: true });
+  await writeFile(
+    path.join(rootDir, "INDEX.md"),
+    "- [[wiki/retrieval|Retrieval Architecture]] - cited hybrid retrieval\n",
+    "utf8",
+  );
+  await writeFile(
+    path.join(rootDir, "wiki", "retrieval.md"),
+    "# Retrieval Architecture\n\nHybrid retrieval keeps cited sources.\n",
+    "utf8",
+  );
+  try {
+    const service = {
+      ...makeMockService(),
+      configRef: {
+        externalWikis: [{
+          id: "reading",
+          rootDir,
+          enabled: true,
+          pagesDir: "wiki",
+          indexFile: "INDEX.md",
+          indexInQmd: false,
+          includeInDefaultRecall: false,
+        }],
+      },
+    } as unknown as EngramAccessService;
+    const server = new EngramMcpServer(service);
+
+    const listed = await server.handleRequest({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/list",
+      params: {},
+    });
+    const listedResult = readMcpResult(listed);
+    assert.ok(Array.isArray(listedResult.tools));
+    const toolNames = listedResult.tools.flatMap((tool) =>
+      tool && typeof tool === "object" && "name" in tool && typeof tool.name === "string"
+        ? [tool.name]
+        : []
+    );
+    assert.ok(toolNames.includes("remnic.external_wiki_search"));
+    assert.ok(toolNames.includes("engram.external_wiki_search"));
+
+    let canonicalResult: unknown;
+    for (const name of ["remnic.external_wiki_search", "engram.external_wiki_search"]) {
+      const response = await server.handleRequest(makeToolRequest(name, {
+        query: "hybrid retrieval",
+        limit: 3,
+        wikiId: "reading",
+        maxCharsPerHit: 400,
+      }));
+      const result = readMcpResult(response);
+      assert.equal(result.isError, false);
+      assert.ok(result.structuredContent && typeof result.structuredContent === "object");
+      if (canonicalResult === undefined) canonicalResult = result.structuredContent;
+      else assert.deepEqual(result.structuredContent, canonicalResult);
+    }
+    assert.ok(canonicalResult && typeof canonicalResult === "object" && "hits" in canonicalResult);
+    assert.ok(Array.isArray(canonicalResult.hits));
+    assert.equal(canonicalResult.hits.length, 1);
+    const firstHit = canonicalResult.hits[0];
+    assert.ok(firstHit && typeof firstHit === "object" && "path" in firstHit);
+    assert.equal(firstHit.path, "wiki/retrieval.md");
+  } finally {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+test("MCP external_wiki_search rejects an empty query before service dispatch", async () => {
+  let configRead = false;
+  const service = {
+    ...makeMockService(),
+    get configRef() {
+      configRead = true;
+      return parseConfig({ memoryDir: os.tmpdir(), externalWikis: [] });
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(makeToolRequest("remnic.external_wiki_search", { query: "  " }));
+  assert.equal(readMcpResult(response).isError, true);
+  assert.equal(configRead, false);
+});

package/src/access-mcp.ts

@@ -43,7 +43,10 @@ import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { expandTildePath } from "./utils/path.js";
 
 import { applyToolOutputSchemas } from "./access-mcp-output-schemas.js";
-import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";import { MEETINGS_MCP_TOOLS } from "./meetings/mcp-tools.js";import { WEARABLES_MCP_TOOLS } from "./wearables/mcp-tools.js";
+import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";
+import { MEETINGS_MCP_TOOLS } from "./meetings/mcp-tools.js";
+import { WEARABLES_MCP_TOOLS } from "./wearables/mcp-tools.js";
+import { EXTERNAL_WIKI_MCP_TOOLS } from "./external-wiki-mcp-tools.js";
 import { abortError, isAbortError } from "./abort-error.js";
 type JsonRpcId = string | number | null;
 
@@ -152,16 +155,10 @@ function withToolAliases(tool: McpTool, emitLegacyTools = true): McpTool[] {
   return emitLegacyTools ? [canonicalTool, tool] : [canonicalTool];
 }
 
-/**
- * MCP tool name (legacy `engram.*` form, since {@link toLegacyToolName}
- * canonicalizes incoming calls) → boundary operation it dispatches through.
- * A tool appears here once its `access-operations.ts` registration lands and
- * its surface-local validation is deleted. The fitness test
- * (`access-surface-catalog.test.ts`) asserts this map and the catalog agree.
- */
 const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.memory_get": "memory_get",
   "engram.memory_search": "memory_search",
+  "engram.external_wiki_search": "external_wiki_search",
   "engram.memory_store": "memory_store",
   "engram.coding_decision": "coding_decision",
   "engram.coding_architecture": "coding_architecture",
@@ -1427,7 +1424,7 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-      // ── Memory search & debug tools ────────────────────────────────────
+      ...EXTERNAL_WIKI_MCP_TOOLS,
       {
         name: "engram.memory_search",
         description:
@@ -2740,6 +2737,7 @@ export class EngramMcpServer {
       const result = (await op.run(envelope, {
         service: this.service,
         authenticatedPrincipal: effectivePrincipal,
+        ...(sourceConnector ? { sourceConnector } : {}),
         ...(abortSignal ? { abortSignal } : {}),
       })) as { result: unknown };
       throwMcpAbort(abortSignal, "MCP recall aborted before postprocessing");

package/src/access-observe-helpers.ts

@@ -3,10 +3,31 @@ type PendingObservePreparation = {
   scopeHint?: string;
   principal?: string;
   namespace?: string;
+  scopeResolved: boolean;
+  resolvedScopeFences: Array<{ principal?: string; namespace?: string }>;
   released: Promise<void>;
   release: () => void;
 };
 
+function resolvedScopesMatch(
+  left: { principal?: string; namespace?: string },
+  right: { principal?: string; namespace?: string },
+): boolean {
+  return left.principal === right.principal && left.namespace === right.namespace;
+}
+
+function preparationMatchesScope(
+  reservation: PendingObservePreparation,
+  principal: string | undefined,
+  namespace: string | undefined,
+  scopeHint: string | undefined,
+): boolean {
+  if (reservation.scopeResolved) {
+    return resolvedScopesMatch(reservation, { principal, namespace });
+  }
+  return reservation.scopeHint === undefined || scopeHint === undefined || reservation.scopeHint === scopeHint;
+}
+
 export type PendingObservePreparationHandle = {
   isCancelled(): boolean;
   setScope(principal?: string, namespace?: string): void;
@@ -40,6 +61,8 @@ export class PendingObserveExtractionTracker {
     let resolveReleased: () => void = () => {};
     const reservation: PendingObservePreparation = {
       cancelled: false,
+      scopeResolved: false,
+      resolvedScopeFences: [],
       scopeHint,
       released: new Promise<void>((resolve) => {
         resolveReleased = resolve;
@@ -61,15 +84,38 @@ export class PendingObserveExtractionTracker {
       setScope: (principal, namespace) => {
         reservation.principal = principal;
         reservation.namespace = namespace;
+        reservation.scopeResolved = true;
+        if (reservation.resolvedScopeFences.some((fence) => resolvedScopesMatch(reservation, fence))) {
+          reservation.cancelled = true;
+        }
       },
       release: reservation.release,
     };
   }
 
-  private async waitForPreparations(sessionKey: string): Promise<void> {
+  private async waitForPreparations(
+    sessionKey: string,
+    principal: string | undefined,
+    namespace: string | undefined,
+    scopeHint: string | undefined,
+  ): Promise<void> {
     while (true) {
-      const pending = [...(this.preparations.get(sessionKey) ?? [])].filter(
-        (reservation) => !reservation.cancelled,
+      const reservations = [...(this.preparations.get(sessionKey) ?? [])];
+      for (const reservation of reservations) {
+        if (
+          !reservation.cancelled &&
+          !reservation.scopeResolved &&
+          !preparationMatchesScope(reservation, principal, namespace, scopeHint) &&
+          !reservation.resolvedScopeFences.some((fence) =>
+            resolvedScopesMatch(fence, { principal, namespace }),
+          )
+        ) {
+          reservation.resolvedScopeFences.push({ principal, namespace });
+        }
+      }
+      const pending = reservations.filter(
+        (reservation) =>
+          !reservation.cancelled && preparationMatchesScope(reservation, principal, namespace, scopeHint),
       );
       if (pending.length === 0) return;
       await Promise.all(pending.map((reservation) => reservation.released));
@@ -103,6 +149,19 @@ export class PendingObserveExtractionTracker {
       });
   }
 
+  cancelPreparations(sessionKey: string, scopeHint?: string): void {
+    for (const reservation of this.preparations.get(sessionKey) ?? []) {
+      if (
+        scopeHint !== undefined &&
+        reservation.scopeHint !== undefined &&
+        reservation.scopeHint !== scopeHint
+      ) {
+        continue;
+      }
+      reservation.cancelled = true;
+    }
+  }
+
   cancel(
     sessionKey: string,
     principal?: string,
@@ -110,24 +169,7 @@ export class PendingObserveExtractionTracker {
     scopeHint?: string,
   ): void {
     for (const reservation of this.preparations.get(sessionKey) ?? []) {
-      const principalMatches =
-        principal === undefined ||
-        reservation.principal === undefined ||
-        reservation.principal === principal;
-      const namespaceMatches =
-        namespace === undefined ||
-        reservation.namespace === undefined ||
-        reservation.namespace === namespace;
-      const resolvedScopeMatches =
-        namespace !== undefined &&
-        reservation.namespace === namespace &&
-        principalMatches;
-      const scopeHintMismatch =
-        (reservation.scopeHint !== undefined && reservation.scopeHint !== scopeHint) ||
-        (reservation.scopeHint === undefined && scopeHint !== undefined);
-      if ((!resolvedScopeMatches && scopeHintMismatch) || !principalMatches || !namespaceMatches) {
-        continue;
-      }
+      if (!preparationMatchesScope(reservation, principal, namespace, scopeHint)) continue;
       reservation.cancelled = true;
     }
 
@@ -158,7 +200,7 @@ export class PendingObserveExtractionTracker {
     registerCancellation?.(abortTracked);
     abortSignal?.addEventListener("abort", abortTracked, { once: true });
     try {
-      await this.waitForPreparations(sessionKey);
+      await this.waitForPreparations(sessionKey, principal, namespace, scopeHint);
       while (true) {
         const entry = this.entries.get(key);
         if (!entry) return;

package/src/access-observe-write-surface.ts

@@ -110,6 +110,10 @@ export interface AccessObserveWriteSurfaceDeps {
       authenticatedPrincipal?: string;
     }
   ): Promise<MemoryScopePlan>;
+  cancelPendingObservePreparations?(
+    sessionKey: string,
+    scopeHint?: string,
+  ): void;
   cancelPendingObserveExtractions?(
     sessionKey: string,
     principal?: string,
@@ -132,6 +136,10 @@ export class AccessObserveWriteSurface {
   private quarantineStoreInstance?: WriteQuarantineStore;
   private readonly pendingObserveExtractions = new PendingObserveExtractionTracker();
 
+  public cancelPendingObservePreparations(sessionKey: string, scopeHint?: string): void {
+    this.pendingObserveExtractions.cancelPreparations(sessionKey, scopeHint);
+  }
+
   public cancelPendingObserveExtractions(
     sessionKey: string,
     principal?: string,

package/src/access-offline-manifest.ts

@@ -0,0 +1,54 @@
+import * as nodePath from "node:path";
+import type { Orchestrator } from "./orchestrator.js";
+import { iterateOfflineSyncSnapshotFileRecords } from "./offline-sync.js";
+import { offlineSyncStorageForSnapshot } from "./offline-sync-impression-drain.js";
+import {
+  buildReconcileManifestFile,
+  RECONCILE_MANIFEST_FORMAT,
+  RECONCILE_MANIFEST_SCHEMA_VERSION,
+  type ReconcileManifest,
+  type ReconcileManifestFile,
+  type ReconcileMemoryParser,
+} from "./reconcile/manifest.js";
+
+export interface OfflineSyncManifestRequest {
+  includeTranscripts?: boolean;
+  signal?: AbortSignal;
+}
+
+export interface OfflineSyncManifestStreamResponse extends Omit<ReconcileManifest, "files"> {
+  namespace: string;
+  files: AsyncIterable<ReconcileManifestFile>;
+}
+
+export async function createOfflineSyncManifestStream(
+  orchestrator: Orchestrator,
+  namespace: string,
+  userExcludeRegexps: RegExp[],
+  options: OfflineSyncManifestRequest,
+  parseMemory: ReconcileMemoryParser,
+): Promise<OfflineSyncManifestStreamResponse> {
+  const storage = await offlineSyncStorageForSnapshot(orchestrator, namespace);
+  const snapshotFiles = iterateOfflineSyncSnapshotFileRecords({
+    root: storage.dir,
+    includeContent: false,
+    includeTranscripts: options.includeTranscripts !== false,
+    readFileDigest: async ({ filePath }) => storage.digestOfflineSyncFile(filePath),
+    signal: options.signal,
+    userExcludeRegexps,
+  });
+  return {
+    namespace,
+    format: RECONCILE_MANIFEST_FORMAT,
+    schemaVersion: RECONCILE_MANIFEST_SCHEMA_VERSION,
+    files: (async function* () {
+      for await (const file of snapshotFiles) {
+        yield await buildReconcileManifestFile(
+          file,
+          async ({ path }) => storage.readOfflineSyncFile(nodePath.join(storage.dir, path)),
+          parseMemory,
+        );
+      }
+    })(),
+  };
+}

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, 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 });
   }