@remnic/core 1.1.0 → 1.1.1

package/dist/chunk-PVPWZSSI.js

@@ -0,0 +1,37 @@
+import {
+  parseXrayFormat
+} from "./chunk-ZAIM4TUE.js";
+
+// src/recall-xray-cli.ts
+function parseXrayBudgetFlag(value) {
+  if (value === void 0 || value === null) return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    throw new Error(
+      `--budget expects a positive integer; got ${JSON.stringify(value)}`
+    );
+  }
+  return parsed;
+}
+function parseXrayCliOptions(rawQuery, options) {
+  if (typeof rawQuery !== "string" || rawQuery.trim().length === 0) {
+    throw new Error("xray: <query> is required and must be non-empty");
+  }
+  const format = parseXrayFormat(options.format);
+  const budget = parseXrayBudgetFlag(options.budget);
+  const namespace = typeof options.namespace === "string" && options.namespace.trim().length > 0 ? options.namespace.trim() : void 0;
+  const outPath = typeof options.out === "string" && options.out.trim().length > 0 ? options.out.trim() : void 0;
+  return {
+    query: rawQuery,
+    format,
+    ...budget !== void 0 ? { budget } : {},
+    ...namespace !== void 0 ? { namespace } : {},
+    ...outPath !== void 0 ? { outPath } : {}
+  };
+}
+
+export {
+  parseXrayBudgetFlag,
+  parseXrayCliOptions
+};
+//# sourceMappingURL=chunk-PVPWZSSI.js.map

package/dist/chunk-PVPWZSSI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-xray-cli.ts"],"sourcesContent":["/**\n * Input-validation helpers for the `remnic xray` CLI command (issue\n * #570, PR 3).\n *\n * Pulled out of `cli.ts` so the validation paths can be unit-tested in\n * isolation — the full CLI handler is hard to exercise without booting\n * an orchestrator.  CLAUDE.md rules 14 + 51 require that `--format`,\n * `--budget`, `--namespace`, and `--out` reject missing-value /\n * unknown / non-positive arguments with a listed-options error, rather\n * than silently defaulting.\n */\n\nimport {\n  parseXrayFormat,\n  type RecallXrayFormat,\n} from \"./recall-xray-renderer.js\";\n\nexport interface ParsedXrayCliOptions {\n  format: RecallXrayFormat;\n  /** Positive integer override, or undefined when not specified. */\n  budget?: number;\n  /** Trimmed namespace, or undefined when not specified. */\n  namespace?: string;\n  /** Trimmed, tilde-unexpanded output path, or undefined when stdout. */\n  outPath?: string;\n}\n\n/**\n * Validate and coerce `--budget <chars>`.  Must be a positive integer;\n * throws a listed-options error otherwise.\n */\nexport function parseXrayBudgetFlag(value: unknown): number | undefined {\n  if (value === undefined || value === null) return undefined;\n  const parsed = typeof value === \"number\" ? value : Number(value);\n  if (\n    !Number.isFinite(parsed) ||\n    parsed <= 0 ||\n    !Number.isInteger(parsed)\n  ) {\n    throw new Error(\n      `--budget expects a positive integer; got ${JSON.stringify(value)}`,\n    );\n  }\n  return parsed;\n}\n\n/**\n * Parse and validate the full option bag for `remnic xray`.  Extracted\n * so the CLI handler in `cli.ts` can stay thin and the validation can\n * be unit-tested without booting an orchestrator.\n */\nexport function parseXrayCliOptions(\n  rawQuery: unknown,\n  options: Record<string, unknown>,\n): { query: string } & ParsedXrayCliOptions {\n  if (typeof rawQuery !== \"string\" || rawQuery.trim().length === 0) {\n    throw new Error(\"xray: <query> is required and must be non-empty\");\n  }\n  const format = parseXrayFormat(options.format);\n  const budget = parseXrayBudgetFlag(options.budget);\n  const namespace =\n    typeof options.namespace === \"string\" &&\n    options.namespace.trim().length > 0\n      ? options.namespace.trim()\n      : undefined;\n  const outPath =\n    typeof options.out === \"string\" && options.out.trim().length > 0\n      ? options.out.trim()\n      : undefined;\n  return {\n    query: rawQuery,\n    format,\n    ...(budget !== undefined ? { budget } : {}),\n    ...(namespace !== undefined ? { namespace } : {}),\n    ...(outPath !== undefined ? { outPath } : {}),\n  };\n}\n"],"mappings":";;;;;AA+BO,SAAS,oBAAoB,OAAoC;AACtE,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,QAAM,SAAS,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;AAC/D,MACE,CAAC,OAAO,SAAS,MAAM,KACvB,UAAU,KACV,CAAC,OAAO,UAAU,MAAM,GACxB;AACA,UAAM,IAAI;AAAA,MACR,4CAA4C,KAAK,UAAU,KAAK,CAAC;AAAA,IACnE;AAAA,EACF;AACA,SAAO;AACT;AAOO,SAAS,oBACd,UACA,SAC0C;AAC1C,MAAI,OAAO,aAAa,YAAY,SAAS,KAAK,EAAE,WAAW,GAAG;AAChE,UAAM,IAAI,MAAM,iDAAiD;AAAA,EACnE;AACA,QAAM,SAAS,gBAAgB,QAAQ,MAAM;AAC7C,QAAM,SAAS,oBAAoB,QAAQ,MAAM;AACjD,QAAM,YACJ,OAAO,QAAQ,cAAc,YAC7B,QAAQ,UAAU,KAAK,EAAE,SAAS,IAC9B,QAAQ,UAAU,KAAK,IACvB;AACN,QAAM,UACJ,OAAO,QAAQ,QAAQ,YAAY,QAAQ,IAAI,KAAK,EAAE,SAAS,IAC3D,QAAQ,IAAI,KAAK,IACjB;AACN,SAAO;AAAA,IACL,OAAO;AAAA,IACP;AAAA,IACA,GAAI,WAAW,SAAY,EAAE,OAAO,IAAI,CAAC;AAAA,IACzC,GAAI,cAAc,SAAY,EAAE,UAAU,IAAI,CAAC;AAAA,IAC/C,GAAI,YAAY,SAAY,EAAE,QAAQ,IAAI,CAAC;AAAA,EAC7C;AACF;","names":[]}

