@remnic/core 9.69.74 → 9.69.75

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