@remnic/core 9.69.50 → 9.69.52

package/src/procedural/procedure-recall.ts

@@ -1,5 +1,6 @@
 /**
  * Intent-gated recall for active procedure memories (issue #519).
+ * Session-end experience episodes (issue #2979) compete here after promotion.
  */
 
 import type { MemoryFile, PluginConfig } from "../types.js";
@@ -9,6 +10,10 @@ import { isActiveMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
 import { canRecallToolScopedMemory } from "../tool-scoped-memory.js";
 import { resolveSecurityCapabilities } from "../capabilities.js";
 import { renderAuthorityBoundContent } from "../recall-context-composition.js";
+import {
+  renderSessionExperiencePreview,
+  scoreSessionExperienceForPrompt,
+} from "../experience/session-experience-recall.js";
 
 function tokenOverlapScore(prompt: string, memoryText: string): number {
   const norm = (s: string) =>
@@ -31,12 +36,16 @@ function scoreProcedureForPrompt(
   m: MemoryFile,
   prompt: string,
   queryIntent: ReturnType<typeof inferIntentFromText>,
+  experienceEnabled: boolean,
 ): number {
   const memText = `${m.content}\n${(m.frontmatter.tags ?? []).join(" ")}`;
   const jaccard = tokenOverlapScore(prompt, memText);
   const memIntent = inferIntentFromText(m.content.slice(0, 2000));
   const intentScore = intentCompatibilityScore(queryIntent, memIntent);
-  return jaccard * 0.55 + intentScore * 0.45;
+  const base = jaccard * 0.55 + intentScore * 0.45;
+  if (!experienceEnabled) return base;
+  const experience = scoreSessionExperienceForPrompt(m, prompt);
+  return experience === null ? base : Math.max(base, experience);
 }
 
 /**
@@ -83,6 +92,7 @@ export async function buildProcedureRecallSection(
   );
 
   const all = await storage.readAllMemories();
+  const experienceEnabled = config.sessionExperience?.enabled === true;
   const scored = all
     .filter(
       (m) =>
@@ -91,7 +101,7 @@ export async function buildProcedureRecallSection(
         (options?.partitionToolScoped !== true ||
           canRecallToolScopedMemory(m.frontmatter, options.requestingConnector)),
     )
-    .map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent) }))
+    .map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent, experienceEnabled) }))
     .filter((x) => x.score > 0.04)
     .sort((a, b) => b.score - a.score)
     .slice(0, maxN);
@@ -110,7 +120,8 @@ export async function buildProcedureRecallSection(
   const security = resolveSecurityCapabilities(config);
   const blocks = scored.map(({ m, score }) => {
     const id = m.frontmatter.id;
-    const flat = m.content.replace(/\s+/g, " ").trim();
+    const labeled = experienceEnabled ? renderSessionExperiencePreview(m) : null;
+    const flat = (labeled ?? m.content).replace(/\s+/g, " ").trim();
     const preview = flat.slice(0, 320);
     const suffix = flat.length > 320 ? "…" : "";
     const body = renderAuthorityBoundContent(`${preview}${suffix}`, m.frontmatter.origin, {

package/src/recall-audit.test.ts

@@ -49,3 +49,37 @@ test("pruneRecallAuditEntries removes day directories older than retention", asy
   assert.equal((await stat(keepDir)).isDirectory(), true);
   await assert.rejects(stat(deleteDir));
 });
+
+test("#2972 audit entry persists degradation when present and omits it otherwise", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-recall-audit-deg-"));
+  const healthy = {
+    ts: "2026-04-12T14:30:12.445Z",
+    sessionKey: "agent/main:session/healthy",
+    agentId: "main",
+    trigger: "access-surface",
+    queryText: "How did the CI outage resolve?",
+    candidateMemoryIds: ["mem_1"],
+    summary: "CI recovered.",
+    injectedChars: 12,
+    toggleState: "enabled" as const,
+  };
+  const degraded = {
+    ...healthy,
+    sessionKey: "agent/main:session/degraded",
+    degradation: {
+      state: "degraded" as const,
+      reason: "budget-compacted" as const,
+      budget: { contextBudget: 80, fullChars: 200, deliveredChars: 80 },
+    },
+  };
+
+  await appendRecallAuditEntry(root, healthy);
+  await appendRecallAuditEntry(root, degraded);
+
+  const healthyPath = buildRecallAuditPath(root, healthy.ts, healthy.sessionKey);
+  const degradedPath = buildRecallAuditPath(root, degraded.ts, degraded.sessionKey);
+  assert.deepEqual(JSON.parse((await readFile(healthyPath, "utf8")).trim()), healthy);
+  assert.equal("degradation" in JSON.parse((await readFile(healthyPath, "utf8")).trim()), false);
+  assert.deepEqual(JSON.parse((await readFile(degradedPath, "utf8")).trim()), degraded);
+});
+

package/src/recall-audit.ts

@@ -2,6 +2,8 @@ import type { Dirent } from "node:fs";
 import { appendFile, mkdir, readdir, rm } from "node:fs/promises";
 import path from "node:path";
 
+import type { RecallContextDegradation } from "./recall-context-composition.js";
+
 export interface RecallAuditEntry {
   ts: string;
   sessionKey: string;
@@ -16,6 +18,8 @@ export interface RecallAuditEntry {
   plannerMode?: string;
   requestedMode?: string;
   fallbackUsed?: boolean;
+  /** Injected-context degradation (#2972). Absent on a healthy recall. */
+  degradation?: RecallContextDegradation;
 }
 
 function formatIsoDate(ts: string): string {

package/src/recall-composition-decision.test.ts

@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { abortError } from "./abort-error.js";
+import {
+  compactRecallContextFromBuckets,
+  decideRecallContextComposition,
+  notifyContextComposition,
+  recallFailureComposition,
+} from "./recall-composition-decision.js";
+
+test("#2972 healthy recall composition carries no degradation marker", () => {
+  const { composition, truncated } = decideRecallContextComposition({
+    context: "A remembered deployment decision.",
+    maxChars: 512,
+  });
+
+  assert.equal("degradation" in composition, false);
+  assert.equal(truncated, false);
+  assert.ok(!JSON.stringify(composition).includes("degradation"));
+});
+
+test("#2972 empty recall stays marker-free", () => {
+  const { composition, context } = decideRecallContextComposition({
+    context: "",
+    maxChars: 512,
+  });
+
+  assert.equal(context, "");
+  assert.equal("degradation" in composition, false);
+});
+
+test("#2972 compact form from section buckets is preferred over clipping", () => {
+  const longOne = "full-form entry one with a long body ".repeat(6).trim();
+  const longTwo = "full-form entry two with a long body ".repeat(6).trim();
+  const buckets = new Map<string, Array<string | { content: string }>>([
+    [
+      "memories",
+      [
+        "## Relevant Memories",
+        { content: `[1] notes/one.md (score: 0.900)\n${longOne}` },
+        { content: `[2] notes/two.md (score: 0.800)\n${longTwo}` },
+      ],
+    ],
+  ]);
+  const compactContext = compactRecallContextFromBuckets(buckets);
+  assert.equal(
+    compactContext,
+    "## Relevant Memories\n[1] notes/one.md (score: 0.900)\n[2] notes/two.md (score: 0.800)",
+  );
+
+  const fullContext = `[1] notes/one.md (score: 0.900)\n${longOne}\n\n[2] notes/two.md (score: 0.800)\n${longTwo}`;
+  assert.ok(fullContext.length > compactContext.length);
+  assert.ok(compactContext.length <= 90);
+
+  const { composition, truncated } = decideRecallContextComposition({
+    context: fullContext,
+    compactContext,
+    maxChars: 90,
+  });
+
+  assert.equal(composition.context, compactContext);
+  assert.equal(composition.degradation?.state, "degraded");
+  assert.equal(composition.degradation?.reason, "budget-compacted");
+  assert.equal(truncated, true);
+});
+
+test("#2972 whitespace-only context stays marker-free", () => {
+  const { composition, context, truncated } = decideRecallContextComposition({
+    context: "   ",
+    maxChars: 512,
+  });
+
+  assert.equal(context, "");
+  assert.equal("degradation" in composition, false);
+  assert.equal(truncated, false);
+});
+
+test("#2972 recall failure composition is missing, abort stays silent", () => {
+  const timeout = recallFailureComposition(new Error("recall timeout"));
+  assert.equal(timeout?.degradation?.state, "missing");
+  assert.equal(timeout?.degradation?.reason, "backend-unavailable");
+  assert.equal(timeout?.degradation?.detail, "timeout");
+  assert.match(timeout?.context ?? "", /memory context unavailable/i);
+
+  const failed = recallFailureComposition(new Error("qmd exploded"));
+  assert.equal(failed?.degradation?.detail, "recall_failed");
+
+  assert.equal(recallFailureComposition(abortError("recall aborted")), null);
+});
+
+test("#2972 composition observer is fail-open", async () => {
+  const seen: unknown[] = [];
+  notifyContextComposition(
+    (composition) => {
+      seen.push(composition.context);
+    },
+    { context: "ok" },
+    () => {
+      throw new Error("onError must not run on success");
+    },
+  );
+  assert.deepEqual(seen, ["ok"]);
+
+  const errors: unknown[] = [];
+  notifyContextComposition(
+    () => {
+      throw new Error("observer boom");
+    },
+    { context: "ok" },
+    (err) => {
+      errors.push(err);
+    },
+  );
+  assert.equal(errors.length, 1);
+
+  await new Promise<void>((resolve, reject) => {
+    notifyContextComposition(
+      async () => {
+        throw new Error("async boom");
+      },
+      { context: "ok" },
+      (err) => {
+        try {
+          assert.equal((err as Error).message, "async boom");
+          resolve();
+        } catch (caught) {
+          reject(caught);
+        }
+      },
+    );
+  });
+});
+

package/src/recall-composition-decision.ts

@@ -0,0 +1,113 @@
+/**
+ * Recall composition decision (#2972 layer 2).
+ *
+ * Extracted from recall-internal so that file stays under its ratchet
+ * ceiling. Classifies injected memory context as complete / degraded /
+ * missing, builds the compact (first-line) form from section buckets,
+ * and turns outer-recall failures into the missing-note instead of "".
+ */
+
+import { isAbortError } from "./abort-error.js";
+import {
+  boundRecallContextComposition,
+  composeMissingMemoryContext,
+  composeRecallContext,
+  RECALL_CONTEXT_SEPARATOR,
+  type RecallContextComposition,
+} from "./recall-context-composition.js";
+
+export type RecallCompositionChunk = string | { readonly content: string };
+
+export interface DecideRecallContextCompositionInput {
+  context: string;
+  compactContext?: string;
+  footer?: string;
+  maxChars: number;
+}
+
+export interface DecidedRecallContextComposition {
+  composition: RecallContextComposition;
+  context: string;
+  truncated: boolean;
+}
+
+function firstLine(content: string): string {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return "";
+  const newline = trimmed.indexOf("\n");
+  return newline === -1 ? trimmed : trimmed.slice(0, newline).trimEnd();
+}
+
+function chunkContent(chunk: RecallCompositionChunk): string {
+  return typeof chunk === "string" ? chunk : chunk.content;
+}
+
+/**
+ * Shallow form of every section chunk: the first line of each entry,
+ * so a budget miss prefers breadth-complete-but-shallow over a clipped
+ * tail. Empty chunks contribute nothing.
+ */
+export function compactRecallContextFromBuckets(
+  buckets: Iterable<readonly [unknown, readonly RecallCompositionChunk[]]>,
+): string {
+  const sections: string[] = [];
+  for (const [, chunks] of buckets) {
+    const lines: string[] = [];
+    for (const chunk of chunks) {
+      const line = firstLine(chunkContent(chunk));
+      if (line.length > 0) lines.push(line);
+    }
+    if (lines.length > 0) sections.push(lines.join("\n"));
+  }
+  return sections.join(RECALL_CONTEXT_SEPARATOR);
+}
+
+export function decideRecallContextComposition(
+  input: DecideRecallContextCompositionInput,
+): DecidedRecallContextComposition {
+  const composition = boundRecallContextComposition({
+    context: input.context,
+    footer: input.footer,
+    maxChars: input.maxChars,
+    compactContext: input.compactContext,
+  });
+  return {
+    composition,
+    context: composeRecallContext(composition),
+    truncated:
+      composition.degradation?.reason === "budget-clipped" ||
+      composition.degradation?.reason === "budget-compacted",
+  };
+}
+
+export function notifyContextComposition(
+  onContextComposition:
+    | ((composition: RecallContextComposition) => void | PromiseLike<void>)
+    | undefined,
+  composition: RecallContextComposition,
+  onError: (err: unknown) => void,
+): void {
+  if (!onContextComposition) return;
+  try {
+    const result = onContextComposition(composition);
+    if (result && typeof result.then === "function") {
+      void Promise.resolve(result).catch(onError);
+    }
+  } catch (err) {
+    onError(err);
+  }
+}
+
+/**
+ * Outer-recall failure: abort stays silent (empty string). Timeout and
+ * other errors become the missing-note so a failed query is never
+ * indistinguishable from "no matches".
+ */
+export function recallFailureComposition(err: unknown): RecallContextComposition | null {
+  if (isAbortError(err)) return null;
+  const detail =
+    err instanceof Error && err.message === "recall timeout"
+      ? "timeout"
+      : "recall_failed";
+  return composeMissingMemoryContext({ detail });
+}

package/src/recall-xray-renderer.test.ts

@@ -615,3 +615,20 @@ test("renderXrayText tier-explain block matches shared helper output", async ()
     assert.ok(nullText.includes(line));
   }
 });