package/dist/{chunk-4NRAJUDS.js → chunk-RBBWYEFJ.js}

@@ -216,4 +216,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-4NRAJUDS.js.map
+//# sourceMappingURL=chunk-RBBWYEFJ.js.map

package/dist/chunk-RFYAYKTD.js

@@ -0,0 +1,146 @@
+// src/recall-audit-anomaly.ts
+var DEFAULT_ANOMALY_DETECTOR_CONFIG = Object.freeze({
+  enabled: false,
+  windowMs: 5 * 6e4,
+  repeatQueryLimit: 5,
+  namespaceWalkLimit: 3,
+  highCardinalityReturnLimit: 50,
+  rapidFireLimit: 30
+});
+function effectiveConfig(raw) {
+  const base = { ...DEFAULT_ANOMALY_DETECTOR_CONFIG };
+  if (!raw) return base;
+  const out = { ...base };
+  if (typeof raw.enabled === "boolean") out.enabled = raw.enabled;
+  if (typeof raw.windowMs === "number" && Number.isFinite(raw.windowMs) && raw.windowMs > 0) {
+    out.windowMs = raw.windowMs;
+  }
+  for (const key of [
+    "repeatQueryLimit",
+    "namespaceWalkLimit",
+    "highCardinalityReturnLimit",
+    "rapidFireLimit"
+  ]) {
+    const v = raw[key];
+    if (typeof v === "number" && Number.isFinite(v) && v > 0) {
+      const floored = Math.floor(v);
+      out[key] = floored >= 1 ? floored : base[key];
+    }
+  }
+  return out;
+}
+function normalizeQueryText(raw) {
+  if (typeof raw !== "string") return "";
+  return raw.toLowerCase().replace(/\s+/g, " ").trim();
+}
+var SEVERITY_ORDER = {
+  alert: 0,
+  warn: 1,
+  info: 2
+};
+function parseTsMs(ts) {
+  const n = new Date(ts).getTime();
+  return Number.isFinite(n) ? n : null;
+}
+function detectRecallAnomalies(input) {
+  const cfg = effectiveConfig(input.config);
+  const cutoff = input.now - cfg.windowMs;
+  const windowed = [];
+  for (let i = 0; i < input.entries.length; i++) {
+    const entry = input.entries[i];
+    const tsMs = parseTsMs(entry.ts);
+    if (tsMs === null) continue;
+    if (tsMs >= cutoff && tsMs <= input.now) {
+      windowed.push({ entry, index: i });
+    }
+  }
+  if (!cfg.enabled) {
+    return { flags: [], windowEntryCount: windowed.length, windowMs: cfg.windowMs };
+  }
+  const flags = [];
+  {
+    const byQuery = /* @__PURE__ */ new Map();
+    for (const { entry, index } of windowed) {
+      const key = normalizeQueryText(entry.queryText);
+      if (key.length === 0) continue;
+      const arr = byQuery.get(key);
+      if (arr) arr.push(index);
+      else byQuery.set(key, [index]);
+    }
+    for (const [query, indices] of byQuery) {
+      if (indices.length > cfg.repeatQueryLimit) {
+        flags.push({
+          kind: "repeat-query",
+          severity: "warn",
+          message: `query "${query}" repeated ${indices.length} times in ${cfg.windowMs}ms`,
+          entryIndices: indices.slice(),
+          signal: query
+        });
+      }
+    }
+  }
+  {
+    const namespaces = /* @__PURE__ */ new Set();
+    const indices = [];
+    for (const { entry, index } of windowed) {
+      if (!Array.isArray(entry.candidateMemoryIds)) continue;
+      let touchedAny = false;
+      for (const id of entry.candidateMemoryIds) {
+        if (typeof id !== "string" || id.length === 0) continue;
+        const slash = id.indexOf("/");
+        if (slash > 0) {
+          namespaces.add(id.slice(0, slash));
+        } else {
+          namespaces.add("__unprefixed__");
+        }
+        touchedAny = true;
+      }
+      if (touchedAny) indices.push(index);
+    }
+    if (namespaces.size > cfg.namespaceWalkLimit) {
+      flags.push({
+        kind: "namespace-walk",
+        severity: "alert",
+        message: `queries touched ${namespaces.size} distinct namespaces in ${cfg.windowMs}ms`,
+        entryIndices: indices,
+        signal: namespaces.size
+      });
+    }
+  }
+  {
+    for (const { entry, index } of windowed) {
+      const ids = Array.isArray(entry.candidateMemoryIds) ? entry.candidateMemoryIds : [];
+      if (ids.length > cfg.highCardinalityReturnLimit) {
+        flags.push({
+          kind: "high-cardinality-return",
+          severity: "alert",
+          message: `single recall returned ${ids.length} candidate memory IDs`,
+          entryIndices: [index],
+          signal: ids.length
+        });
+      }
+    }
+  }
+  if (windowed.length > cfg.rapidFireLimit) {
+    flags.push({
+      kind: "rapid-fire",
+      severity: "warn",
+      message: `${windowed.length} recall entries in ${cfg.windowMs}ms`,
+      entryIndices: windowed.map((w) => w.index),
+      signal: windowed.length
+    });
+  }
+  flags.sort((a, b) => {
+    const s = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+    if (s !== 0) return s;
+    return a.kind.localeCompare(b.kind);
+  });
+  return { flags, windowEntryCount: windowed.length, windowMs: cfg.windowMs };
+}
+
+export {
+  DEFAULT_ANOMALY_DETECTOR_CONFIG,
+  normalizeQueryText,
+  detectRecallAnomalies
+};
+//# sourceMappingURL=chunk-RFYAYKTD.js.map

