@remnic/core 9.45.3 → 9.45.5

package/src/orchestration/extraction-run-helpers.ts

@@ -309,11 +309,11 @@ export async function runExtractionPostPersist(
 }
 
 /**
- * Advance the extraction liveness watermark for a successfully parsed empty
- * extraction (#2223) and record its processed fingerprint when applicable.
- * Fingerprinted/import runs treat the metadata save as load-bearing (dedupe
- * state) and propagate failures; normal live runs treat the stamp as
- * diagnostic liveness and fail open. Deadline errors always propagate.
+ * Record a processed fingerprint when applicable and advance the extraction
+ * liveness watermark only for a provider-backed empty success. Fingerprinted
+ * imports treat the metadata save as load-bearing dedupe state; normal live
+ * runs treat the stamp as diagnostic and fail open. Deadline errors always
+ * propagate.
  */
 export async function commitEmptySuccessExtraction(args: {
   storage: StorageManager;
@@ -321,6 +321,7 @@ export async function commitEmptySuccessExtraction(args: {
   extractionFingerprint: string | null;
   shouldPersistProcessedFingerprint: boolean;
   hasExtractionFailure: boolean;
+  extractionSkippedReason: ExtractionResult["extractionSkippedReason"];
   recordProcessedExtractionFingerprint: (storage: StorageManager, fingerprint: string, meta: MetaState) => Promise<unknown>;
   runDeadlineAware: <T>(operation: () => Promise<T>, phase: string, clearTimerOnError?: boolean) => Promise<T>;
   isDeadlineError: (error: unknown) => boolean;
@@ -331,26 +332,43 @@ export async function commitEmptySuccessExtraction(args: {
     extractionFingerprint,
     shouldPersistProcessedFingerprint,
     hasExtractionFailure,
+    extractionSkippedReason,
     recordProcessedExtractionFingerprint,
     runDeadlineAware,
     isDeadlineError,
   } = args;
-  let meta = existingMeta;
-  if (extractionFingerprint && shouldPersistProcessedFingerprint && !hasExtractionFailure) {
-    meta ??= await storage.loadMeta();
-    await recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
-  }
-  if (!hasExtractionFailure) {
-    const livenessStampFatal = shouldPersistProcessedFingerprint;
-    try {
-      meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_empty_success_liveness_load", false);
+  const shouldRecordFingerprint =
+    extractionFingerprint !== null &&
+    shouldPersistProcessedFingerprint &&
+    !hasExtractionFailure;
+  const shouldStampLiveness =
+    !hasExtractionFailure && extractionSkippedReason === undefined;
+  if (!shouldRecordFingerprint && !shouldStampLiveness) return;
+
+  const metadataFailureIsFatal = shouldRecordFingerprint;
+  try {
+    const meta =
+      existingMeta ??
+      await runDeadlineAware(
+        () => storage.loadMeta(),
+        "during_empty_success_liveness_load",
+        false,
+      );
+    if (shouldRecordFingerprint) {
+      await recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
+    }
+    if (shouldStampLiveness) {
       meta.extractionCount += 1;
       meta.lastExtractionAt = new Date().toISOString();
-      await runDeadlineAware(() => storage.saveMeta(meta!), "during_empty_success_liveness_save", false);
-    } catch (err) {
-      if (isDeadlineError(err)) throw err;
-      if (livenessStampFatal) throw err;
-      log.warn("runExtraction: failed to stamp empty-success liveness watermark (non-fatal)", err);
     }
+    await runDeadlineAware(
+      () => storage.saveMeta(meta),
+      "during_empty_success_liveness_save",
+      false,
+    );
+  } catch (err) {
+    if (isDeadlineError(err)) throw err;
+    if (metadataFailureIsFatal) throw err;
+    log.warn("runExtraction: failed to stamp empty-success liveness watermark (non-fatal)", err);
   }
 }

package/src/orchestration/extraction-run.test.ts

@@ -93,7 +93,11 @@ interface Harness {
   setRespond: (fn: (turns: BufferTurn[]) => ExtractionResult | Promise<ExtractionResult>) => void;
   setPassiveCapture: (fn: () => void | Promise<void>) => void;
   setMemoryBox: (fn: () => void | Promise<void>) => void;
+  setBufferClear: (fn: () => void | Promise<void>) => void;
   setPersist: (fn: () => void | Promise<void>) => void;
+  setFingerprintRecorder: (
+    fn: ExtractionRunCoordinatorDeps["recordProcessedExtractionFingerprint"],
+  ) => void;
   recordedProcessedCount: () => number;
   run: (
     coord: ExtractionRunCoordinator,
@@ -140,6 +144,9 @@ async function makeHarness(overrides: Record<string, unknown> = {}): Promise<Har
   let persistHandler: () => void | Promise<void> = async () => {};
   let memoryBoxHandler: () => void | Promise<void> = async () => {};
   let recordedProcessedCount = 0;
+  let fingerprintRecorder:
+    ExtractionRunCoordinatorDeps["recordProcessedExtractionFingerprint"] =
+      async () => {};
 
   let threadingBlocked = false;
   let persistCalls = 0;
@@ -184,8 +191,9 @@ async function makeHarness(overrides: Record<string, unknown> = {}): Promise<Har
     requestQmdMaintenance: () => {},
     runTierMigrationCycle: async () => migrationSummary,
     getLastPersistExtractionDeferredCount: () => 0,
-    recordProcessedExtractionFingerprint: async () => {
+    recordProcessedExtractionFingerprint: async (storage, fingerprint, meta) => {
       recordedProcessedCount += 1;
+      await fingerprintRecorder(storage, fingerprint, meta);
     },
   });
 
@@ -210,6 +218,14 @@ async function makeHarness(overrides: Record<string, unknown> = {}): Promise<Har
     setMemoryBox: (fn) => {
       memoryBoxHandler = fn;
     },
+    setBufferClear: (fn) => {
+      buffer.clearAfterExtraction = async () => {
+        await fn();
+      };
+    },
+    setFingerprintRecorder: (fn) => {
+      fingerprintRecorder = fn;
+    },
     setPersist: (fn) => {
       persistHandler = fn;
     },
@@ -685,6 +701,32 @@ test("circuit breaker: a forced flush still calls extract() while the breaker is
   }
 });
 
+test("circuit breaker: a forced local prefilter skip does not heal an open breaker", async () => {
+  const h = await makeHarness({
+    extractionRetryScheduleMs: [3_600_000],
+    extractionBreakerFailureThreshold: 1,
+    extractionBreakerCooldownMs: 3_600_000,
+  });
+  try {
+    const coord = h.newCoordinator();
+    h.setRespond(() => failureResult("provider_retryable"));
+    await h.run(coord, "fp-1");
+    assert.equal(coord.getExtractionResilienceStatus().breaker.state, "open");
+
+    h.setRespond(() => ({
+      ...emptySuccessResult(),
+      extractionSkippedReason: "mechanical_telemetry",
+    }));
+    const result = await h.run(coord, "fp-2", { force: true });
+
+    assert.equal(result.reason, "empty_extraction_result");
+    assert.equal(coord.getExtractionResilienceStatus().breaker.state, "open");
+    assert.equal(coord.getExtractionResilienceStatus().breaker.consecutiveFailures, 1);
+  } finally {
+    await h.cleanup();
+  }
+});
+
 test("circuit breaker: auth_config failure opens the breaker immediately (no hot loop)", async () => {
   const h = await makeHarness({
     extractionRetryScheduleMs: [3_600_000],
@@ -1013,7 +1055,7 @@ test("extraction liveness (#2223): a normal live empty success advances lastExtr
     const result = await coord.runExtraction(liveTurns("nothing-durable-here"), {
       skipCharThreshold: true,
       skipUserTurnThreshold: true,
-      clearBufferAfterExtraction: false,
+      clearBufferAfterExtraction: true,
       bufferKey: "nothing-durable-here",
     });
 
@@ -1030,6 +1072,133 @@ test("extraction liveness (#2223): a normal live empty success advances lastExtr
   }
 });
 
+test("extraction liveness (#2227): prefilter skips do not advance the watermark", async () => {
+  for (const extractionSkippedReason of [
+    "conversation_only_non_memory",
+    "mechanical_telemetry",
+  ] as const) {
+    const h = await makeHarness();
+    try {
+      h.setRespond(() => ({ ...emptySuccessResult(), extractionSkippedReason }));
+      const storage = await h.storageForNs("default");
+      const before = await storage.loadMeta();
+
+      const result = await h.newCoordinator().runExtraction(liveTurns(extractionSkippedReason), {
+        skipCharThreshold: true,
+        skipUserTurnThreshold: true,
+        clearBufferAfterExtraction: true,
+        bufferKey: extractionSkippedReason,
+      });
+
+      assert.equal(result.reason, "empty_extraction_result");
+      const after = await storage.loadMeta();
+      assert.equal(after.extractionCount, before.extractionCount);
+      assert.equal(after.lastExtractionAt, before.lastExtractionAt);
+    } finally {
+      await h.cleanup();
+    }
+  }
+});
+
+test("extraction liveness (#2227): passive-correction failure prevents a live empty-success stamp", async () => {
+  const h = await makeHarness();
+  try {
+    h.setRespond(() => emptySuccessResult());
+    h.setPassiveCapture(() => {
+      throw new Error("passive capture failed");
+    });
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+
+    await assert.rejects(
+      h.newCoordinator().runExtraction(liveTurns("passive-capture-failure"), {
+        skipCharThreshold: true,
+        skipUserTurnThreshold: true,
+        clearBufferAfterExtraction: true,
+        bufferKey: "passive-capture-failure",
+      }),
+      /passive capture failed/,
+    );
+
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, before.extractionCount);
+    assert.equal(after.lastExtractionAt, before.lastExtractionAt);
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("extraction liveness (#2227): buffer-clear failure prevents a live empty-success stamp", async () => {
+  const h = await makeHarness();
+  try {
+    h.setRespond(() => emptySuccessResult());
+    h.setBufferClear(() => {
+      throw new Error("buffer clear failed");
+    });
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+
+    await assert.rejects(
+      h.newCoordinator().runExtraction(liveTurns("buffer-clear-failure"), {
+        skipCharThreshold: true,
+        skipUserTurnThreshold: true,
+        clearBufferAfterExtraction: true,
+        bufferKey: "buffer-clear-failure",
+      }),
+      /buffer clear failed/,
+    );
+
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, before.extractionCount);
+    assert.equal(after.lastExtractionAt, before.lastExtractionAt);
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("extraction liveness (#2227): a fingerprinted prefilter skip persists dedupe state without stamping liveness", async () => {
+  const h = await makeHarness();
+  try {
+    h.setRespond(() => ({
+      ...emptySuccessResult(),
+      extractionSkippedReason: "mechanical_telemetry",
+    }));
+    h.setFingerprintRecorder(async (_storage, fingerprint, meta) => {
+      assert.ok(meta, "empty-success commit supplies preloaded metadata");
+      meta.processedExtractionFingerprints = [
+        ...(meta.processedExtractionFingerprints ?? []),
+        { fingerprint, observedAt: new Date().toISOString() },
+      ];
+    });
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+    const baselineFingerprintCount =
+      before.processedExtractionFingerprints?.length ?? 0;
+
+    const result = await h.newCoordinator().runExtraction(
+      makeTurns("fingerprinted-prefilter"),
+      {
+        skipCharThreshold: true,
+        skipUserTurnThreshold: true,
+        clearBufferAfterExtraction: true,
+        bufferKey: "fingerprinted-prefilter",
+      },
+    );
+
+    assert.equal(result.reason, "empty_extraction_result");
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, before.extractionCount);
+    assert.equal(after.lastExtractionAt, before.lastExtractionAt);
+    assert.equal(
+      after.processedExtractionFingerprints?.length,
+      baselineFingerprintCount + 1,
+    );
+    assert.equal(h.recordedProcessedCount(), 1);
+  } finally {
+    await h.cleanup();
+  }
+});
+
 test("extraction liveness (#2223): a fingerprinted empty success advances the watermark once and records the fingerprint once", async () => {
   const h = await makeHarness();
   try {

package/src/orchestration/extraction-run.ts

@@ -979,7 +979,7 @@ export class ExtractionRunCoordinator {
           // pre-#1908 clear-buffer behavior applies below.
           log.warn("runExtraction: failed to load meta for retry bookkeeping (non-fatal)", err);
         }
-      } else {
+      } else if (result.extractionSkippedReason === undefined) {
         // Provider responded without failure → breaker heals; clear any
         // parked backoff for this fingerprint so it proceeds normally.
         this.resetProviderBreakerOnSuccess();
@@ -1016,19 +1016,20 @@ export class ExtractionRunCoordinator {
           { extractionFailure }
         );
       }
-      await commitEmptySuccessExtraction({
+      const emptySuccessCommit = {
         storage,
         meta,
         extractionFingerprint,
         shouldPersistProcessedFingerprint,
         hasExtractionFailure: Boolean(extractionFailure),
+        extractionSkippedReason: result.extractionSkippedReason,
         recordProcessedExtractionFingerprint: this.deps.recordProcessedExtractionFingerprint,
         runDeadlineAware,
-        isDeadlineError: (error) => error instanceof ExtractionDeadlineError,
-      });
-      // Correction-only turns that meet char/user-turn thresholds but yield
-      // zero facts still need passive capture (review: "empty extraction skips
-      // capture"). selfNamespace/principal already resolved above.
+        isDeadlineError: (error: unknown) => error instanceof ExtractionDeadlineError,
+      };
+      if (shouldPersistProcessedFingerprint) {
+        await commitEmptySuccessExtraction(emptySuccessCommit);
+      }
       await runPassiveCapture(normalizedTurns as BufferTurn[], {
         sessionKey,
         principal,
@@ -1037,16 +1038,13 @@ export class ExtractionRunCoordinator {
         isLiveSession: clearBufferAfterExtraction,
       });
       if (recordedRetryFailure) {
-        // Retain the failed turns so the backoff gate can re-attempt them after
-        // nextEligibleAt. Clearing here would lose the data the retry state
-        // points at (cursor high + codex P1). Trigger/forced paths already
-        // retain via clearBufferAfterExtraction=false; this covers the normal
-        // live-session path. Overflow is bounded by MAX_BUFFER_ENTRY_COUNT
-        // with a loud eviction log.
         log.debug("runExtraction: retaining buffer for backoff retry after failure");
       } else {
         await clearBuffer();
       }
+      if (!shouldPersistProcessedFingerprint) {
+        await commitEmptySuccessExtraction(emptySuccessCommit);
+      }
       return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
     }
 

package/src/orchestration/extraction-watermark.ts

@@ -36,12 +36,11 @@ export interface AggregateExtractionWatermarkOptions {
   caps?: TokenCapabilities;
 }
 
-function readFailure(reason: string, rootStats?: ExtractionRootStats): ExtractionWatermarkRead {
+function readFailure(reason: string): ExtractionWatermarkRead {
   return {
     lastExtractionAt: null,
     readFailed: true,
     readError: reason,
-    ...(rootStats ? { rootStats } : {}),
   };
 }
 
@@ -49,12 +48,101 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+const ISO_TIMESTAMP_PATTERN =
+  /^([+-]?\d{4,6})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(?:\.(\d+))?(Z|[+-]\d{2}:?\d{2})$/i;
+
+function validatedTimestampMs(value: string): number | null {
+  const match = ISO_TIMESTAMP_PATTERN.exec(value);
+  const parsed = Date.parse(value);
+  if (!match || !Number.isFinite(parsed)) return null;
+  const [, yearText, monthText, dayText, hourText, minuteText, secondText, fraction, zone] = match;
+  const normalizedZone = zone.toUpperCase();
+  const offsetMinuteText = normalizedZone.includes(":")
+    ? normalizedZone.slice(4, 6)
+    : normalizedZone.slice(3, 5);
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const hour = Number(hourText);
+  const minute = Number(minuteText);
+  const second = secondText !== undefined ? Number(secondText) : 0;
+  const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth[month - 1]!) return null;
+  if (hour === 24) {
+    const isEndOfDay = minute === 0 && second === 0 && /^0*$/.test(fraction ?? "");
+    return isEndOfDay ? parsed : null;
+  }
+  const zoneSign = normalizedZone === "Z" || normalizedZone[0] === "+" ? 1 : -1;
+  const offsetMinutes =
+    normalizedZone === "Z"
+      ? 0
+      : zoneSign * (Number(normalizedZone.slice(1, 3)) * 60 + Number(offsetMinuteText));
+  const representedCalendar = new Date(parsed + offsetMinutes * 60_000);
+  const millisecond = Number((fraction ?? "").padEnd(3, "0").slice(0, 3));
+  const expected = [
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    second,
+    millisecond,
+  ];
+  const actual = [
+    representedCalendar.getUTCFullYear(),
+    representedCalendar.getUTCMonth() + 1,
+    representedCalendar.getUTCDate(),
+    representedCalendar.getUTCHours(),
+    representedCalendar.getUTCMinutes(),
+    representedCalendar.getUTCSeconds(),
+    representedCalendar.getUTCMilliseconds(),
+  ];
+  return actual.every((part, index) => part === expected[index]) ? parsed : null;
+}
+
+function mergeRootStats(
+  current: ExtractionRootStats | undefined,
+  candidate: ExtractionRootStats | undefined,
+): ExtractionRootStats | undefined {
+  if (!current && !candidate) return undefined;
+  const currentCount = current?.extractionCount;
+  const candidateCount = candidate?.extractionCount;
+  const extractionCount =
+    currentCount === undefined && candidateCount === undefined
+      ? undefined
+      : (currentCount ?? 0) + (candidateCount ?? 0);
+  const currentConsolidation = current?.lastConsolidationAt;
+  const candidateConsolidation = candidate?.lastConsolidationAt;
+  const hasConsolidation =
+    currentConsolidation !== undefined || candidateConsolidation !== undefined;
+  return {
+    ...(extractionCount === undefined ? {} : { extractionCount }),
+    ...(hasConsolidation
+      ? {
+          lastConsolidationAt: newerWatermark(
+            currentConsolidation ?? null,
+            candidateConsolidation ?? null,
+          ),
+        }
+      : {}),
+  };
+}
+
 function watermarkFromMeta(meta: ExtractionWatermarkMeta, name: string): ExtractionWatermarkRead {
-  if (meta.lastExtractionAt !== null && meta.lastExtractionAt !== undefined) {
-    const parsed = Date.parse(meta.lastExtractionAt);
-    if (!Number.isFinite(parsed)) {
-      return readFailure(`${name} watermark timestamp invalid`);
-    }
+  if (
+    meta.lastExtractionAt !== null &&
+    meta.lastExtractionAt !== undefined &&
+    validatedTimestampMs(meta.lastExtractionAt) === null
+  ) {
+    return readFailure(`${name} watermark timestamp invalid`);
+  }
+  if (
+    meta.lastConsolidationAt !== null &&
+    meta.lastConsolidationAt !== undefined &&
+    validatedTimestampMs(meta.lastConsolidationAt) === null
+  ) {
+    return readFailure(`${name} consolidation timestamp invalid`);
   }
   const hasRootStats = meta.extractionCount !== undefined || meta.lastConsolidationAt !== undefined;
   return {
@@ -107,11 +195,11 @@ function isReadFailure(value: CorpusNamespaceRoot[] | ExtractionWatermarkRead):
 
 function newerWatermark(current: string | null, candidate: string | null): string | null {
   if (candidate === null) return current;
-  const candidateMs = Date.parse(candidate);
-  if (!Number.isFinite(candidateMs)) return current;
+  const candidateMs = validatedTimestampMs(candidate);
+  if (candidateMs === null) return current;
   if (current === null) return candidate;
-  const currentMs = Date.parse(current);
-  return !Number.isFinite(currentMs) || candidateMs > currentMs ? candidate : current;
+  const currentMs = validatedTimestampMs(current);
+  return currentMs === null || candidateMs > currentMs ? candidate : current;
 }
 
 export async function readAggregateExtractionWatermark(
@@ -155,10 +243,13 @@ export async function readAggregateExtractionWatermark(
     (!options.caps || capabilityAllowsNamespace(options.caps, defaultNamespace));
   let rootRead: ExtractionWatermarkRead = { lastExtractionAt: null, readFailed: false };
   if (canAccessRoot) {
-    rootRead = await readWatermark(options.rootStorage, "root store");
+    rootRead = options.rootMeta
+      ? watermarkFromMeta(options.rootMeta, "root store")
+      : await readWatermark(options.rootStorage, "root store");
     if (rootRead.readFailed) return rootRead;
   }
   let lastExtractionAt = rootRead.lastExtractionAt;
+  let rootStats = rootRead.rootStats;
 
   const reads = await Promise.all(
     targets.map(async (target) => {
@@ -173,16 +264,14 @@ export async function readAggregateExtractionWatermark(
 
   for (const read of reads) {
     if (read.readFailed) {
-      return readFailure(
-        read.readError ?? "namespace watermark unreadable",
-        rootRead.rootStats
-      );
+      return readFailure(read.readError ?? "namespace watermark unreadable");
     }
     lastExtractionAt = newerWatermark(lastExtractionAt, read.lastExtractionAt);
+    rootStats = mergeRootStats(rootStats, read.rootStats);
   }
   return {
     lastExtractionAt,
     readFailed: false,
-    ...(rootRead.rootStats ? { rootStats: rootRead.rootStats } : {}),
+    ...(rootStats ? { rootStats } : {}),
   };
 }

package/src/orchestration/generic-recall-paths.ts

@@ -1,5 +1,7 @@
 import path from "node:path";
 import type { QmdSearchResult } from "../types.js";
+import { isExternalWikiCollectionName } from "../external-wiki-guard.js";
+export { isExternalWikiCollectionName } from "../external-wiki-guard.js";
 import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
 import {
   isActivityDigestPath,
@@ -81,12 +83,24 @@ export function isTopLevelArchivePath(
   return /^(?:archive|namespaces[\\/][^\\/]+[\\/]archive)(?:[\\/]|$)/i.test(normalized);
 }
 
+function isExternalWikiQmdPath(
+  filePath: string,
+  source: GenericRecallPathSource,
+): boolean {
+  if (source !== "qmd") return false;
+  const normalized = normalizeQmdUriPath(filePath, source).replace(/\\/g, "/");
+  const slashIndex = normalized.indexOf("/");
+  const collection = slashIndex === -1 ? normalized : normalized.slice(0, slashIndex);
+  return isExternalWikiCollectionName(collection);
+}
+
 export function isGenericRecallExcludedPath(
   filePath: string,
   policy: GenericRecallPathPolicy = {},
   source: GenericRecallPathSource = "filesystem",
 ): boolean {
   return (
+    isExternalWikiQmdPath(filePath, source) ||
     isArtifactMemoryPath(filePath) ||
     isActivityDigestPath(filePath, policy.memoryDir) ||
     isTopLevelArchivePath(filePath, policy, source) ||

package/src/orchestration/orchestrator-helpers.ts

@@ -197,6 +197,8 @@ export interface RecallInvocationOptions {
   topK?: number;
   mode?: RecallPlanMode;
   abortSignal?: AbortSignal;
+  /** Server-resolved identity of the connector performing this recall. */
+  sourceConnector?: string;
   /**
    * Capture a `RecallXraySnapshot` for this recall (issue #570).  When
    * `true`, the orchestrator builds a snapshot from the data it has

package/src/orchestration/orchestrator-init.ts

@@ -26,6 +26,7 @@ import type { ConversationIndexBackend } from "../conversation-index/backend.js"
 import type { CorrectionService } from "../correction/correction-service.js";
 import { EmbeddingFallback } from "../embedding-fallback.js";
 import { ContentHashIndex, StorageManager } from "../index.js";
+import { assertExternalWikiRootOutsideMemoryDirCanonical } from "../external-wiki-guard.js";
 import { log } from "../logger.js";
 import { migrateFromEngram } from "../migrate/from-engram.js";
 import { NamespaceCatalog } from "../namespaces/catalog.js";
@@ -118,6 +119,14 @@ export class OrchestratorInitCoordinator {
       });
       await this.deps.storage.loadAliases();
       await this.deps.storage.ensureDirectories();
+      await Promise.all(
+        this.deps.config.externalWikis.map((wiki) =>
+          assertExternalWikiRootOutsideMemoryDirCanonical(
+            this.deps.config.memoryDir,
+            wiki.rootDir,
+          ),
+        ),
+      );
       if (resolveNamespaceCapabilities(this.deps.config).namespaces) {
         const namespaces = new Set<string>([
           this.deps.config.defaultNamespace,

package/src/orchestration/recall-internal-deps.ts

@@ -34,6 +34,7 @@ import type { CodingContext, EngramTraceEvent, IdentityInjectionMode, MemoryFile
 import type { VerifiedEpisodeResult } from "../verified-recall.js";
 import type { WorkProductLedgerSearchResult } from "../work-product-ledger.js";
 import type { GraphRecallRankedResult, GraphRecallShadowComparison } from "./graph-recall-coordinator.js";
+import type { RecallRerankCoordinator, RecallResultPartitionSink } from "./recall-rerank-coordinator.js";
 import type { RecallSectionAppendOptions, RecallSectionBuckets } from "./recall-section-coordinator.js";
 
 export interface RecallInternalDeps {
@@ -64,6 +65,7 @@ export interface RecallInternalDeps {
     onDegradation?: (degradation: SearchDegradation) => void;
     /** Issue #680 — historical recall point in ms-since-epoch. */
     asOfMs?: number;
+    requestingConnector?: string;
     /**
      * Optional out-parameter that receives the pre-MMR / pre-truncation
      * pool size captured inside the pipeline (issue #570 PR 1).  The
@@ -73,6 +75,7 @@ export interface RecallInternalDeps {
      * Unset by default so existing call sites are unaffected.
      */
     xrayPoolSizeSink?: { size: number };
+    resultPartitionSink?: RecallResultPartitionSink;
     /**
      * Issue #1577 — out-parameter that receives the TrustScore stage's
      * per-path trust map (admitted + quarantined) when the cold path runs
@@ -126,6 +129,7 @@ export interface RecallInternalDeps {
        * string at the input boundary (CLI / HTTP / MCP).
        */
       asOfMs?: number;
+      requestingConnector?: string;
     },
   ): Promise<QmdSearchResult[]>;
   boxBuilderFor(storage: StorageManager): BoxBuilder;
@@ -177,6 +181,7 @@ export interface RecallInternalDeps {
   ): string[];
   readonly compounding?: CompoundingEngine;
   readonly config: PluginConfig;
+  readonly recallRerankCoordinator: Pick<RecallRerankCoordinator, "diversifyRecallResultsWithHeadroom">;
   currentPolicyVersion(): string;
   diversifyAndLimitRecallResults(
     sectionId: string,
@@ -234,6 +239,7 @@ export interface RecallInternalDeps {
       abortSignal?: AbortSignal;
       dropUnresolved?: boolean;
       recallNamespaces?: readonly string[];
+      requestingConnector?: string;
     },
   ): Promise<{ results: QmdSearchResult[]; memoryByPath: Map<string, MemoryFile> }>;
   formatCausalTrajectoryResults(