+
+test("#2972 xray text and markdown surface degradation only when present", () => {
+  const healthy = minimalSnapshot();
+  const degraded = {
+    ...minimalSnapshot(),
+    degradation: {
+      state: "degraded" as const,
+      reason: "budget-clipped" as const,
+    },
+  };
+  const healthyText = renderXrayText(healthy);
+  assert.equal(healthyText.includes("degradation:"), false);
+  assert.match(renderXrayText(degraded), /degradation: degraded\/budget-clipped/);
+  assert.equal(renderXrayMarkdown(healthy).includes("| Degradation |"), false);
+  assert.match(renderXrayMarkdown(degraded), /\| Degradation \| degraded\/budget-clipped \|/);
+});
+

package/src/recall-xray-renderer.ts

@@ -108,6 +108,11 @@ export function renderXrayText(snapshot: RecallXraySnapshot | null): string {
   lines.push(
     `budget: ${snapshot.budget.used} / ${snapshot.budget.chars} chars`,
   );
+  if (snapshot.degradation) {
+    lines.push(
+      `degradation: ${snapshot.degradation.state}/${snapshot.degradation.reason}`,
+    );
+  }
 
   lines.push("");
   lines.push("--- filters ---");
@@ -247,6 +252,11 @@ export function renderXrayMarkdown(
   lines.push(
     `| Budget | ${snapshot.budget.used} / ${snapshot.budget.chars} chars |`,
   );
+  if (snapshot.degradation) {
+    lines.push(
+      `| Degradation | ${snapshot.degradation.state}/${snapshot.degradation.reason} |`,
+    );
+  }
 
   lines.push("");
   lines.push("## Filters");

package/src/recall-xray.test.ts

@@ -650,3 +650,31 @@ test("RecallXrayBuilder clones the trust projection so the snapshot surfaces it
     "quarantine reason preserved so exclusion never looks like 'no result' (rule 34)",
   );
 });
