@remnic/core 9.69.50 → 9.69.51

package/src/directory-sidecars.ts

@@ -26,12 +26,20 @@
  * for `index.md`/`log.md`) while staying full-text searchable. Files at the
  * sidecar path WITHOUT the marker are user content: never overwritten, never
  * removed.
+ *
+ * Layer 2 (this slice): {@link refreshDirectorySidecarsAfterWrite} refreshes
+ * only the changed directory and its category ancestors, so a memory write
+ * populates sidecars without walking the rest of the store. `enabled: false`
+ * is a proven no-op (no reads, no writes). Config parsing lives here;
+ * `parseConfig` wiring, retrieval drill-down, xray, and LLM summarization
+ * remain later layers on #2977 (`config.ts` is at its file-size ratchet).
  */
 
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import path from "node:path";
 
+import { coerceBooleanLike } from "./connectors/coerce.js";
 import { writeFileAtomically } from "./maintenance/atomic-file.js";
 import { normalizeProjectionPreview } from "./memory-projection-format.js";
 import { OKF_RESERVED_BASENAMES } from "./okf/type-mapping.js";
@@ -43,6 +51,18 @@ export const DIRECTORY_SIDECAR_MARKER = "<!-- remnic-directory-sidecar -->";
 const ABSTRACT_MAX_CHARS = 256;
 const OVERVIEW_MAX_CHARS = 4000;
 const DEFAULT_QUERY_LIMIT = 5;