package/dist/chunk-RFYAYKTD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-audit-anomaly.ts"],"sourcesContent":["/**\n * Recall-audit anomaly detector (issue #565 PR 5/5).\n *\n * Given a sequence of `RecallAuditEntry` records for a single principal /\n * session, classify the series and emit `AnomalyFlag`s for suspicious\n * patterns. Intended to run on both:\n *\n * 1. The MCP / HTTP access layers — every `recall` / `memory_search` /\n *    `memory_timeline` call appends an audit entry and the detector is\n *    invoked against the tail of the series (streaming mode).\n * 2. The existing Openclaw hook (already writes `transcripts/*.jsonl`) —\n *    the detector can be invoked out-of-band over the same entries.\n *\n * See the threat model §5 (gap: recall-audit was only on the Openclaw\n * hook) and §6.3 (anomaly signals) for the patterns below.\n *\n * The module is pure: no I/O, no clock. Callers pass the entries +\n * configured thresholds; the detector returns a deterministic classification.\n *\n * Patterns detected:\n *\n * - `repeat-query` — the same normalized query text issued more than N\n *   times in the window. Covers the ADAM \"exploitation\" phase where the\n *   attacker re-queries a high-signal token until it plateaus.\n * - `namespace-walk` — the same principal's queries visit more than N\n *   distinct candidate memory namespaces in the window. Suggests the\n *   attacker is enumerating the namespace tree for leaks.\n * - `high-cardinality-return` — a single recall surfaced more than N\n *   candidate memory IDs in one response. Covers the \"one query, dump\n *   everything\" exfiltration path.\n * - `rapid-fire` — more than N recalls in the window irrespective of\n *   content. Blunt instrument; useful when nothing else fires.\n *\n * Each flag carries the entry indices that support it so an audit UI can\n * highlight the underlying evidence.\n */\n\nimport type { RecallAuditEntry } from \"./recall-audit.js\";\n\nexport type AnomalyKind =\n  | \"repeat-query\"\n  | \"namespace-walk\"\n  | \"high-cardinality-return\"\n  | \"rapid-fire\";\n\nexport type AnomalySeverity = \"info\" | \"warn\" | \"alert\";\n\nexport interface AnomalyFlag {\n  kind: AnomalyKind;\n  severity: AnomalySeverity;\n  /** Human-readable rationale, e.g. `\"query 'alex' repeated 12 times in 60s\"`. */\n  message: string;\n  /** Indices into the supplied `entries` array that triggered the flag. */\n  entryIndices: number[];\n  /**\n   * Optional extra signal the caller can use to key metrics. For\n   * `repeat-query` this is the normalized query text; for\n   * `namespace-walk` it is the namespace count; etc.\n   */\n  signal?: string | number;\n}\n\nexport interface AnomalyDetectorConfig {\n  /** Detector feature-flag. Defaults to false — ships disabled. */\n  enabled?: boolean;\n  /**\n   * Rolling window in ms. The detector only considers entries whose `ts`\n   * falls within `[now - windowMs, now]`. Default 5 minutes.\n   */\n  windowMs?: number;\n  /**\n   * Threshold for `repeat-query`: a normalized query repeated more than\n   * this many times in the window trips the flag. Default 5.\n   */\n  repeatQueryLimit?: number;\n  /**\n   * Threshold for `namespace-walk`: more than this many distinct\n   * candidate namespaces in the window trips the flag. Default 3.\n   */\n  namespaceWalkLimit?: number;\n  /**\n   * Threshold for `high-cardinality-return`: more than this many\n   * `candidateMemoryIds` in a single entry trips the flag. Default 50.\n   */\n  highCardinalityReturnLimit?: number;\n  /**\n   * Threshold for `rapid-fire`: more than this many entries in the\n   * window trips the flag. Default 30. (Matches the default\n   * `recallCrossNamespaceBudgetHardLimit` from PR 4.)\n   */\n  rapidFireLimit?: number;\n}\n\nexport const DEFAULT_ANOMALY_DETECTOR_CONFIG: Required<AnomalyDetectorConfig> =\n  Object.freeze({\n    enabled: false,\n    windowMs: 5 * 60_000,\n    repeatQueryLimit: 5,\n    namespaceWalkLimit: 3,\n    highCardinalityReturnLimit: 50,\n    rapidFireLimit: 30,\n  });\n\nexport interface AnomalyDetectorInput {\n  entries: readonly RecallAuditEntry[];\n  /** Current time in epoch ms. Entries older than `now - windowMs` are ignored. */\n  now: number;\n  config?: AnomalyDetectorConfig;\n}\n\nexport interface AnomalyDetectorResult {\n  /** All flags ordered by descending severity then kind. */\n  flags: AnomalyFlag[];\n  /** Number of entries inside the active window (after filtering). */\n  windowEntryCount: number;\n  /** Window size actually used, in ms. */\n  windowMs: number;\n}\n\nfunction effectiveConfig(\n  raw: AnomalyDetectorConfig | undefined,\n): Required<AnomalyDetectorConfig> {\n  const base = { ...DEFAULT_ANOMALY_DETECTOR_CONFIG };\n  if (!raw) return base;\n  const out = { ...base };\n  if (typeof raw.enabled === \"boolean\") out.enabled = raw.enabled;\n  if (\n    typeof raw.windowMs === \"number\" &&\n    Number.isFinite(raw.windowMs) &&\n    raw.windowMs > 0\n  ) {\n    out.windowMs = raw.windowMs;\n  }\n  for (const key of [\n    \"repeatQueryLimit\",\n    \"namespaceWalkLimit\",\n    \"highCardinalityReturnLimit\",\n    \"rapidFireLimit\",\n  ] as const) {\n    const v = raw[key];\n    if (typeof v === \"number\" && Number.isFinite(v) && v > 0) {\n      const floored = Math.floor(v);\n      // Guard against fractional inputs (e.g. 0.5) that floor to 0 and\n      // turn every detector into a flood-on-anything trigger.\n      out[key] = floored >= 1 ? floored : base[key];\n    }\n  }\n  return out;\n}\n\n/**\n * Normalize query text so cosmetic variation doesn't defeat the\n * repeat-query detector. Lowercase, collapse whitespace, trim.\n */\nexport function normalizeQueryText(raw: string): string {\n  if (typeof raw !== \"string\") return \"\";\n  return raw.toLowerCase().replace(/\\s+/g, \" \").trim();\n}\n\nconst SEVERITY_ORDER: Record<AnomalySeverity, number> = {\n  alert: 0,\n  warn: 1,\n  info: 2,\n};\n\nfunction parseTsMs(ts: string): number | null {\n  const n = new Date(ts).getTime();\n  return Number.isFinite(n) ? n : null;\n}\n\n/**\n * Run the detector against a series of audit entries. Pure; no side\n * effects.\n */\nexport function detectRecallAnomalies(\n  input: AnomalyDetectorInput,\n): AnomalyDetectorResult {\n  const cfg = effectiveConfig(input.config);\n  const cutoff = input.now - cfg.windowMs;\n\n  // Filter to the active window, preserving original indices so flags\n  // can reference the caller's entries array directly.\n  const windowed: { entry: RecallAuditEntry; index: number }[] = [];\n  for (let i = 0; i < input.entries.length; i++) {\n    const entry = input.entries[i]!;\n    const tsMs = parseTsMs(entry.ts);\n    if (tsMs === null) continue;\n    if (tsMs >= cutoff && tsMs <= input.now) {\n      windowed.push({ entry, index: i });\n    }\n  }\n\n  if (!cfg.enabled) {\n    return { flags: [], windowEntryCount: windowed.length, windowMs: cfg.windowMs };\n  }\n\n  const flags: AnomalyFlag[] = [];\n\n  // 1) repeat-query: bucket by normalized queryText.\n  {\n    const byQuery = new Map<string, number[]>();\n    for (const { entry, index } of windowed) {\n      const key = normalizeQueryText(entry.queryText);\n      if (key.length === 0) continue;\n      const arr = byQuery.get(key);\n      if (arr) arr.push(index);\n      else byQuery.set(key, [index]);\n    }\n    for (const [query, indices] of byQuery) {\n      if (indices.length > cfg.repeatQueryLimit) {\n        flags.push({\n          kind: \"repeat-query\",\n          severity: \"warn\",\n          message: `query \"${query}\" repeated ${indices.length} times in ${cfg.windowMs}ms`,\n          entryIndices: indices.slice(),\n          signal: query,\n        });\n      }\n    }\n  }\n\n  // 2) namespace-walk: distinct namespaces extracted from candidateMemoryIds.\n  //    Candidate IDs that begin with `<namespace>/` disclose the namespace\n  //    directly. IDs without a slash prefix (e.g. bare filenames) do not\n  //    disclose a namespace, but a recall whose result list mixes\n  //    prefixed AND unprefixed IDs is itself suspicious — it suggests\n  //    the backend leaked memories from both the caller's own namespace\n  //    and named tenants. We track unprefixed IDs under a reserved\n  //    sentinel namespace so they still contribute to the count when a\n  //    trail is all-unprefixed (common for older audit entries sourced\n  //    from filenames).\n  {\n    const namespaces = new Set<string>();\n    const indices: number[] = [];\n    for (const { entry, index } of windowed) {\n      if (!Array.isArray(entry.candidateMemoryIds)) continue;\n      let touchedAny = false;\n      for (const id of entry.candidateMemoryIds) {\n        if (typeof id !== \"string\" || id.length === 0) continue;\n        const slash = id.indexOf(\"/\");\n        if (slash > 0) {\n          namespaces.add(id.slice(0, slash));\n        } else {\n          namespaces.add(\"__unprefixed__\");\n        }\n        touchedAny = true;\n      }\n      if (touchedAny) indices.push(index);\n    }\n    if (namespaces.size > cfg.namespaceWalkLimit) {\n      flags.push({\n        kind: \"namespace-walk\",\n        severity: \"alert\",\n        message: `queries touched ${namespaces.size} distinct namespaces in ${cfg.windowMs}ms`,\n        entryIndices: indices,\n        signal: namespaces.size,\n      });\n    }\n  }\n\n  // 3) high-cardinality-return: one entry's candidateMemoryIds > limit.\n  {\n    for (const { entry, index } of windowed) {\n      const ids = Array.isArray(entry.candidateMemoryIds)\n        ? entry.candidateMemoryIds\n        : [];\n      if (ids.length > cfg.highCardinalityReturnLimit) {\n        flags.push({\n          kind: \"high-cardinality-return\",\n          severity: \"alert\",\n          message: `single recall returned ${ids.length} candidate memory IDs`,\n          entryIndices: [index],\n          signal: ids.length,\n        });\n      }\n    }\n  }\n\n  // 4) rapid-fire: windowed count alone.\n  if (windowed.length > cfg.rapidFireLimit) {\n    flags.push({\n      kind: \"rapid-fire\",\n      severity: \"warn\",\n      message: `${windowed.length} recall entries in ${cfg.windowMs}ms`,\n      entryIndices: windowed.map((w) => w.index),\n      signal: windowed.length,\n    });\n  }\n\n  flags.sort((a, b) => {\n    const s = SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];\n    if (s !== 0) return s;\n    return a.kind.localeCompare(b.kind);\n  });\n\n  return { flags, windowEntryCount: windowed.length, windowMs: cfg.windowMs };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-DHHP2Z4X.js → chunk-RGLL5SPU.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-GV6NLQ4X.js";
+} from "./chunk-F5VP6YCB.js";
 import {
   parseContinuityImprovementLoops,
   parseContinuityIncident
@@ -1860,4 +1860,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-DHHP2Z4X.js.map
+//# sourceMappingURL=chunk-RGLL5SPU.js.map

package/dist/{chunk-3SV6CQHO.js → chunk-S3EEFKNY.js}

@@ -6,7 +6,10 @@ import {
   ProactiveExtractionResultSchema,
   ProactiveQuestionsResultSchema,
   buildProfileConsolidationResultSchema
-} from "./chunk-UEYA6UC7.js";
+} from "./chunk-NZLQTHS5.js";
+import {
+  normalizeReasoningTrace
+} from "./chunk-54V4BZWP.js";
 import {
   ProfilingCollector
 } from "./chunk-NBNN5GOB.js";