+
+test("#2972 healthy xray snapshot omits the degradation marker", () => {
+  const snapshot = buildXraySnapshot({
+    query: "q",
+    now: fixedNow,
+    snapshotIdGenerator: idGen(),
+  });
+  assert.equal("degradation" in snapshot, false);
+  assert.ok(!JSON.stringify(snapshot).includes("degradation"));
+});
+
+test("#2972 xray snapshot copies degradation and isolates caller mutation", () => {
+  const degradation = {
+    state: "degraded" as const,
+    reason: "budget-clipped" as const,
+    budget: { contextBudget: 20, fullChars: 100, deliveredChars: 20 },
+  };
+  const snapshot = buildXraySnapshot({
+    query: "q",
+    degradation,
+    now: fixedNow,
+    snapshotIdGenerator: idGen(),
+  });
+  assert.deepEqual(snapshot.degradation, degradation);
+  degradation.budget.deliveredChars = 0;
+  assert.equal(snapshot.degradation?.budget?.deliveredChars, 20);
+});
+

package/src/recall-xray.ts

@@ -24,6 +24,7 @@ import { estimateTokenCount } from "./token-estimate.js";
 import type { RecallDisclosure, RecallTierExplain } from "./types.js";
 import type { StateLabel } from "./recall-state-view.js";
 import { isRecallDisclosure } from "./types.js";
