@remnic/core 9.69.73 → 9.69.75

package/src/config.ts

@@ -26,6 +26,7 @@ import type {
   TrustWeights,
 } from "./types.js";
 import { parseBackgroundGeneration } from "./background-generation-config.js";
+import { parseSearchBackend } from "./config-search-backend.js";
 import { parseLocalLlmConfig } from "./local-llm-config.js";
 import { parseConvergeConfig } from "./converge-config.js";
 import { parseExternalWikiRecallGuard } from "./external-wiki-guard.js";
@@ -3173,9 +3174,7 @@ export function parseConfig(
         : 500,
 
     // Search backend abstraction
-    searchBackend: (["qmd", "remote", "noop", "lancedb", "meilisearch", "orama"] as const).includes(cfg.searchBackend as any)
-      ? (cfg.searchBackend as "qmd" | "remote" | "noop" | "lancedb" | "meilisearch" | "orama")
-      : "qmd",
+    searchBackend: parseSearchBackend(cfg.searchBackend),
     remoteSearchBaseUrl: typeof cfg.remoteSearchBaseUrl === "string" ? cfg.remoteSearchBaseUrl : undefined,
     remoteSearchApiKey: typeof cfg.remoteSearchApiKey === "string" ? cfg.remoteSearchApiKey : undefined,
     remoteSearchTimeoutMs: typeof cfg.remoteSearchTimeoutMs === "number" ? cfg.remoteSearchTimeoutMs : 30_000,

package/src/orchestration/extraction-persist-citation.test.ts

@@ -0,0 +1,9 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { applyInlineCitation, normalizeStoredHashSource } from "./extraction-persist-citation.js";
+
+test("#3091 citation helpers no-op when inline attribution is off", () => {
+  assert.equal(applyInlineCitation("hello", false, "[{ts}]", {}), "hello");
+  assert.equal(normalizeStoredHashSource("hello", false, "[{ts}]"), "hello");
+});

package/src/orchestration/extraction-persist-citation.ts

@@ -0,0 +1,37 @@
+import { ContentHashIndex } from "../index.js";
+import { sanitizeMemoryContent } from "../sanitize.js";
+import {
+  attachCitation,
+  type CitationContext,
+  hasCitationForTemplate,
+  stripCitationForTemplate,
+} from "../source-attribution.js";
+
+export function normalizeStoredHashSource(
+  raw: string,
+  citationEnabled: boolean,
+  citationTemplate: string,
+): string {
+  return ContentHashIndex.normalizeContent(
+    sanitizeMemoryContent(
+      citationEnabled && hasCitationForTemplate(raw, citationTemplate)
+        ? stripCitationForTemplate(raw, citationTemplate)
+        : raw,
+    ).text,
+  );
+}
+
+export function applyInlineCitation(
+  content: string,
+  citationEnabled: boolean,
+  citationTemplate: string,
+  citationContextBase: Omit<CitationContext, "ts">,
+): string {
+  if (!citationEnabled) return content;
+  if (typeof content !== "string" || content.length === 0) return content;
+  const citationContext: CitationContext = {
+    ...citationContextBase,
+    ts: new Date().toISOString(),
+  };
+  return attachCitation(content, citationContext, citationTemplate);
+}

package/src/orchestration/extraction-persist.ts

@@ -125,6 +125,10 @@ import { applySemanticMergeAtPersist, runMergedTargetPostEffects, writeMergedVer
 import { buildMergedTargetPromotionPayload } from "./semantic-merge-promotion-payload.js";
 import { persistMergedTargetThreadEpisode } from "./semantic-merge-commit-effects.js";
 import { ExtractionAnchorSnapshot } from "./extraction-anchor-snapshot.js";
+import {
+  applyInlineCitation as applyInlineCitationToContent,
+  normalizeStoredHashSource as normalizeStoredHashSourceContent,
+} from "./extraction-persist-citation.js";
 
 export class ExtractionPersistCoordinator {
   constructor(
@@ -145,26 +149,12 @@ export class ExtractionPersistCoordinator {
     sourceContext?: ExtractionSourceContext,
     baseNamespace?: string,
     scopeProfileWritePlan?: ResolvedScopeProfilePlan | null,
-    /** Verbatim source turn text the facts were extracted from (faithfulness gate #1576). */
     sourceText?: string,
     graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.deps.config),
     lifecycleCaps: MemoryLifecycleCapabilitySet = resolveMemoryLifecycleCapabilities(this.deps.config),
   ): Promise<{ persistedIds: string[]; memoryPathById: Map<string, string> }> {
-    // Inline source attribution (issue #369). When enabled, every extracted
-    // fact is rewritten to carry a compact provenance tag inside its body so
-    // the citation survives hostile memory text, copy/paste, and LLM quoting.
-    // The helper is a no-op when the feature flag is off, so legacy pipelines
-    // see zero behavioral change.
     const citationEnabled = resolvePipelineProcessingCapabilities(this.deps.config).inlineSourceAttribution === true;
     const citationTemplate = this.deps.config.inlineSourceAttributionFormat;
-    // #1909: the main-path fact writes defer their per-fact fact-hash-index flush
-    // to the orchestrator's end-of-persist reconciling batch save ONLY when fact
-    // deduplication is enabled (with it off, contentHashIndexForStorage() returns
-    // null and the batch save is a no-op, so the write must save immediately).
-    // Round 11: there is NO fact-hashes.ready marker anymore — the fact-hash
-    // index is ALWAYS rebuilt from the corpus on restart (see
-    // ensureFactHashIndexAuthoritative), so a deferred write, crash, or
-    // multi-process interleave is safe by construction with no marker to guard.
     const factDedupEnabled = resolveRecallAuxiliaryCapabilities(this.deps.config).factDeduplication;
     const harmonicConstructionEnabled = resolveCapabilities(this.deps.config).harmonicRetrieval;
     const harmonicAnchorsEnabled =
@@ -182,40 +172,16 @@ export class ExtractionPersistCoordinator {
     let harmonicSourceOrder = 0;
     const promotedCopyProbe = createBatchPromotedCopyProbe(this.deps.config, this.deps.getStorageRouter, scopeProfileWritePlan); // #2330 finding F: one promoted-copy scan per namespace per batch
 
-  // Canonicalize stored content for dedup comparison: strip citations
-  // (using the same template), sanitize, then normalize whitespace.
-  const normalizeStoredHashSource = (raw: string): string =>
-    ContentHashIndex.normalizeContent(
-      sanitizeMemoryContent(
-        citationEnabled && hasCitationForTemplate(raw, citationTemplate)
-          ? stripCitationForTemplate(raw, citationTemplate)
-          : raw,
-      ).text,
-    );
-    // The stable fields (agent, session) are computed once; `ts` is intentionally
-    // omitted here and added fresh per invocation so each fact in a large batch
-    // gets its own insertion timestamp rather than sharing a single batch-start time.
+    const normalizeStoredHashSource = (raw: string): string =>
+      normalizeStoredHashSourceContent(raw, citationEnabled, citationTemplate);
     const citationContextBase: Omit<CitationContext, "ts"> = citationEnabled
       ? {
           agent: sourceContext?.principal,
           session: sourceContext?.sessionKey,
         }
       : {};
-    const applyInlineCitation = (content: string): string => {
-      if (!citationEnabled) return content;
-      if (typeof content !== "string" || content.length === 0) return content;
-      // Build a fresh CitationContext per call so `ts` reflects the actual
-      // insertion time of each individual fact rather than the batch-start time.
-      const citationContext: CitationContext = {
-        ...citationContextBase,
-        ts: new Date().toISOString(),
-      };
-      // `attachCitation` already calls `hasCitationForTemplate` internally and
-      // is a no-op when the content already carries a citation (default or
-      // custom template).  The outer check was redundant and has been removed
-      // to avoid a maintenance hazard where the two guard paths could diverge.
-      return attachCitation(content, citationContext, citationTemplate);
-    };
+    const applyInlineCitation = (content: string): string =>
+      applyInlineCitationToContent(content, citationEnabled, citationTemplate, citationContextBase);
     const persistedIds: string[] = [];
     const memoryPathById = new Map<string, string>();
     const anchorSnapshots = new ExtractionAnchorSnapshot({

package/src/orchestration/recall-entry.ts

@@ -23,7 +23,12 @@ import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../ty
 import { stateViewPacketActive } from "../recall-state-view-anchors.js";
 import { resultStateViewKey, stateViewPacketKeys } from "../recall-state-view.js";
 import { applyRecallStateViews } from "../recall-state-view-wire.js";
-import { composeRecallContext } from "../recall-context-composition.js";
+import { composeRecallContext, type RecallContextComposition } from "../recall-context-composition.js";
+import {
+  memoriesToStandingEntries,
+  prefixStandingMemoryBlock,
+  renderStandingMemoryBlock,
+} from "../standing-memory-recall.js";
 import {
   notifyContextComposition,
   recallFailureComposition,
@@ -151,16 +156,53 @@ export class RecallEntryCoordinator {
       return lockedMsg;
     }
 
-    // Keep outer recall timeout above worst-case serialized hybrid search:
-    // QMD subprocess BM25 (30s) + vector (30s) can consume ~60s under contention.
+    let standingText = "";
+    const standingBudget =
+      typeof options.budgetCharsOverride === "number" &&
+      Number.isInteger(options.budgetCharsOverride) &&
+      options.budgetCharsOverride >= 0
+        ? options.budgetCharsOverride
+        : this.deps.config.recallBudgetChars;
+    if (this.deps.config.recallStandingBlock && !namespacesEnabled && standingBudget !== 0 && !options.asOf) {
+      try {
+        const memories = await this.deps.storage.readAllMemories({
+          abortSignal: abortController.signal,
+        });
+        standingText = renderStandingMemoryBlock(
+          this.deps.config,
+          memoriesToStandingEntries(memories, { requestingConnector: options.sourceConnector }),
+        );
+      } catch (err) {
+        log.warn(`standing memory block skipped: ${err}`);
+      }
+    }
+    const innerObserver = options.onContextComposition;
+    const innerBudget =
+      standingText.length > 0 && standingBudget && standingBudget > 0
+        ? Math.max(0, standingBudget - standingText.length - 2)
+        : options.budgetCharsOverride;
+    const recallOptions = {
+      ...options,
+      abortSignal: abortController.signal,
+      budgetCharsOverride: innerBudget,
+      onContextComposition:
+        standingText.length > 0
+          ? (composition: RecallContextComposition) =>
+              innerObserver?.({
+                ...composition,
+                context: prefixStandingMemoryBlock(
+                  composition.context ?? "",
+                  standingText,
+                  standingBudget,
+                ),
+              })
+          : innerObserver,
+    };
     try {
-      const recallPromise = this.deps.recallInternal(prompt, sessionKey, {
-        ...options,
-        abortSignal: abortController.signal,
-      }, caps, graphCaps);
+      const recallPromise = this.deps.recallInternal(prompt, sessionKey, recallOptions, caps, graphCaps);
       const RECALL_TIMEOUT_MS = this.deps.config.recallOuterTimeoutMs ?? 75_000;
       if (RECALL_TIMEOUT_MS <= 0) {
-        return await recallPromise;
+        return prefixStandingMemoryBlock(await recallPromise, standingText, standingBudget);
       }
 
       let timeoutHandle: NodeJS.Timeout | null = null;
@@ -196,18 +238,17 @@ export class RecallEntryCoordinator {
         }
       }
 
-      return recallResult;
+      return prefixStandingMemoryBlock(recallResult, standingText, standingBudget);
     } catch (err) {
       this.deps.logRecallFailure(err);
-      // endTrace() is safe here: if no trace is active (disabled or already
-      // closed by recallInternal's try/finally), it returns null immediately.
       this.deps.profiler.endTrace();
-      // Caller-cancelled recalls stay quiet: the failure was the caller's
-      // abort, not a recall degradation (issue #2972 contract).
       const missing = options.abortSignal?.aborted
         ? null
         : recallFailureComposition(err);
       if (!missing) return "";
+      if (standingText.length > 0) {
+        missing.context = prefixStandingMemoryBlock(missing.context ?? "", standingText, standingBudget);
+      }
       notifyContextComposition(options.onContextComposition, missing, (observerErr) => {
         log.warn("recall: context composition observer failed open", observerErr);
       });

package/src/standing-memory-block.test.ts

@@ -230,6 +230,7 @@ async function writeFact(memoryDir: string): Promise<void> {
     `created: ${now}`,
     `updated: ${now}`,
     "source: extraction",
+    "origin: user",
     "confidence: 0.8",
     "confidenceTier: high",
     "tags: []",
@@ -242,7 +243,7 @@ async function writeFact(memoryDir: string): Promise<void> {
   await writeFile(path.join(factsDir, "standing-fact.md"), `${fact.join("\n")}\n`, "utf-8");
 }
 
-test("zero-diff: recall output is byte-identical with the flag off vs on (pre-wiring)", async () => {
+test("recall injects the standing memory block when the flag is on", async () => {
   const off = await makeOrchestrator();
   const on = await makeOrchestrator({ recallStandingBlock: true });
   try {
@@ -250,8 +251,8 @@ test("zero-diff: recall output is byte-identical with the flag off vs on (pre-wi
     await writeFact(on.memoryDir);
     const outOff = await off.orchestrator.recall("how do deploys go out", "sess-standing-off");
     const outOn = await on.orchestrator.recall("how do deploys go out", "sess-standing-on");
-    assert.equal(outOn, outOff, "recall must not change until the wiring slice lands");
-    assert.ok(!outOn.includes("## Standing Memory (Remnic)"), "no standing block in recall output");
+    assert.ok(!outOff.includes("## Standing Memory (Remnic)"), "flag off keeps recall unchanged");
+    assert.ok(outOn.includes("## Standing Memory (Remnic)"), "flag on injects the standing block");
     assert.ok(outOn.includes("blue pipeline"), "sanity: the fact is recalled");
   } finally {
     await off.orchestrator.destroy();

package/src/standing-memory-recall.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import {
+  memoriesToStandingEntries,
+  prefixStandingMemoryBlock,
+  renderStandingMemoryBlock,
+} from "./standing-memory-recall.js";
+
+test("#3089 standing block is omitted when recallStandingBlock is off", () => {
+  const off = parseConfig({});
+  const on = parseConfig({ recallStandingBlock: true });
+  const entries = memoriesToStandingEntries([
+    {
+      id: "fact-1",
+      content: "The blue pipeline is the only deploy path.",
+      frontmatter: { id: "fact-1", pinned: true, origin: "user" },
+    },
+  ]);
+  const recall = "per-turn recall";
+  assert.equal(renderStandingMemoryBlock(off, entries), "");
+  assert.equal(prefixStandingMemoryBlock(recall, renderStandingMemoryBlock(off, entries)), recall);
+  const standing = renderStandingMemoryBlock(on, entries);
+  assert.ok(standing.includes("## Standing Memory (Remnic)"));
+  assert.ok(standing.includes("blue pipeline"));
+  const prefixed = prefixStandingMemoryBlock(recall, standing);
+  assert.ok(prefixed.startsWith(standing));
+  assert.ok(prefixed.includes("per-turn recall"));
+});

package/src/standing-memory-recall.ts

@@ -0,0 +1,87 @@
+import {
+  DEFAULT_UNTRUSTED_ORIGINS,
+  isUntrustedOrigin,
+  parseOriginClass,
+} from "./security/origin-authority.js";
+import type { PluginConfig } from "./types.js";
+import {
+  buildStandingMemoryBlock,
+  lintStandingBlockVolatility,
+  type StandingMemoryEntry,
+} from "./standing-memory-block.js";
+
+export interface StandingMemorySource {
+  id?: string;
+  path?: string;
+  content: string;
+  frontmatter: {
+    id?: unknown;
+    pinned?: unknown;
+    updated?: unknown;
+    origin?: unknown;
+    status?: unknown;
+    toolScoped?: unknown;
+    sourceConnector?: unknown;
+  };
+}
+
+export function memoriesToStandingEntries(
+  memories: readonly StandingMemorySource[],
+  opts: { requestingConnector?: string } = {},
+): StandingMemoryEntry[] {
+  const entries: StandingMemoryEntry[] = [];
+  for (const memory of memories) {
+    const id = String(memory.frontmatter.id ?? memory.id ?? memory.path ?? "");
+    if (!id) continue;
+    if (isUntrustedOrigin(parseOriginClass(memory.frontmatter.origin), DEFAULT_UNTRUSTED_ORIGINS)) {
+      continue;
+    }
+    if (typeof memory.frontmatter.status === "string" && memory.frontmatter.status !== "active") {
+      continue;
+    }
+    const requestingConnector = opts.requestingConnector?.trim();
+    const memoryConnector =
+      typeof memory.frontmatter.sourceConnector === "string" ? memory.frontmatter.sourceConnector.trim() : "";
+    if (memory.frontmatter.toolScoped === true && memoryConnector && requestingConnector && memoryConnector !== requestingConnector) {
+      continue;
+    }
+    const description =
+      memory.content
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("---")) ?? "";
+    if (description.length < 8) continue;
+    if (lintStandingBlockVolatility(description).length > 0) continue;
+    const pinned = memory.frontmatter.pinned === true;
+    const lastChangedAt =
+      typeof memory.frontmatter.updated === "string" ? memory.frontmatter.updated : undefined;
+    entries.push({ id, description: description.slice(0, 200), pinned, lastChangedAt });
+  }
+  return entries;
+}
+
+export function renderStandingMemoryBlock(config: PluginConfig, entries: StandingMemoryEntry[]): string {
+  if (!config.recallStandingBlock || entries.length === 0) return "";
+  try {
+    return buildStandingMemoryBlock({
+      entries,
+      nowMs: Date.now(),
+      maxChars: config.standingBlockMaxChars,
+      freshDays: config.standingBlockFreshDays,
+    }).text;
+  } catch {
+    return "";
+  }
+}
+
+export function prefixStandingMemoryBlock(
+  recallResult: string,
+  standingText: string,
+  budgetChars?: number,
+): string {
+  if (standingText.length === 0) return recallResult;
+  if (budgetChars === 0) return recallResult;
+  const combined = `${standingText}\n\n${recallResult}`;
+  if (!budgetChars || combined.length <= budgetChars) return combined;
+  return combined.slice(0, budgetChars);
+}