@remnic/core 9.25.3 → 9.25.5

package/src/access-recall-response.ts

@@ -16,6 +16,11 @@ import { decideDisclosureEscalation } from "./recall-disclosure-escalation.js";
 import { type TagMatchMode, applyTagFilter, normalizeTags, parseTagMatch } from "./recall-tag-filter.js";
 import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { displaySafeBudgetsApplied, displaySafeRecallSnapshot } from "./orchestration/recall-result-formatter.js";
+import {
+  boundRecallContextComposition,
+  composeRecallContext,
+  type RecallContextComposition,
+} from "./recall-context-composition.js";
 
 /**
  * Build the recall response from the completed pipeline (issue #1906 review
@@ -29,6 +34,7 @@ export async function assembleRecallResponse(
   params: {
   request: EngramAccessRecallRequest;
   context: string;
+  contextComposition?: RecallContextComposition;
   query: string;
   mode: RecallPlanMode | undefined;
   namespace: string;
@@ -47,6 +53,7 @@ export async function assembleRecallResponse(
   const {
     request,
     context,
+    contextComposition,
     query,
     mode,
     namespace,
@@ -191,7 +198,8 @@ export async function assembleRecallResponse(
       err instanceof Error ? err.message : String(err),
     );
   }
-  let effectiveContext = context;
+  let effectiveComposition: RecallContextComposition = contextComposition ?? { context };
+  let effectiveContext = composeRecallContext(effectiveComposition);
   if (filterTags && filterTags.length > 0) {
     const beforeIds = results.map((r) => r.id);
     const { results: admitted } = applyTagFilter(results, {
@@ -213,20 +221,16 @@ export async function assembleRecallResponse(
     const admittedIds = new Set(results.map((r) => r.id));
     const droppedAny = beforeIds.some((id) => !admittedIds.has(id));
     if (droppedAny) {
-      effectiveContext = results
-        .map((r) => {
-          const content =
-            typeof (r as { content?: unknown }).content === "string"
-              ? ((r as { content?: string }).content ?? "")
-              : "";
-          const preview =
-            typeof (r as { preview?: unknown }).preview === "string"
-              ? ((r as { preview?: string }).preview ?? "")
-              : "";
-          return content || preview;
-        })
+      const filteredContext = results
+        .map((result) => result.content || result.preview)
         .filter((s) => s.length > 0)
         .join("\n\n");
+      effectiveComposition = boundRecallContextComposition({
+        context: filteredContext,
+        footer: effectiveComposition.footer,
+        maxChars: deps.orchestrator.config.recallBudgetChars,
+      });
+      effectiveContext = composeRecallContext(effectiveComposition);
     }
   }
   const filteredMemoryIds = filterTags && filterTags.length > 0
@@ -289,6 +293,7 @@ export async function assembleRecallResponse(
       sessionKey: request.sessionKey,
       namespace: effectiveNamespace,
       context: effectiveContext,
+      contextComposition: effectiveComposition,
       count: filterTags && filterTags.length > 0
         ? results.length
         : (snapshot?.memoryIds.length ?? results.length),

package/src/access-recall-surface.ts

@@ -27,6 +27,7 @@ import type { Orchestrator, RecallInvocationOptions } from "./orchestrator.js";
 import { decideDisclosureEscalation } from "./recall-disclosure-escalation.js";
 import { assembleRecallResponse } from "./access-recall-response.js";
 import type { LastRecallSnapshot } from "./recall-state.js";
+import type { RecallContextComposition } from "./recall-context-composition.js";
 import { type TagMatchMode, applyTagFilter, normalizeTags, parseTagMatch } from "./recall-tag-filter.js";
 import { type RecallXraySnapshot, estimateRecallTokens } from "./recall-xray.js";
 import { SecureStoreLockedError } from "./secure-store/index.js";
@@ -852,10 +853,14 @@ export class AccessRecallSurface {
       }
       asOf = request.asOf;
     }
+    let contextComposition: RecallContextComposition | undefined;
     const recallOptions: RecallInvocationOptions = {
       namespace: namespaceOverride,
       topK,
       mode,
+      onContextComposition: (composition) => {
+        contextComposition = composition;
+      },
       ...(authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {}),
       ...(asOf !== undefined ? { asOf } : {}),
       ...(request.includeLowConfidence === true ? { includeLowConfidence: true } : {}),
@@ -892,10 +897,15 @@ export class AccessRecallSurface {
     // construction — so ANY failure after the reserve releases the exact
     // budget entry (by token, review #4) instead of leaking it.
     try {
-      const context = await this.deps.orchestrator.recall(query, request.sessionKey, recallOptions);
+      const context = await this.deps.orchestrator.recall(
+        query,
+        request.sessionKey,
+        recallOptions,
+      );
       const assembled = await assembleRecallResponse(this.deps, {
         request,
         context,
+        contextComposition,
         query,
         mode,
         namespace,

package/src/access-service.ts

@@ -170,6 +170,7 @@ import {
   type ScopeInspection,
 } from "./admin/admin-surfaces.js";
 import type { LastRecallSnapshot } from "./recall-state.js";
+import type { RecallContextComposition } from "./recall-context-composition.js";
 import type {
   GraphRecallSnapshot,
   IntentDebugSnapshot,
@@ -453,6 +454,8 @@ export interface EngramAccessRecallResponse {
   sessionKey?: string;
   namespace: string;
   context: string;
+  /** Request-local split used by adapters that must re-render a tighter prompt budget. */
+  contextComposition?: RecallContextComposition;
   count: number;
   memoryIds: string[];
   results: EngramAccessMemorySummary[];

