@remnic/core 9.19.0 → 9.20.0

package/src/orchestration/recall-search-pipeline.test.ts

@@ -9,6 +9,7 @@ import { RecallSearchPipelineCoordinator } from "./recall-search-pipeline.js";
 import type { RecallSearchPipelineDeps } from "./recall-search-pipeline.js";
 import type { MemoryFile, QmdSearchResult } from "../types.js";
 import type { StorageManager } from "../index.js";
+import type { QueryAwarePrefilter } from "../orchestrator.js";
 
 function result(namespace: string, path: string): QmdSearchResult {
   return { docid: `${namespace}:${path}`, namespace, path, score: 1, snippet: path };
@@ -68,3 +69,184 @@ test("recall safety keeps same relative path distinct across namespaces", async
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+function scopedCandidatesStub(
+  seed: QmdSearchResult[],
+): RecallSearchPipelineDeps["searchScopedMemoryCandidates"] {
+  // Faithful to production: return only the requested candidates, capped to limit.
+  return async (candidatePaths, _query, limit) =>
+    seed.filter((r) => candidatePaths.has(r.path)).slice(0, Math.max(0, limit));
+}
+
+function fallbackCoordinator(seed: QmdSearchResult[], archived: MemoryFile[]): RecallSearchPipelineCoordinator {
+  const readArchivedMemoriesForNamespaces: RecallSearchPipelineDeps["readArchivedMemoriesForNamespaces"] =
+    async () => archived;
+  const namespaceFromPath: RecallSearchPipelineDeps["namespaceFromPath"] = () => "default";
+  const deps = {
+    searchScopedMemoryCandidates: scopedCandidatesStub(seed),
+    readArchivedMemoriesForNamespaces,
+    namespaceFromPath,
+    config: { memoryDir: "/mem" },
+  } as unknown as RecallSearchPipelineDeps;
+  return new RecallSearchPipelineCoordinator(deps);
+}
+
+function prefilter(paths: string[]): QueryAwarePrefilter {
+  return {
+    candidatePaths: new Set(paths),
+    temporalFromDate: null,
+    matchedTags: [],
+    expandedTags: [],
+    combination: "none",
+    filteredToFullSearch: false,
+  };
+}
+
+const MEETING_RECORD = "meetings/2026-03-10/mtg-2026-03-10-abcdef01.md";
+const SEED_PATHS = [MEETING_RECORD, "facts/a.md", "artifacts/y.md"];
+const SEED_WITH_NON_RECALLABLE = SEED_PATHS.map((p) => result("default", p));
+const PREFILTER = prefilter(SEED_PATHS);
+
+test("archive fallback excludes non-recallable seeds on the archived-empty early return", async () => {
+  const coordinator = fallbackCoordinator(SEED_WITH_NON_RECALLABLE, []);
+  // limit 10 > filtered seed count, tokens non-empty, archived empty → the
+  // `return scopedSeedResults` early path at the archived-empty guard.
+  const out = await coordinator.searchLongTermArchiveFallback("quarterly report", ["default"], 10, PREFILTER);
+  assert.deepEqual(
+    out.map((r) => r.path),
+    ["facts/a.md"],
+    "meeting record + artifact must not leak through the direct-caller early return",
+  );
+});
+
+test("archive fallback excludes non-recallable seeds on the empty-tokens early return", async () => {
+  const coordinator = fallbackCoordinator(SEED_WITH_NON_RECALLABLE, [memory("facts/z.md", "archived")]);
+  // Empty prompt → zero tokens → the `return scopedSeedResults` early path
+  // before archive scoring is even attempted.
+  const out = await coordinator.searchLongTermArchiveFallback("", ["default"], 10, PREFILTER);
+  assert.deepEqual(out.map((r) => r.path), ["facts/a.md"]);
+});
+
+test("archive fallback applies the cap to FILTERED seeds, not raw non-recallable hits", async () => {
+  // The scoped search returns a single non-recallable hit that would fill a cap
+  // of 1 if counted raw; the method must count only recallable seeds, so it does
+  // not early-return that hit and (archive empty) yields nothing.
+  const coordinator = fallbackCoordinator([result("default", MEETING_RECORD)], []);
+  const out = await coordinator.searchLongTermArchiveFallback("quarterly", ["default"], 1, prefilter([MEETING_RECORD]));
+  assert.deepEqual(out.map((r) => r.path), []);
+});
+
+test("finding 1 — overfetches scoped seeds before exclusion so a capped fetch still yields recallable hits", async () => {
+  // The scoped candidate order puts the NON-recallable meeting record FIRST;
+  // capping the scoped fetch to the caller's limit (1) BEFORE the generic-recall
+  // exclusion would return only the meeting record, which is then filtered out —
+  // dropping facts/a.md with no refill. Overfetching the full candidate set first
+  // and excluding afterward must still surface the recallable hit at the cap.
+  const coordinator = fallbackCoordinator(
+    [result("default", MEETING_RECORD), result("default", "facts/a.md")],
+    [],
+  );
+  const out = await coordinator.searchLongTermArchiveFallback(
+    "quarterly",
+    ["default"],
+    1,
+    prefilter([MEETING_RECORD, "facts/a.md"]),
+  );
+  assert.deepEqual(
+    out.map((r) => r.path),
+    ["facts/a.md"],
+    "an excluded-first seed must not starve the result of a recallable hit at the cap",
+  );
+});
+
+function hotSeedCoordinator(seed: QmdSearchResult[]): RecallSearchPipelineCoordinator {
+  const deps = {
+    config: { memoryDir: "/mem", qmdSearchStrategy: "lex", searchBackend: "qmd" },
+    qmd: {},
+    searchScopedMemoryCandidates: scopedCandidatesStub(seed),
+    searchAcrossNamespaces: async () => [],
+    namespaceFromPath: () => "default",
+  } as unknown as RecallSearchPipelineDeps;
+  return new RecallSearchPipelineCoordinator(deps);
+}
+
+test("finding 1 (round-4) — hot QMD seed path overfetches scoped seeds before exclusion", async () => {
+  // The query-aware candidate order puts the NON-recallable meeting record FIRST.
+  // The hot seed fetch previously capped the scoped fetch to qmdFetchLimit (1)
+  // BEFORE the generic-recall exclusion, so the sole fetched seed was the meeting
+  // record — filtered out, dropping facts/a.md with no refill. Overfetching the
+  // full candidate set and excluding afterward must still surface the recallable
+  // hit at the cap.
+  const coordinator = hotSeedCoordinator([
+    result("default", MEETING_RECORD),
+    result("default", "facts/a.md"),
+  ]);
+  const out = await coordinator.fetchQmdMemoryResultsWithArtifactTopUp("quarterly", 1, 1, {
+    namespacesEnabled: false,
+    recallNamespaces: ["default"],
+    resolveNamespace: () => "default",
+    queryAwarePrefilter: prefilter([MEETING_RECORD, "facts/a.md"]),
+  });
+  assert.deepEqual(
+    out.map((r) => r.path),
+    ["facts/a.md"],
+    "an excluded-first candidate must not starve the hot seed of a recallable hit at the cap",
+  );
+});
+
+function resultScored(namespace: string, path: string, score: number): QmdSearchResult {
+  return { docid: `${namespace}:${path}`, namespace, path, score, snippet: path };
+}
+
+function meetingRecordPath(hash: string): string {
+  return `meetings/2026-03-10/mtg-2026-03-10-${hash}.md`;
+}
+
+function starvedPrimaryCoordinator(
+  seed: QmdSearchResult[],
+  primary: QmdSearchResult[],
+): RecallSearchPipelineCoordinator {
+  const deps = {
+    config: { memoryDir: "/mem", qmdSearchStrategy: "lex", searchBackend: "qmd" },
+    qmd: {},
+    searchScopedMemoryCandidates: scopedCandidatesStub(seed),
+    // Faithful to the QMD backend: cap the primary hits to the requested budget.
+    searchAcrossNamespaces: async ({ maxResults }: { maxResults: number }) =>
+      [...primary].sort((a, b) => b.score - a.score).slice(0, Math.max(0, maxResults)),
+    namespaceFromPath: () => "default",
+  } as unknown as RecallSearchPipelineDeps;
+  return new RecallSearchPipelineCoordinator(deps);
+}
+
+test("finding 1 (round-5) — excluded seeds must not fill the merge cap and starve a primary hit", async () => {
+  // Excluded meeting records dominate the query-aware SEED set (higher score),
+  // while the sole recallable memory arrives from the PRIMARY QMD search — so the
+  // scoped-seed overfetch fix and the seed-derived `bestFiltered` fallback cannot
+  // rescue it. The seed MERGE `[...seeds, ...primary]` capped to fetchLimit BEFORE
+  // filterRecallCandidates ran, so every cap slot (even after the two-attempt
+  // fetchLimit growth) went to meeting records later filtered out — dropping
+  // facts/a.md with no refill. Excluding non-recallable paths BEFORE the cap must
+  // let the primary hit survive at qmdFetchLimit=1.
+  const meetings = [
+    "aaaaaaaa",
+    "bbbbbbbb",
+    "cccccccc",
+    "dddddddd",
+    "eeeeeeee",
+    "ffffffff",
+  ].map((h) => resultScored("default", meetingRecordPath(h), 2));
+  const coordinator = starvedPrimaryCoordinator(meetings, [
+    resultScored("default", "facts/a.md", 1),
+  ]);
+  const out = await coordinator.fetchQmdMemoryResultsWithArtifactTopUp("quarterly", 1, 1, {
+    namespacesEnabled: false,
+    recallNamespaces: ["default"],
+    resolveNamespace: () => "default",
+    queryAwarePrefilter: prefilter(meetings.map((m) => m.path)),
+  });
+  assert.deepEqual(
+    out.map((r) => r.path),
+    ["facts/a.md"],
+    "excluded seeds ranked ahead must not fill the fetchLimit cap and starve the recallable primary hit",
+  );
+});

package/src/orchestration/recall-search-pipeline.ts

@@ -422,10 +422,19 @@ export class RecallSearchPipelineCoordinator {
       ? await this.deps.searchScopedMemoryCandidates(
           queryAwarePrefilter.candidatePaths,
           prompt,
-          qmdFetchLimit,
+          // Overfetch the FULL scoped candidate set BEFORE the generic-recall
+          // exclusion `filterRecallCandidates` applies below (L464). Capping to
+          // `qmdFetchLimit` here lets excluded paths (artifacts, activity digests,
+          // meeting records) consume the caller's budget and drop legitimate hits
+          // with no refill — the hot-path mirror of the archive-fallback fix. The
+          // candidate set is an already-bounded prefilter, so its size is the
+          // natural ceiling; the post-exclusion cap is applied by filterRecallCandidates.
+          queryAwarePrefilter.candidatePaths.size,
           { allowArchived: options.collection !== undefined },
         )
       : [];
+    // Drop generic-recall-excluded records before the fetchLimit cap so they can't starve valid memories (#1995).
+    const recallable = (r: QmdSearchResult) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir);
 
     let fetchLimit = Math.max(qmdFetchLimit, qmdHybridFetchLimit);
     const maxFetchLimit = Math.min(
@@ -586,13 +595,12 @@ export class RecallSearchPipelineCoordinator {
           lastHybridResultCount = hybridResults.length;
           lastHybridTopUpUsed = hybridResults.length > 0;
           if (hybridResults.length > 0) {
-            // Dedup by composite (namespace, path) so a fanout hit and a
-            // seed/hybrid hit for the same memory never inject twice (#2020).
+            // Dedup by composite (namespace, path) so a hit never injects twice (#2020).
             mergedResults = dedupeResultsByNamespace(
               [...primaryResults, ...hybridResults],
               this.deps.namespaceFromPath,
               fetchLimit,
-              { transportFallback: "hybrid" },
+              { transportFallback: "hybrid", filter: recallable },
             );
           }
         }
@@ -603,6 +611,7 @@ export class RecallSearchPipelineCoordinator {
           [...scopedSeedResults, ...mergedResults],
           this.deps.namespaceFromPath,
           fetchLimit,
+          { filter: recallable },
         );
       }
 
@@ -685,18 +694,30 @@ export class RecallSearchPipelineCoordinator {
     if (cappedLimit === 0) return [];
     if (queryAwarePrefilter?.candidatePaths?.size === 0) return [];
 
-    const scopedSeedResults = queryAwarePrefilter?.candidatePaths?.size
-      ? await this.deps.searchScopedMemoryCandidates(
-          queryAwarePrefilter.candidatePaths,
-          prompt,
-          cappedLimit,
-          { allowArchived: true },
-        )
-      : [];
+    const candidatePaths = queryAwarePrefilter?.candidatePaths;
+    const scopedSeedResults = (
+      candidatePaths?.size
+        ? await this.deps.searchScopedMemoryCandidates(
+            candidatePaths,
+            prompt,
+            // Overfetch the FULL scoped candidate set BEFORE the generic-recall
+            // exclusion below. Capping to `cappedLimit` first lets excluded paths
+            // (artifacts, activity digests, meeting records) consume the caller's
+            // budget and drop legitimate hits with no refill — e.g. a prefilter of
+            // [meetingRecord, facts/a.md] at limit 1 would return nothing. The
+            // candidate set is an already-bounded prefilter, so its size is the
+            // natural ceiling; the post-exclusion cap is applied below.
+            candidatePaths.size,
+            { allowArchived: true },
+          )
+        : []
+    ).filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir));
+    // Non-recallable seed paths (artifacts, activity digests, meeting records) are
+    // excluded above AFTER an unconstrained candidate fetch, so the cap here counts
+    // only recallable seeds — and EVERY early-return / direct-caller path below
+    // returns already-filtered, budget-honoring seeds.
     if (scopedSeedResults.length >= cappedLimit) {
-      return scopedSeedResults
-        .filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir))
-        .slice(0, cappedLimit);
+      return scopedSeedResults.slice(0, cappedLimit);
     }
 
     const tokens = Array.from(new Set(tokenizeRecallQuery(prompt)));

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { BoundedJsonlStateConfig } from "./bounded-jsonl-state.js";
+import type { MeetingsConfig } from "./meetings/types.js";
 import type { ActivityConfig } from "./activity/types.js";
 import type { WearablesConfig } from "./wearables/types.js";
 
@@ -1217,6 +1218,11 @@ export interface PluginConfig extends BoundedJsonlStateConfig {
    */
   wearables: WearablesConfig;
   activity: ActivityConfig;
+  /**
+   * Retrospective meeting intelligence (issue #1900): detect + fuse meetings
+   * from already-ingested audio + screen activity. Disabled by default.
+   */
+  meetings: MeetingsConfig;
   /**
    * At-rest encryption configuration (issue #690 PR 3/4).
    *