+import type { RecallContextDegradation } from "./recall-context-composition.js";
 
 /**
  * Estimate token cost of a payload for X-ray disclosure accounting.
@@ -282,6 +283,12 @@ export interface RecallXraySnapshot {
    * absent) means no peer profile was injected.
    */
   peerProfileInjection?: RecallXrayPeerProfileInjection | null;
+  /**
+   * Injected-context degradation (#2972). Absent on a healthy recall so
+   * the snapshot stays byte-stable. Budget warnings ride here, never
+   * in the injected text.
+   */
+  degradation?: RecallContextDegradation;
 }
 
 // ─── Builder ──────────────────────────────────────────────────────────────
@@ -300,6 +307,8 @@ export interface BuildXraySnapshotInput {
   traceId?: string;
   /** Peer-profile injection metadata (issue #679 completion). */
   peerProfileInjection?: RecallXrayPeerProfileInjection | null;
+  /** Injected-context degradation (#2972). Omit on a healthy recall. */
+  degradation?: RecallContextDegradation;
   /** Optional injected timestamp for deterministic tests. */
   now?: () => number;
   /** Optional injected id generator for deterministic tests. */
@@ -375,6 +384,12 @@ export function buildXraySnapshot(
   if (peerProfileInjection !== undefined) {
     out.peerProfileInjection = peerProfileInjection;
   }
+  if (input.degradation && typeof input.degradation === "object") {
+    out.degradation = { ...input.degradation };
+    if (input.degradation.budget) {
+      out.degradation.budget = { ...input.degradation.budget };
+    }
+  }
   return out;
 }
 

package/src/testing/subjects/recall-recognition-tier.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Recognition-tier swap subject for the scenario-matrix harness (issue #2975).
+ *
+ * Every canonical row runs the real fetchQmdMemoryResultsWithRecognitionSwap
+ * seam twice: gate off (original fetch only, zero index I/O, zero recognizer
+ * calls) and gate on with an under-threshold index (one recognizer call, the
+ * namespace never reaches vector search). The scenario dimensions are
+ * orthogonal to this routing decision, so the same invariant holds per row.
+ */
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+
+import {
+  fetchQmdMemoryResultsWithRecognitionSwap,
+  type RecognitionSearchDeps,
+} from "../../orchestration/recall-recognition-search.js";
+import { saveRecognitionIndex } from "../../recall-recognition-tier.js";
+import type { QmdSearchResult } from "../../types.js";
+import { type LifecycleSubject, type MatrixRow, runLifecycleMatrix } from "../lifecycle-matrix.js";
+interface SwapState {
+  rowId: string;
+  dir: string;
+  deps: (enabled: boolean) => RecognitionSearchDeps;
+  fetchCalls: number;
+  recognizeCalls: number;
+  storageForCalls: number;
+}
+
+const subject: LifecycleSubject<SwapState> = {
+  async setup(row: MatrixRow): Promise<SwapState> {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-recognition-subject-"));
+    await saveRecognitionIndex(dir, {
+      version: 1,
+      entries: [
+        { id: `m-${row.id}-a`, description: `trigger for ${row.id}-a` },
+        { id: `m-${row.id}-b`, description: `trigger for ${row.id}-b` },
+      ],
+    });
+    const state: SwapState = { rowId: String(row.id), dir, deps: undefined as never, fetchCalls: 0, recognizeCalls: 0, storageForCalls: 0 };
+    state.deps = (enabled) =>
+      ({
+        config: { recallRecognitionTier: enabled, recognitionIndexMaxEntries: 500 },
+        storageRouter: {
+          storageFor: async () => {
+            state.storageForCalls += 1;
+            return {
+              dir,
+              findExistingMemoryPaths: async (ids: string[]) =>
+                new Map(ids.map((id) => [id, [path.join(dir, `facts/${id}.md`)]])),
+            };
+          },
+        },
+        fastLlmForRerank: {
+          chatCompletion: async () => {
+            state.recognizeCalls += 1;
+            return { content: JSON.stringify([`m-${row.id}-a`, `m-${row.id}-b`]) };
+          },
+        },
+        fetchQmdMemoryResultsWithArtifactTopUp: async (): Promise<QmdSearchResult[]> => {
+          state.fetchCalls += 1;
+          return [{ docid: `default:vector.md`, namespace: "default", path: "vector.md", score: 1, snippet: "vector" }];
+        },
+      }) as unknown as RecognitionSearchDeps;
+    return state;
+  },
+
+  async exercise(state): Promise<void> {
+    const options = {
+      namespacesEnabled: true,
+      recallNamespaces: ["default"],
+      resolveNamespace: () => "default",
+    };
+
+    const off = await fetchQmdMemoryResultsWithRecognitionSwap(state.deps(false), "q", 5, 7, options);
+    assert.equal(off.length, 1);
+    assert.equal(state.fetchCalls, 1);
+    assert.equal(state.recognizeCalls, 0);
+    assert.equal(state.storageForCalls, 0);
+
+    const on = await fetchQmdMemoryResultsWithRecognitionSwap(state.deps(true), "q", 5, 7, options);
+    assert.equal(state.recognizeCalls, 1);
+    assert.equal(state.fetchCalls, 1, "recognition namespace must not reach vector fetch");
+    assert.deepEqual(on.map((r) => r.path).sort(), [`facts/m-${state.rowId}-a.md`, `facts/m-${state.rowId}-b.md`].sort());
+  },
+
+  async invariants(state): Promise<void> {
+    // Off-path again after the on-path run: still a pure passthrough.
+    const before = { fetch: state.fetchCalls, recognize: state.recognizeCalls, storage: state.storageForCalls };
+    await fetchQmdMemoryResultsWithRecognitionSwap(state.deps(false), "q", 5, 7, {
+      namespacesEnabled: true,
+      recallNamespaces: ["default"],
+      resolveNamespace: () => "default",
+    });
+    assert.equal(state.fetchCalls, before.fetch + 1);
+    assert.equal(state.recognizeCalls, before.recognize);
+    assert.equal(state.storageForCalls, before.storage);
+  },
+
+  async teardown(state): Promise<void> {
+    await rm(state.dir, { recursive: true, force: true });
+  },
+};
+
+runLifecycleMatrix("recall-recognition-tier", subject);

package/src/types.ts

@@ -23,6 +23,7 @@ import type {
 import type { DeepRecallSettings } from "./deep-recall-config.js";
 import type { RecallNavigationSettings } from "./recall-navigation-config.js";
 import type { RecognitionTierSettings } from "./recall-recognition-tier.js";
+import type { SeedGraduationSettings } from "./lifecycle/seed-graduation-config-types.js";
 import type { ProceduralMaintenanceConfig } from "./procedural/maintenance-config.js";
 import type { SkillProjectionConfig } from "./procedural/skill-projection.js";
 import type { SessionExperienceConfig } from "./experience/session-experience-config.js";
@@ -698,6 +699,7 @@ export interface PluginConfig
     DeepRecallSettings,
     RecallNavigationSettings,
     RecognitionTierSettings,
+    SeedGraduationSettings,
     LocalLlmConfig {
   openaiApiKey: string | undefined;
   openaiBaseUrl: string | undefined;
@@ -3877,12 +3879,8 @@ export interface HourlySummary {
   generatedAt: string;
 }
 
-// ============================================================================
-// Dreams Pipeline Telemetry (issue #678 PR 3/4)
-// ============================================================================
-// Re-export from the authoritative source to avoid duplicate definitions.
-// dreams-ledger.ts is the single source of truth; types.ts re-exports so
-// callers that import from types.js continue to work unchanged.
+// Dreams Pipeline Telemetry (issue #678 PR 3/4). Re-export from
+// dreams-ledger.ts so callers importing types.js stay unchanged.
 export type {
   DreamsPhase,
   DreamsPhaseStatus,