package/src/extraction-prompt-safety.test.ts

@@ -12,6 +12,11 @@ const SOURCE_TURN: BufferTurn = {
   timestamp: "2026-07-25T12:00:00.000Z",
 };
 
+const TAG_SOURCE_TURN: BufferTurn = {
+  ...SOURCE_TURN,
+  content: "The page uses <main> as the primary landmark.",
+};
+
 const SOURCE_GROUNDED_EXTRACTION = {
   facts: [{
     category: "fact",
@@ -23,6 +28,81 @@ const SOURCE_GROUNDED_EXTRACTION = {
   entities: [],
   questions: [],
 };
+const STRUCTURAL_PLACEHOLDER_EXTRACTION = {
+  facts: [{
+    category: "<category>",
+    content: "<source-grounded statement>",
+    confidence: 0,
+    tags: ["<tag>"],
+    entityRef: "<optional normalized-name>",
+    promptedByQuestion: "<optional source-grounded question>",
+    quote: "<optional exact contiguous source span>",
+  },
+  {
+    category: "<category>",
+    content: SOURCE_TURN.content,
+    confidence: 0.95,
+    tags: ["theme"],
+  },
+  {
+    category: "procedure",
+    content: SOURCE_TURN.content,
+    confidence: 0.95,
+    tags: ["theme"],
+    procedureSteps: [
+      { order: 1, intent: "<step>" },
+      { order: 2, intent: "<step>" },
+    ],
+  },
+  {
+    category: "reasoning_trace",
+    content: SOURCE_TURN.content,
+    confidence: 0.95,
+    tags: ["theme"],
+    reasoningTrace: {
+      steps: [
+        { order: 1, description: "<step>" },
+        { order: 2, description: "<step>" },
+      ],
+      finalAnswer: "<answer>",
+    },
+  }],
+  profileUpdates: ["<source-grounded profile update>"],
+  entities: [{
+    name: "<normalized-name>",
+    type: "<entity-type>",
+    facts: ["<source-grounded statement>"],
+    promptedByQuestion: "<optional source-grounded question>",
+  },
+  {
+    name: "Moonlight",
+    type: "<entity-type>",
+    facts: [SOURCE_TURN.content],
+  }],
+  questions: [{
+    question: "<source-grounded unresolved question>",
+    context: "<source-grounded context>",
+    priority: 0,
+  }],
+  identityReflection: "<conversation-grounded agent reflection>",
+  relationships: [{
+    source: "<normalized-name>",
+    target: "<normalized-name>",
+    label: "<source-grounded relationship>",
+  }],
+};
+
+const GATEWAY_PLACEHOLDER_EXTRACTION = {
+  ...STRUCTURAL_PLACEHOLDER_EXTRACTION,
+  facts: [{
+    ...STRUCTURAL_PLACEHOLDER_EXTRACTION.facts[0],
+    category: "fact",
+  }],
+  entities: [{
+    ...STRUCTURAL_PLACEHOLDER_EXTRACTION.entities[0],
+    type: "other",
+  }],
+};
 
 type ChatMessage = { role: string; content: string };
 
@@ -100,6 +180,105 @@ test("local extraction prompt uses placeholders and accepts an empty question li
   assert.doesNotMatch(prompt, /^- rule:/m);
 });
 
+test("local extraction discards literal structural placeholders", async () => {
+  const engine = new ExtractionEngine(parseConfig({
+    localLlmEnabled: true,
+    localLlmModel: "fixture-local",
+    localLlmFallback: false,
+  }));
+  const localLlm: LocalLlmFixture = {
+    async chatCompletion() {
+      return { content: JSON.stringify(STRUCTURAL_PLACEHOLDER_EXTRACTION) };
+    },
+  };
+  const modelRegistry = {
+    calculateContextSizes: () => ({ maxInputChars: 8_000, maxOutputTokens: 1_000, description: "fixture" }),
+  };
+  assert.equal(Reflect.set(engine, "localLlm", localLlm), true);
+  assert.equal(Reflect.set(engine, "modelRegistry", modelRegistry), true);
+
+  const result = await engine.extract([SOURCE_TURN]);
+
+  assert.deepEqual(result.facts, []);
+  assert.deepEqual(result.profileUpdates, []);
+  assert.deepEqual(result.entities, []);
+  assert.deepEqual(result.questions, []);
+  assert.deepEqual(result.relationships, []);
+  assert.equal(result.identityReflection, undefined);
+});
+
+test("local extraction preserves source text that looks like a tag", async () => {
+  const engine = new ExtractionEngine(parseConfig({
+    localLlmEnabled: true,
+    localLlmModel: "fixture-local",
+    localLlmFallback: false,
+  }));
+  const localLlm: LocalLlmFixture = {
+    async chatCompletion() {
+      return {
+        content: JSON.stringify({
+          facts: [{ category: "fact", content: "<main>", confidence: 0.95, tags: [] }],
+          profileUpdates: [],
+          entities: [],
+          questions: [],
+        }),
+      };
+    },
+  };
+  const modelRegistry = {
+    calculateContextSizes: () => ({ maxInputChars: 8_000, maxOutputTokens: 1_000, description: "fixture" }),
+  };
+  assert.equal(Reflect.set(engine, "localLlm", localLlm), true);
+  assert.equal(Reflect.set(engine, "modelRegistry", modelRegistry), true);
+
+  const result = await engine.extract([TAG_SOURCE_TURN]);
+
+  assert.equal(result.facts[0]?.content, "<main>");
+});
+
+test("local truncated recovery discards literal structural placeholders", async () => {
+  const engine = new ExtractionEngine(parseConfig({
+    localLlmEnabled: true,
+    localLlmModel: "fixture-local",
+    localLlmFallback: false,
+  }));
+  const localLlm: LocalLlmFixture = {
+    async chatCompletion() {
+      return {
+        content: "{\"facts\":[{\"category\":\"<category>\",\"content\":\"<source-grounded statement>\",\"confidence\":0.7}",
+      };
+    },
+  };
+  const modelRegistry = {
+    calculateContextSizes: () => ({ maxInputChars: 8_000, maxOutputTokens: 1_000, description: "fixture" }),
+  };
+  assert.equal(Reflect.set(engine, "localLlm", localLlm), true);
+  assert.equal(Reflect.set(engine, "modelRegistry", modelRegistry), true);
+
+  const result = await engine.extract([SOURCE_TURN]);
+
+  assert.deepEqual(result.facts, []);
+});
+
+test("gateway extraction discards literal structural placeholders", async () => {
+  const engine = new ExtractionEngine(parseConfig({ modelSource: "gateway" }));
+  const fallbackLlm: GatewayFixture = {
+    async parseWithSchemaDetailed() {
+      return { modelUsed: "fixture-gateway", result: GATEWAY_PLACEHOLDER_EXTRACTION };
+    },
+  };
+  assert.equal(Reflect.set(engine, "fallbackLlm", fallbackLlm), true);
+
+  const result = await engine.extract([SOURCE_TURN]);
+
+  assert.deepEqual(result.facts, []);
+  assert.deepEqual(result.profileUpdates, []);
+  assert.deepEqual(result.entities, []);
+  assert.deepEqual(result.questions, []);
+  assert.deepEqual(result.relationships, []);
+  assert.equal(result.identityReflection, undefined);
+});
+
 test("gateway extraction prompt uses placeholders and accepts an empty question list", async () => {
   const engine = new ExtractionEngine(parseConfig({ modelSource: "gateway" }));
   let calls = 0;