@@ -16,17 +19,17 @@ import {
 import {
   LocalLlmClient
 } from "./chunk-JL2PU6AI.js";
+import {
+  delinearize
+} from "./chunk-VEWZZM3H.js";
 import {
   buildExtensionsFooterForSummary,
   formatDaySummaryMemories,
   loadDaySummaryPrompt
 } from "./chunk-GZCUW5IC.js";
-import {
-  delinearize
-} from "./chunk-VEWZZM3H.js";
 import {
   FallbackLlmClient
-} from "./chunk-44ICJRF3.js";
+} from "./chunk-3GXCSUXR.js";
 import {
   buildChatCompletionTokenLimit,
   shouldAssumeOpenAiChatCompletions
@@ -50,6 +53,22 @@ import {
 // src/extraction.ts
 import OpenAI from "openai";
 var PROACTIVE_MIN_CONFIDENCE = 0.8;
+var CONSOLIDATION_RESPONSE_SCHEMA = `{
+  "items": [
+    {
+      "existingId": "id",
+      "action": "ADD",
+      "mergeWith": "optional-existing-id",
+      "updatedContent": "optional replacement content",
+      "reason": "brief reason for this action"
+    }
+  ],
+  "profileUpdates": ["optional profile update"],
+  "entityUpdates": [{"name": "person-jane-doe", "type": "person", "facts": ["Now leads the backend team", "Recently migrated the user service to TypeScript"]}]
+}`;
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function normalizeQuestion(question) {
   const priority = Number.isFinite(question.priority) ? Math.max(0, Math.min(1, question.priority)) : 0.5;
   return {
@@ -168,7 +187,11 @@ var ExtractionEngine = class {
       structuredAttributes: f?.structuredAttributes && typeof f.structuredAttributes === "object" && !Array.isArray(f.structuredAttributes) ? Object.fromEntries(
         Object.entries(f.structuredAttributes).filter(([k, v]) => typeof k === "string" && typeof v === "string")
       ) : void 0,
-      procedureSteps: Array.isArray(f?.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0
+      procedureSteps: Array.isArray(f?.procedureSteps) ? normalizeProcedureSteps(f.procedureSteps) : void 0,
+      reasoningTrace: (() => {
+        const candidate = f?.reasoningTrace && typeof f.reasoningTrace === "object" && !Array.isArray(f.reasoningTrace) ? f.reasoningTrace : f?.reasoning_trace && typeof f.reasoning_trace === "object" && !Array.isArray(f.reasoning_trace) ? f.reasoning_trace : null;
+        return candidate ? normalizeReasoningTrace(candidate) ?? void 0 : void 0;
+      })()
     })).filter((f) => f.content.length > 0) : [];
     const questions = Array.isArray(parsed?.questions) ? parsed.questions.map((q) => {
       if (typeof q === "string") return { question: q, context: "", priority: 0.5 };
@@ -195,16 +218,32 @@ var ExtractionEngine = class {
     };
   }
   normalizeEntityUpdate(entity) {
+    const rawUpdates = isPlainRecord(entity?.updates) ? entity.updates : null;
+    const directFacts = Array.isArray(entity?.facts) ? entity.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : [];
+    const updateFacts = rawUpdates && Array.isArray(rawUpdates.facts) ? rawUpdates.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : [];
+    const scalarUpdateFacts = rawUpdates ? Object.keys(rawUpdates).sort((a, b) => a.localeCompare(b)).filter((key) => !["facts", "name", "promptedByQuestion", "structuredSections", "type"].includes(key)).flatMap((key) => {
+      const value = rawUpdates[key];
+      if (typeof value === "string" && value.trim().length > 0) {
+        return [`${key}: ${value.trim()}`];
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return [`${key}: ${String(value)}`];
+      }
+      return [];
+    }) : [];
+    const structuredSectionsSource = Array.isArray(entity?.structuredSections) ? entity.structuredSections : Array.isArray(rawUpdates?.structuredSections) ? rawUpdates.structuredSections : [];
+    const name = typeof entity?.name === "string" ? entity.name.trim() : typeof entity?.entityId === "string" ? entity.entityId.trim() : typeof rawUpdates?.name === "string" ? rawUpdates.name.trim() : "";
+    const type = typeof entity?.type === "string" && entity.type.trim().length > 0 ? entity.type.trim() : typeof rawUpdates?.type === "string" && rawUpdates.type.trim().length > 0 ? rawUpdates.type.trim() : "other";
     return {
-      name: typeof entity?.name === "string" ? entity.name : "",
-      type: typeof entity?.type === "string" ? entity.type : "other",
-      facts: Array.isArray(entity?.facts) ? entity.facts.filter((fact) => typeof fact === "string") : [],
-      structuredSections: Array.isArray(entity?.structuredSections) ? entity.structuredSections.map((section) => ({
+      name,
+      type,
+      facts: [...directFacts, ...updateFacts, ...scalarUpdateFacts],
+      structuredSections: structuredSectionsSource.length > 0 ? structuredSectionsSource.map((section) => ({
         key: typeof section?.key === "string" ? section.key.trim() : "",
         title: typeof section?.title === "string" ? section.title.trim() : "",
         facts: Array.isArray(section?.facts) ? section.facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0) : []
       })).filter((section) => section.key.length > 0 && section.title.length > 0 && section.facts.length > 0) : void 0,
-      promptedByQuestion: typeof entity?.promptedByQuestion === "string" ? entity.promptedByQuestion : void 0
+      promptedByQuestion: typeof entity?.promptedByQuestion === "string" ? entity.promptedByQuestion : typeof rawUpdates?.promptedByQuestion === "string" ? rawUpdates.promptedByQuestion : void 0
     };
   }
   parseJsonObject(content) {
@@ -264,15 +303,36 @@ var ExtractionEngine = class {
     return normalized.summary.length > 0 ? normalized : null;
   }
   sanitizeConsolidationResult(result) {
-    const items = result.items.map((item) => {
-      if (!item.updatedContent) return item;
-      const sanitized = sanitizeMemoryContent(item.updatedContent);
+    const items = [];
+    for (const item of Array.isArray(result.items) ? result.items : []) {
+      const rawAction = typeof item?.action === "string" ? item.action.toUpperCase() : "SKIP";
+      const action = rawAction === "ADD" || rawAction === "MERGE" || rawAction === "UPDATE" || rawAction === "INVALIDATE" || rawAction === "SKIP" ? rawAction : "SKIP";
+      const existingId = typeof item?.existingId === "string" ? item.existingId.trim() : typeof item?.newMemoryId === "string" ? item.newMemoryId.trim() : typeof item?.memoryId === "string" ? item.memoryId.trim() : "";
+      if (!existingId) continue;
+      const mergeWith = typeof item?.mergeWith === "string" ? item.mergeWith : void 0;
+      const reason = typeof item?.reason === "string" ? item.reason : "";
+      const rawUpdatedContent = typeof item?.updatedContent === "string" ? item.updatedContent : void 0;
+      if (!rawUpdatedContent) {
+        items.push({ existingId, action, mergeWith, updatedContent: void 0, reason });
+        continue;
+      }
+      const sanitized = sanitizeMemoryContent(rawUpdatedContent);
       if (!sanitized.clean) {
-        log.warn(`consolidation item sanitized (${item.existingId}); violations=${sanitized.violations.join(", ")}`);
+        log.warn(`consolidation item sanitized (${existingId}); violations=${sanitized.violations.join(", ")}`);
       }
-      return { ...item, updatedContent: sanitized.text };
-    });
-    return { ...result, items };
+      items.push({
+        existingId,
+        action,
+        mergeWith,
+        updatedContent: sanitized.text,
+        reason
+      });
+    }
+    const profileUpdates = (Array.isArray(result.profileUpdates) ? result.profileUpdates : []).map(
+      (update) => typeof update === "string" ? update.trim() : typeof update?.content === "string" ? update.content.trim() : ""
+    ).filter((update) => update.length > 0);
+    const entityUpdates = (Array.isArray(result.entityUpdates) ? result.entityUpdates : []).map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity.name.length > 0);
+    return { items, profileUpdates, entityUpdates };
   }
   async applyProactiveQuestionPass(conversation, base) {
     if (!this.config.proactiveExtractionEnabled) return base;
@@ -762,8 +822,16 @@ var ExtractionEngine = class {
           log.debug(
             `extracted ${result.facts.length} facts, ${result.entities.length} entities, ${(result.questions ?? []).length} questions via fallback (${detailed.modelUsed})`
           );
+          const normalizedFacts = result.facts.map((f) => {
+            if (!f?.reasoningTrace) return f;
+            return {
+              ...f,
+              reasoningTrace: normalizeReasoningTrace(f.reasoningTrace) ?? void 0
+            };
+          });
           const sanitized = this.sanitizeExtractionResult({
             ...result,
+            facts: normalizedFacts,
             questions: result.questions ?? [],
             identityReflection: result.identityReflection ?? void 0
           }, messageTimestamp);
@@ -831,6 +899,7 @@ Memory categories \u2014 use the MOST SPECIFIC category that fits:
 - skill: Demonstrated capabilities
 - rule: Explicit operational rules or constraints
 - procedure: Repeatable workflows \u2014 use when the user describes a multi-step play (\u22652 ordered steps). Put the human-readable trigger/context in "content" (e.g. "When you deploy\u2026") and list steps in "procedureSteps" as [{"order":1,"intent":"\u2026"}, \u2026] mirroring the gateway extraction schema.
+- reasoning_trace: Stored solution chains \u2014 use when the user narrates HOW they solved a specific problem step-by-step ("here's how I figured out\u2026", "the debugging went like this\u2026"). Put a short title in "content" (e.g. "How I debugged the staging latency spike") and the chain in "reasoningTrace": {"steps":[{"order":1,"description":"\u2026"}, \u2026], "finalAnswer":"\u2026", "observedOutcome":"\u2026" (optional)}. Require \u22652 ordered steps and a finalAnswer. Do NOT use for ordinary decisions (prefer "decision") or reusable workflows (prefer "procedure").
 
 IMPORTANT: Do NOT label everything as "fact". Use "decision" for architectural choices, "commitment" for deadlines/promises, "principle" for reusable rules, "correction" for when the user rejects a suggestion, etc.
 
@@ -892,7 +961,7 @@ Also generate:
 
 Output JSON:
 {
-  "facts": [{"category": "decision", "content": "Chose PostgreSQL over MongoDB for the user service", "importance": 8, "confidence": 0.9, "structuredAttributes": {"chosen": "PostgreSQL", "rejected": "MongoDB"}}, {"category": "procedure", "content": "When you cut a hotfix release, follow the checklist", "importance": 8, "confidence": 0.9, "procedureSteps": [{"order": 1, "intent": "Branch from main and cherry-pick the fix"}, {"order": 2, "intent": "Run CI and tag the release"}]}, {"category": "commitment", "content": "Must ship v2.0 API by end of March", "importance": 10, "confidence": 1.0, "structuredAttributes": {"deadline": "end of March", "deliverable": "v2.0 API"}}, {"category": "fact", "content": "The store backend uses Redis for session caching", "importance": 6, "confidence": 0.95, "entityRef": "project-acme-store"}, {"category": "principle", "content": "Always run migrations in a transaction to avoid partial schema updates", "importance": 8, "confidence": 0.9}],
+  "facts": [{"category": "decision", "content": "Chose PostgreSQL over MongoDB for the user service", "importance": 8, "confidence": 0.9, "structuredAttributes": {"chosen": "PostgreSQL", "rejected": "MongoDB"}}, {"category": "procedure", "content": "When you cut a hotfix release, follow the checklist", "importance": 8, "confidence": 0.9, "procedureSteps": [{"order": 1, "intent": "Branch from main and cherry-pick the fix"}, {"order": 2, "intent": "Run CI and tag the release"}]}, {"category": "reasoning_trace", "content": "How I debugged the staging latency spike", "importance": 7, "confidence": 0.9, "reasoningTrace": {"steps": [{"order": 1, "description": "Checked CPU/memory dashboards \u2014 both were flat"}, {"order": 2, "description": "Ran a traceroute and saw retries against the cache tier"}, {"order": 3, "description": "Tailed cache-tier logs and spotted eviction storms"}], "finalAnswer": "Root cause was an undersized eviction policy on the session cache", "observedOutcome": "Increased cache size, p95 returned to baseline within 10 minutes"}}, {"category": "commitment", "content": "Must ship v2.0 API by end of March", "importance": 10, "confidence": 1.0, "structuredAttributes": {"deadline": "end of March", "deliverable": "v2.0 API"}}, {"category": "fact", "content": "The store backend uses Redis for session caching", "importance": 6, "confidence": 0.95, "entityRef": "project-acme-store"}, {"category": "principle", "content": "Always run migrations in a transaction to avoid partial schema updates", "importance": 8, "confidence": 0.9}],
   "entities": [{"name": "person-jane-doe", "type": "person", "facts": ["Works at Acme Corp", "Prefers Python over JavaScript"], "structuredSections": [{"key": "beliefs", "title": "Beliefs", "facts": ["Python is a better fit than JavaScript for backend work."]}]}, {"name": "project-acme-store", "type": "project", "facts": ["Built with Next.js", "Deployed on Vercel"]}],
   "profileUpdates": ["User prefers dark mode in all editors"],
   "questions": [{"question": "Which cloud provider hosts the staging environment?", "context": "Came up during deployment discussion", "priority": 0.5}],
@@ -969,7 +1038,7 @@ ${truncatedConversation}`;
 
 Respond with valid JSON matching this schema:
 {
-  "facts": [{"category": "decision", "content": "Chose React over Vue for the dashboard rewrite", "importance": 8, "confidence": 0.9, "tags": ["frontend"], "structuredAttributes": {"chosen": "React", "rejected": "Vue"}}, {"category": "fact", "content": "The API gateway uses rate limiting at 1000 req/min", "importance": 6, "confidence": 0.95, "tags": ["infra"], "entityRef": "project-dashboard", "structuredAttributes": {"rate_limit": "1000 req/min"}}],
+  "facts": [{"category": "decision", "content": "Chose React over Vue for the dashboard rewrite", "importance": 8, "confidence": 0.9, "tags": ["frontend"], "structuredAttributes": {"chosen": "React", "rejected": "Vue"}}, {"category": "fact", "content": "The API gateway uses rate limiting at 1000 req/min", "importance": 6, "confidence": 0.95, "tags": ["infra"], "entityRef": "project-dashboard", "structuredAttributes": {"rate_limit": "1000 req/min"}}, {"category": "reasoning_trace", "content": "How I chose the dashboard rewrite framework", "confidence": 0.9, "tags": ["frontend"], "reasoningTrace": {"steps": [{"order": 1, "description": "Listed constraints: SSR needed, team mostly JS"}, {"order": 2, "description": "Ran a spike in Vue 3 \u2014 worked, but ecosystem felt thin for our needs"}, {"order": 3, "description": "Ran the same spike in React \u2014 integrated faster with Next.js"}], "finalAnswer": "Picked React with Next.js for SSR + ecosystem fit"}}],
   "entities": [{"name": "person-sarah-chen", "type": "person", "facts": ["Leads the backend team", "Joined from Google in 2024"], "structuredSections": [{"key": "beliefs", "title": "Beliefs", "facts": ["Small teams should own whole systems."]}]}, {"name": "project-dashboard", "type": "project", "facts": ["React-based admin panel", "Deployed on AWS ECS"]}],
   "profileUpdates": ["User prefers TypeScript over plain JavaScript"],
   "questions": [{"question": "What database does the analytics service use?", "context": "Came up during discussion of migration plan", "priority": 0.5}],
@@ -1015,7 +1084,8 @@ Respond with valid JSON matching this schema:
       "moment",
       "skill",
       "rule",
-      "procedure"
+      "procedure",
+      "reasoning_trace"
     ]);
     const allowedEntityTypes = /* @__PURE__ */ new Set([
       "person",
@@ -1073,6 +1143,7 @@ Memory categories:
 - skill: Capabilities the user or agent has demonstrated (e.g., "user is proficient with Kubernetes")${this.config.causalRuleExtractionEnabled ? `
 - rule: Causal rules discovered through experience (format: "IF <condition> THEN <action/outcome>", e.g., "IF Shopify API returns 401 THEN the admin token is missing read_products scope")` : ""}
 - procedure: A reusable workflow the user wants remembered the same way across sessions. Set category to "procedure". Use "content" for a short title that includes explicit trigger phrasing (e.g. "When you deploy to production\u2026", "Whenever you ship a release\u2026"). Add "procedureSteps": an array of at least two objects {"order": number, "intent": "concrete step description"} in execution order. Optional per-step "toolCall": {"kind": "\u2026", "signature": "\u2026"}, "expectedOutcome", "optional": true.
+- reasoning_trace: A stored solution chain / chain-of-thought the user walked through to solve a problem (e.g. "Here's how I debugged the latency spike: first I checked\u2026, then I\u2026, finally I\u2026"). Set category to "reasoning_trace". Use "content" for a short title summarising the problem (e.g. "How I debugged the staging latency spike"). Add "reasoningTrace": {"steps": [{"order": number, "description": "what happened at this step"}, \u2026], "finalAnswer": "the conclusion or answer", "observedOutcome": "optional confirmation of how it played out"}. Require at least two ordered steps AND a finalAnswer. Use this category only when the user explicitly narrates their reasoning \u2014 not for ordinary decisions (use "decision") or reusable workflows (use "procedure").
 
 Rules:
 - Only extract genuinely NEW information worth remembering across sessions
@@ -1193,15 +1264,10 @@ Consolidate the new memories against existing ones.`
     );
     if (fallbackResult) {
       log.debug(`consolidation: ${fallbackResult.items.length} decisions via fallback`);
-      const normalizedEntityUpdates = fallbackResult.entityUpdates.map((entity) => this.normalizeEntityUpdate(entity));
       return this.sanitizeConsolidationResult({
-        items: fallbackResult.items.map((item) => ({
-          ...item,
-          mergeWith: item.mergeWith ?? void 0,
-          updatedContent: item.updatedContent ?? void 0
-        })),
+        items: fallbackResult.items,
         profileUpdates: fallbackResult.profileUpdates,
-        entityUpdates: normalizedEntityUpdates
+        entityUpdates: fallbackResult.entityUpdates
       });
     }
     if (!this.client) {
@@ -1233,19 +1299,7 @@ New memories to consolidate:
 ${newList}
 
 Respond with valid JSON only, matching this schema:
-{
-  "items": [
-    {
-      "existingId": "id",
-      "action": "ADD",
-      "mergeWith": "optional-existing-id",
-      "updatedContent": "optional replacement content",
-      "reason": "brief reason for this action"
-    }
-  ],
-  "profileUpdates": ["optional profile update"],
-  "entityUpdates": [{"name": "person-jane-doe", "type": "person", "facts": ["Now leads the backend team", "Recently migrated the user service to TypeScript"]}]
-}`;
+${CONSOLIDATION_RESPONSE_SCHEMA}`;
       const response = await this.client.chat.completions.create({
         model: this.config.model,
         messages: [
@@ -1280,25 +1334,13 @@ Respond with valid JSON only, matching this schema:
         tokenUsage: cUsage ? { input: cUsage.prompt_tokens, output: cUsage.completion_tokens, total: cUsage.total_tokens } : void 0
       });
       if (parsed && Array.isArray(parsed.items)) {
-        const normalizedItems = parsed.items.map((item) => {
-          const rawAction = typeof item?.action === "string" ? item.action.toUpperCase() : "SKIP";
-          const action = rawAction === "ADD" || rawAction === "MERGE" || rawAction === "UPDATE" || rawAction === "INVALIDATE" || rawAction === "SKIP" ? rawAction : "SKIP";
-          return {
-            existingId: typeof item?.existingId === "string" ? item.existingId : typeof item?.newMemoryId === "string" ? item.newMemoryId : "",
-            action,
-            mergeWith: typeof item?.mergeWith === "string" ? item.mergeWith : void 0,
-            updatedContent: typeof item?.updatedContent === "string" ? item.updatedContent : void 0,
-            reason: typeof item?.reason === "string" ? item.reason : ""
-          };
-        }).filter((item) => item.existingId.length > 0);
-        const normalizedEntityUpdates = Array.isArray(parsed.entityUpdates) ? parsed.entityUpdates.map((entity) => this.normalizeEntityUpdate(entity)).filter((entity) => entity.name.length > 0) : [];
         log.debug(
-          `consolidation: ${normalizedItems.length} decisions`
+          `consolidation: ${parsed.items.length} decisions`
         );
         return this.sanitizeConsolidationResult({
-          items: normalizedItems,
-          profileUpdates: Array.isArray(parsed.profileUpdates) ? parsed.profileUpdates.filter((update) => typeof update === "string" && update.trim().length > 0) : [],
-          entityUpdates: normalizedEntityUpdates
+          items: parsed.items,
+          profileUpdates: Array.isArray(parsed.profileUpdates) ? parsed.profileUpdates : [],
+          entityUpdates: Array.isArray(parsed.entityUpdates) ? parsed.entityUpdates : []
         });
       }
       log.warn("consolidation returned no parsed output");
@@ -1349,13 +1391,7 @@ New memories to consolidate:
 ${newList}
 
 Respond with valid JSON matching this schema:
-{
-  "items": [
-    {"memoryId": "id", "action": "ADD|MERGE|UPDATE|INVALIDATE|SKIP", "reason": "why", "updatedContent": "optional new content"}
-  ],
-  "profileUpdates": [{"section": "section name", "content": "new bullet"}],
-  "entityUpdates": [{"entityId": "id", "updates": {"field": "value"}}]
-}`;
+${CONSOLIDATION_RESPONSE_SCHEMA}`;
     const response = await this.localLlm.chatCompletion(
       [
         { role: "system", content: "You are a memory consolidation system. Output valid JSON only." },
@@ -2224,4 +2260,4 @@ ${memoryList}` }
 export {
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-3SV6CQHO.js.map
+//# sourceMappingURL=chunk-S3EEFKNY.js.map