+const CATEGORY_ROOTS: ReadonlySet<string> = new Set(RECALL_FALLBACK_DIRS);
+
+/** Config fields this slice owns. Mix into `PluginConfig` in a later layer. */
+export interface DirectorySidecarSettings {
+  /** Populate sidecars on memory writes. Default false. */
+  directorySidecarsEnabled: boolean;
+}
+
+/** Strict off-default: only an explicit true/"true"/1 opts in. */
+export function parseDirectorySidecarsEnabled(raw: unknown): boolean {
+  return coerceBooleanLike(raw, "directorySidecarsEnabled") === true;
+}
 
 /** Basenames never treated as child memories (ours plus OKF's reserved ones). */
 const RESERVED_CHILD_BASENAMES: Readonly<Record<string, true>> = Object.freeze({
@@ -238,8 +258,77 @@ function collectSidecarDirs(scopeRoot: string): string[] {
   return dirs;
 }
 
+async function syncSidecarDir(
+  dir: string,
+  enabled: boolean,
+  childAbstracts: Map<string, string>,
+  written: string[],
+  removed: string[],
+): Promise<void> {
+  const target = sidecarPath(dir);
+  const raw = readFileOrNull(target);
+  const existing = raw !== null && raw.startsWith(DIRECTORY_SIDECAR_MARKER) ? raw : null;
+  if (!enabled) {
+    if (existing !== null) {
+      unlinkSync(target);
+      removed.push(target);
+    }
+    return;
+  }
+  const next = renderSidecar(dir, directoryFingerprint(dir), childAbstracts);
+  if (next === null) {
+    if (existing !== null) {
+      unlinkSync(target);
+      removed.push(target);
+    }
+    return;
+  }
+  const parsedNext = parseSidecar(next);
+  if (parsedNext) childAbstracts.set(dir, parsedNext.abstract);
+  if (raw === next) return;
+  if (existing === null && raw !== null) return; // user-authored file: hands off
+  await writeFileAtomically(target, next);
+  written.push(target);
+}
+
+function childAbstractsFromDisk(dir: string): Map<string, string> {
+  const abstracts = new Map<string, string>();
+  for (const name of directoryChildren(dir)) {
+    const childDir = path.join(dir, name);
+    const parsed = parseSidecar(readFileOrNull(sidecarPath(childDir)) ?? "");
+    if (parsed) abstracts.set(childDir, parsed.abstract);
+  }
+  return abstracts;
+}
+
 /**
- * Regenerate directory sidecars incrementally. Unchanged sidecars are left
+ * Category-root ancestry of a changed memory path, deepest first.
+ * Paths outside a recall category return `[]` so writes to `state/` or
+ * `namespaces/<ns>/` itself never mint a sidecar.
+ */
+export function directorySidecarAncestry(memoryDir: string, changedPath: string): string[] {
+  const root = path.resolve(memoryDir);
+  const abs = path.isAbsolute(changedPath) ? path.resolve(changedPath) : path.resolve(root, changedPath);
+  const rel = path.relative(root, abs);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return [];
+  const parts = rel.split(path.sep).filter(Boolean);
+  const dirParts = isRealDirectory(abs) ? parts : parts.slice(0, -1);
+  let categoryAt = -1;
+  if (dirParts[0] === "namespaces" && dirParts.length >= 3 && CATEGORY_ROOTS.has(dirParts[2] ?? "")) {
+    categoryAt = 2;
+  } else if (CATEGORY_ROOTS.has(dirParts[0] ?? "")) {
+    categoryAt = 0;
+  }
+  if (categoryAt === -1) return [];
+  const dirs: string[] = [];
+  for (let i = dirParts.length; i > categoryAt; i--) {
+    dirs.push(path.join(root, ...dirParts.slice(0, i)));
+  }
+  return dirs;
+}
+
+/**
+ * Regenerates directory sidecars incrementally. Unchanged sidecars are left
  * untouched; emptied directories lose theirs; user files at the sidecar path
  * (no marker) are never written or removed. With `enabled: false` every
  * generated sidecar is removed — the OKF index-maintenance contract.
@@ -253,35 +342,31 @@ export async function runDirectorySidecarMaintenance(
   for (const scope of scopeRoots(memoryDir)) {
     const childAbstracts = new Map<string, string>();
     for (const dir of collectSidecarDirs(scope)) {
-      const target = sidecarPath(dir);
-      const raw = readFileOrNull(target);
-      const existing = raw !== null && raw.startsWith(DIRECTORY_SIDECAR_MARKER) ? raw : null;
-      if (!enabled) {
-        if (existing !== null) {
-          unlinkSync(target);
-          removed.push(target);
-        }
-        continue;
-      }
-      const next = renderSidecar(dir, directoryFingerprint(dir), childAbstracts);
-      if (next === null) {
-        if (existing !== null) {
-          unlinkSync(target);
-          removed.push(target);
-        }
-        continue;
-      }
-      const parsedNext = parseSidecar(next);
-      if (parsedNext) childAbstracts.set(dir, parsedNext.abstract);
-      if (raw === next) continue;
-      if (existing === null && raw !== null) continue; // user-authored file: hands off
-      await writeFileAtomically(target, next);
-      written.push(target);
+      await syncSidecarDir(dir, enabled, childAbstracts, written, removed);
     }
   }
   return { written, removed };
 }
 
+/**
+ * Incremental write-path refresh: only the changed directory and its
+ * category ancestors, using the same fingerprint/render path as maintenance.
+ * `enabled: false` returns immediately — no readdir, no writes.
+ */
+export async function refreshDirectorySidecarsAfterWrite(
+  memoryDir: string,
+  changedPath: string,
+  enabled: boolean,
+): Promise<DirectorySidecarReport> {
+  if (!enabled) return { written: [], removed: [] };
+  const written: string[] = [];
+  const removed: string[] = [];
+  for (const dir of directorySidecarAncestry(memoryDir, changedPath)) {
+    await syncSidecarDir(dir, true, childAbstractsFromDisk(dir), written, removed);
+  }
+  return { written, removed };
+}
+
 /**
  * Read a directory's sidecar for retrieval. By default a stale sidecar is
  * refreshed in place (child directories first), which is what makes direct

package/src/experience/session-experience-recall.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Session-end experience recall injection (issue #2979 layer 2).
+ *
+ * Promoted experience memories compete in the existing procedure-recall
+ * slot and share `recallMaxProcedures`. pending_review never injects.
+ * Gate off: extraction still makes zero storage calls; recall does not
+ * inspect experience attributes (no Experience preview prefix).
+ */
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { parseConfig } from "../config.js";
+import type { BufferTurn, PluginConfig } from "../types.js";
+import type { SealedMemoryEnvelope } from "../write-envelope.js";
+import { StorageManager } from "../storage.js";
+import { buildProcedureRecallSection } from "../procedural/procedure-recall.js";
+import { buildProcedureMarkdownBody } from "../procedural/procedure-types.js";
+import { runSessionExperienceExtraction } from "./session-experience.js";
+import {
+  isSessionExperienceMemory,
+  renderSessionExperiencePreview,
+  scoreSessionExperienceForPrompt,
+} from "./session-experience-recall.js";
+
+function turn(role: "user" | "assistant", content: string): BufferTurn {
+  return { role, content, timestamp: "2026-01-15T10:00:00.000Z" };
+}
+
+function successSession(): BufferTurn[] {
+  return [
+    turn("user", "Fix the failing integration test in the payments module. The test times out after 30 seconds."),
+    turn("assistant", "I will inspect the payments test file and reproduce the timeout locally first."),
+    turn("assistant", "The timeout came from an unawaited database call in the test setup. I added the missing await."),
+    turn("assistant", "Verified: the payments integration test passes now and the full suite is green."),
+  ];
+}
+
+const TASK_PROMPT = "Let's fix the failing integration test in the payments module";
+
+function recallConfig(memoryDir: string, experienceEnabled: boolean, recallMaxProcedures = 2): PluginConfig {
+  return parseConfig({
+    memoryDir,
+    workspaceDir: path.join(memoryDir, "ws"),
+    openaiApiKey: "test-key",
+    procedural: { enabled: true, recallMaxProcedures },
+    sessionExperience: { enabled: experienceEnabled },
+  });
+}
+
+function recordingStorage() {
+  const calls: { readAllMemories: number; writeSealedMemory: SealedMemoryEnvelope[] } = {
+    readAllMemories: 0,
+    writeSealedMemory: [],
+  };
+  const storage = {
+    async readAllMemories() {
+      calls.readAllMemories += 1;
+      return [];
+    },
+    async writeSealedMemory(envelope: SealedMemoryEnvelope) {
+      calls.writeSealedMemory.push(envelope);
+      return { id: "should-not-write" };
+    },
+  };
+  return { storage, calls };
+}
+
+test("gate off: session-end extraction still performs zero storage calls after recall wiring", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-off-"));
+  try {
+    const config = parseConfig({ memoryDir });
+    assert.equal(config.sessionExperience.enabled, false);
+    const { storage, calls } = recordingStorage();
+    const result = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-off",
+      config,
+      storage,
+    });
+    assert.deepEqual(result, { written: false, skippedReason: "session_experience_disabled" });
+    assert.equal(calls.readAllMemories, 0);
+    assert.equal(calls.writeSealedMemory.length, 0);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("pending_review experience is not injected into procedure-recall", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-pending-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    const config = recallConfig(memoryDir, true);
+    const written = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-pending",
+      config,
+      storage,
+    });
+    assert.equal(written.written, true);
+    const memories = await storage.readAllMemories();
+    assert.equal(memories[0]?.frontmatter.status, "pending_review");
+    const section = await buildProcedureRecallSection(storage, TASK_PROMPT, config);
+    assert.equal(section, null, "pending_review must not occupy a procedure-recall slot");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("promoted experience injects through procedure-recall with an Experience preview", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-on-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    const config = recallConfig(memoryDir, true);
+    const written = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-on",
+      config,
+      storage,
+    });
+    assert.equal(written.written, true);
+    assert.ok(written.memoryId);
+    const promoted = await storage.updateMemoryFrontmatter(written.memoryId, { status: "active" });
+    assert.equal(promoted, true);
+    const section = await buildProcedureRecallSection(storage, TASK_PROMPT, config);
+    assert.ok(section);
+    assert.match(section, /## Relevant procedures/);
+    assert.match(section, new RegExp(written.memoryId));
+    assert.match(section, /Experience\. Situation:/);
+    assert.match(section, /payments/i);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("experience and procedure share recallMaxProcedures; situation match wins cap 1", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-budget-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    const config = recallConfig(memoryDir, true, 1);
+    const written = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-budget",
+      config,
+      storage,
+    });
+    assert.equal(written.written, true);
+    await storage.updateMemoryFrontmatter(written.memoryId, { status: "active" });
+    const body = buildProcedureMarkdownBody([
+      { order: 1, intent: "Run deploy checks for production gateway" },
+      { order: 2, intent: "Push the release tag" },
+    ]);
+    const other = await storage.writeMemory(
+      "procedure",
+      `When you deploy the gateway\n\n${body}`,
+      { source: "test", tags: ["deploy", "gateway"] },
+    );
+    const section = await buildProcedureRecallSection(storage, TASK_PROMPT, config);
+    assert.ok(section);
+    assert.match(section, new RegExp(written.memoryId));
+    assert.doesNotMatch(section, new RegExp(other.id));
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("gate off: promoted experience may inject as a procedure but without Experience preview", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-generic-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    const enabled = recallConfig(memoryDir, true);
+    const written = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-generic",
+      config: enabled,
+      storage,
+    });
+    assert.equal(written.written, true);
+    await storage.updateMemoryFrontmatter(written.memoryId, { status: "active" });
+    const off = recallConfig(memoryDir, false);
+    const section = await buildProcedureRecallSection(storage, TASK_PROMPT, off);
+    if (section !== null) {
+      assert.match(section, new RegExp(written.memoryId));
+      assert.doesNotMatch(section, /Experience\. Situation:/);
+    }
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("helpers: non-experience memories score/render as null; episodes label Situation", async () => {
+  const memoryDir = await mkdtemp(path.join(tmpdir(), "remnic-sx-recall-helpers-"));
+  try {
+    const storage = new StorageManager(memoryDir);
+    await storage.ensureDirectories();
+    const other = await storage.writeMemory("procedure", "When you deploy the gateway, run the smoke suite.", {
+      source: "test",
+    });
+    const otherFile = (await storage.readAllMemories()).find((m) => m.frontmatter.id === other.id);
+    assert.ok(otherFile);
+    assert.equal(isSessionExperienceMemory(otherFile), false);
+    assert.equal(scoreSessionExperienceForPrompt(otherFile, TASK_PROMPT), null);
+    assert.equal(renderSessionExperiencePreview(otherFile), null);
+
+    const config = recallConfig(memoryDir, true);
+    const written = await runSessionExperienceExtraction({
+      turns: successSession(),
+      sessionKey: "session-recall-helpers",
+      config,
+      storage,
+    });
+    assert.equal(written.written, true);
+    const episode = (await storage.readAllMemories()).find((m) => m.frontmatter.id === written.memoryId);
+    assert.ok(episode);
+    assert.equal(isSessionExperienceMemory(episode), true);
+    const score = scoreSessionExperienceForPrompt(episode, TASK_PROMPT);
+    assert.ok(score !== null && score > 0.04);
+    assert.match(renderSessionExperiencePreview(episode) ?? "", /Experience\. Situation:.*payments/i);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/experience/session-experience-recall.ts

@@ -0,0 +1,60 @@
+/**
+ * Session-experience recall helpers (issue #2979 layer 2).
+ *
+ * Promoted experience memories are `category: procedure`, so they already
+ * compete in `buildProcedureRecallSection` and share `recallMaxProcedures`.
+ * These helpers add situation-overlap scoring and an Experience preview.
+ * Call them only when `sessionExperience.enabled` is true — the gate-off
+ * path must not inspect experience attributes.
+ */
+
+import type { MemoryFile } from "../types.js";
+
+function tokenOverlapScore(prompt: string, memoryText: string): number {
+  const norm = (s: string) =>
+    s
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter((t) => t.length > 2);
+  const promptTokens = new Set(norm(prompt));
+  const memTokens = new Set(norm(memoryText));
+  if (promptTokens.size === 0 || memTokens.size === 0) return 0;
+  let inter = 0;
+  for (const t of promptTokens) {
+    if (memTokens.has(t)) inter++;
+  }
+  const union = new Set([...promptTokens, ...memTokens]);
+  return inter / Math.max(1, union.size);
+}
+
+export function isSessionExperienceMemory(memory: MemoryFile): boolean {
+  const hash = memory.frontmatter.structuredAttributes?.experience_session_hash;
+  return typeof hash === "string" && hash.length > 0;
+}
+
+/**
+ * Situation-overlap score in `[0, 1]`, or `null` when the memory is not a
+ * session-experience episode. Caller keeps the generic procedure score.
+ */
+export function scoreSessionExperienceForPrompt(memory: MemoryFile, prompt: string): number | null {
+  if (!isSessionExperienceMemory(memory)) return null;
+  const situation = memory.frontmatter.structuredAttributes?.experience_situation ?? "";
+  const situationScore = tokenOverlapScore(prompt, situation);
+  const bodyScore = tokenOverlapScore(prompt, memory.content);
+  return Math.min(1, situationScore * 0.75 + bodyScore * 0.25);
+}
+
+/** Flattened Experience preview, or `null` when the memory is not an episode. */
+export function renderSessionExperiencePreview(memory: MemoryFile): string | null {
+  if (!isSessionExperienceMemory(memory)) return null;
+  const attrs = memory.frontmatter.structuredAttributes ?? {};
+  const situation = (attrs.experience_situation ?? "").trim();
+  const approach = (attrs.experience_approach ?? "").trim();
+  const reflection = (attrs.experience_reflection ?? "").trim();
+  if (situation.length === 0 && approach.length === 0 && reflection.length === 0) {
+    return `Experience. ${memory.content.replace(/\s+/g, " ").trim()}`;
+  }
+  return `Experience. Situation: ${situation} Approach: ${approach} Reflection: ${reflection}`
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/src/index.ts

@@ -469,6 +469,7 @@ export {
 export type { ResolveSecretRefFn } from "./resolve-auth-token.js";
 export type { SecretRef, AgentAccessAuthToken } from "./types.js";
 export * from "./recall-context-composition.js";
+export * from "./recall-composition-decision.js";
 // Recall X-ray CLI helpers (issue #570).  Exported so the standalone
 // `@remnic/cli` binary can wire the `remnic xray` command without
 // reimporting core-internal modules by relative path (CLAUDE.md rule 26).

package/src/orchestration/recall-entry.ts

@@ -22,7 +22,12 @@ import type { RecallResultFormatter } from "./recall-result-formatter.js";
 import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../types.js";
 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 { applyRecallStateViews } from "../recall-state-view-wire.js";
+import { composeRecallContext } from "../recall-context-composition.js";
+import {
+  notifyContextComposition,
+  recallFailureComposition,
+} from "../recall-composition-decision.js";
 
 export interface RecallEntryDeps {
   appendRecallSection(
@@ -197,7 +202,16 @@ export class RecallEntryCoordinator {
       // 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();
-      return ""; // Return empty context on timeout/error
+      // 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 "";
+      notifyContextComposition(options.onContextComposition, missing, (observerErr) => {
+        log.warn("recall: context composition observer failed open", observerErr);
+      });
+      return composeRecallContext(missing);
     } finally {
       options.abortSignal?.removeEventListener("abort", onAbort);
     }

package/src/orchestration/recall-internal.ts

@@ -45,9 +45,14 @@ import { buildQmdRecallCacheKey, getCachedQmdRecall, setCachedQmdRecall } from "
 import { MEMORY_ID_PATTERN } from "../recall-handles.js";
 import { shouldRecordRecallAuthorityHistory } from "../recall-navigation-config.js";
 import {
-  boundRecallContextComposition, composeRecallContext, contextBudgetForFooter,
+  contextBudgetForFooter,
   formatCuriosityFooter, renderAuthorityBoundContent, selectCuriosityQuestion,
 } from "../recall-context-composition.js";
+import {
+  compactRecallContextFromBuckets,
+  decideRecallContextComposition,
+  notifyContextComposition,
+} from "../recall-composition-decision.js";
 import {
   createBoundedCoreSectionRunner,
   createRecallSectionMetricRecorder,
@@ -110,6 +115,7 @@ import {
 import type { RecallInternalDeps } from "./recall-internal-deps.js";
 import { appendEpisodicContextSection } from "./episodic-context-section.js";
 import { resolveCompositeProfileStorage } from "./recall-profile-storage.js";
+import { fetchQmdMemoryResultsWithRecognitionSwap } from "./recall-recognition-search.js";
 
 export class RecallInternalCoordinator {
   private readonly securityCapabilities: SecurityCapabilitySet;
@@ -2141,7 +2147,8 @@ export class RecallInternalCoordinator {
 
         try {
           const filteredResults =
-            await this.deps.fetchQmdMemoryResultsWithArtifactTopUp(
+            await fetchQmdMemoryResultsWithRecognitionSwap(
+              this.deps,
               retrievalQuery,
               qmdFetchLimit,
               qmdHybridFetchLimit,
@@ -4951,23 +4958,16 @@ export class RecallInternalCoordinator {
       recalledMemoryNamespaces,
     );
     const recalledContext = assembledRecall.sections.join("\n\n---\n\n");
-    const composition = boundRecallContextComposition({
-      context: recalledContext, footer: curiosityFooter, maxChars: recallBudgetChars,
-    });
-    const context = composeRecallContext(composition);
-    try {
-      const observerResult = options.onContextComposition?.(composition);
-      if (observerResult && typeof observerResult.then === "function") {
-        void Promise.resolve(observerResult).catch((err) => log.warn(
-          "recall: context composition observer rejected", err,
-        ));
-      }
-    } catch (err) {
+    const { composition, context, truncated: compositionTruncated } =
+      decideRecallContextComposition({
+        context: recalledContext,
+        compactContext: compactRecallContextFromBuckets(sectionBuckets),
+        footer: curiosityFooter,
+        maxChars: recallBudgetChars,
+      });
+    notifyContextComposition(options.onContextComposition, composition, (err) => {
       log.warn("recall: context composition observer failed open", err);
-    }
-    const compositionTruncated = context.length < composeRecallContext({
-      context: recalledContext, footer: curiosityFooter,
-    }).length;
+    });
     const includedSections = [...assembledRecall.includedIds];
     const omittedSections = [...assembledRecall.omittedIds];
     if (composition.footer && !includedSections.includes("questions")) includedSections.push("questions");
@@ -5202,6 +5202,9 @@ export class RecallInternalCoordinator {
             chars: this.deps.getRecallBudgetChars(options.budgetCharsOverride),
             used: context.length,
           },
+          ...(composition.degradation
+            ? { degradation: composition.degradation }
+            : {}),
           sessionKey,
           namespace: selfNamespace,
           traceId,