@remnic/core 9.65.0 → 9.65.2

package/dist/chunk-3WU7XOFN.js

@@ -0,0 +1,102 @@
+// src/cross-lingual-recall.ts
+var SCRIPT_RANGES = [
+  ["latn", 65, 90],
+  ["latn", 97, 122],
+  ["latn", 192, 591],
+  ["grek", 880, 1023],
+  ["cyrl", 1024, 1279],
+  ["cyrl", 1280, 1327],
+  ["hebr", 1424, 1535],
+  ["arab", 1536, 1791],
+  ["arab", 1872, 1919],
+  ["deva", 2304, 2431],
+  ["thai", 3584, 3711],
+  ["kore", 4352, 4607],
+  ["latn", 7680, 7935],
+  ["kana", 12352, 12447],
+  ["kana", 12448, 12543],
+  ["kana", 12784, 12799],
+  ["hani", 13312, 19903],
+  ["hani", 19968, 40959],
+  ["kore", 44032, 55203],
+  ["kana", 65382, 65437]
+];
+function detectLanguageHint(text) {
+  const counts = /* @__PURE__ */ new Map();
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    for (const [script, low, high] of SCRIPT_RANGES) {
+      if (code < low) break;
+      if (code <= high) {
+        counts.set(script, (counts.get(script) ?? 0) + 1);
+        break;
+      }
+    }
+  }
+  if (counts.has("kana")) return "jpan";
+  let best;
+  let bestCount = 0;
+  for (const [script, count] of counts) {
+    if (script === "kana") continue;
+    if (count > bestCount) {
+      best = script;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function corpusDominantLanguage(hints) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const hint of hints) {
+    if (hint === void 0 || hint === "") continue;
+    counts.set(hint, (counts.get(hint) ?? 0) + 1);
+  }
+  let best;
+  let bestCount = 0;
+  for (const [hint, count] of counts) {
+    if (count > bestCount) {
+      best = hint;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function planCrossScript(input) {
+  const crossScript = input.queryLanguage !== void 0 && input.corpusLanguage !== void 0 && input.queryLanguage !== input.corpusLanguage;
+  return {
+    queryLanguage: input.queryLanguage,
+    corpusLanguage: input.corpusLanguage,
+    crossScript,
+    degradation: crossScript && !input.vectorTierAvailable ? {
+      backend: "qmd",
+      code: "vector_tier_unavailable",
+      detail: `cross-script query (${input.queryLanguage}) over a ${input.corpusLanguage} corpus: lexical recall cannot match across scripts \u2014 enable a multilingual embedding model (embedding fallback) so the vector tier can serve it`
+    } : void 0
+  };
+}
+var CORPUS_SAMPLE_CAP = 500;
+var corpusLanguageCache = /* @__PURE__ */ new Map();
+async function dominantCorpusLanguage(storage) {
+  try {
+    const version = storage.getCorpusScanVersion();
+    const cached = corpusLanguageCache.get(storage.dir);
+    if (cached?.version === version) return cached.language;
+    const memories = await storage.readAllMemories();
+    const language = corpusDominantLanguage(
+      memories.slice(0, CORPUS_SAMPLE_CAP).map((memory) => memory.frontmatter.language)
+    );
+    if (corpusLanguageCache.size > 8) corpusLanguageCache.clear();
+    corpusLanguageCache.set(storage.dir, { version, language });
+    return language;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  detectLanguageHint,
+  corpusDominantLanguage,
+  planCrossScript,
+  dominantCorpusLanguage
+};
+//# sourceMappingURL=chunk-3WU7XOFN.js.map

package/dist/chunk-3WU7XOFN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cross-lingual-recall.ts"],"sourcesContent":["/**\n * Cross-lingual recall planner (issue #2197).\n *\n * Lexical tiers (BM25/FTS) match on shared surface tokens, so a query whose\n * dominant script differs from the corpus's cannot retrieve lexically — an\n * English query never token-overlaps a Japanese fact. When the planner\n * detects that mismatch it leans on the vector tier (the embedding-fallback\n * supplement in the recall search pipeline), and when NO vector tier exists\n * it emits a {@link SearchDegradation} so \"no results\" stays distinguishable\n * from \"cross-script query, vectors unavailable\" (rule 34).\n *\n * The write-time half is a dominant-script hint stamped into frontmatter\n * `language` by `StorageManager.writeMemory` (ISO 15924 script codes);\n * legacy files without the field simply do not vote for the corpus script.\n */\n\nimport type { MemoryFile } from \"./types.js\";\nimport type { SearchDegradation } from \"./search/port.js\";\n\ntype CorpusLanguageStorage = {\n  dir: string;\n  readAllMemories: () => Promise<MemoryFile[]>;\n  getCorpusScanVersion: () => string;\n};\n\n/** Script classes the cheap detector can distinguish. ISO 15924 codes. */\nexport type LanguageHint =\n  | \"latn\"\n  | \"jpan\"\n  | \"kore\"\n  | \"hani\"\n  | \"cyrl\"\n  | \"grek\"\n  | \"arab\"\n  | \"hebr\"\n  | \"thai\"\n  | \"deva\";\n\n/** Inclusive codepoint ranges per script class. `kana` folds into `jpan` at detection. */\nconst SCRIPT_RANGES: ReadonlyArray<readonly [LanguageHint | \"kana\", number, number]> = [\n  [\"latn\", 0x41, 0x5a],\n  [\"latn\", 0x61, 0x7a],\n  [\"latn\", 0xc0, 0x24f],\n  [\"grek\", 0x370, 0x3ff],\n  [\"cyrl\", 0x400, 0x4ff],\n  [\"cyrl\", 0x500, 0x52f],\n  [\"hebr\", 0x590, 0x5ff],\n  [\"arab\", 0x600, 0x6ff],\n  [\"arab\", 0x750, 0x77f],\n  [\"deva\", 0x900, 0x97f],\n  [\"thai\", 0xe00, 0xe7f],\n  [\"kore\", 0x1100, 0x11ff],\n  [\"latn\", 0x1e00, 0x1eff],\n  [\"kana\", 0x3040, 0x309f],\n  [\"kana\", 0x30a0, 0x30ff],\n  [\"kana\", 0x31f0, 0x31ff],\n  [\"hani\", 0x3400, 0x4dbf],\n  [\"hani\", 0x4e00, 0x9fff],\n  [\"kore\", 0xac00, 0xd7a3],\n  [\"kana\", 0xff66, 0xff9d],\n];\n\n/**\n * Dominant-script hint for a text. Codepoint-range counting (no regex):\n * kana anywhere maps to `jpan` — kana is unique to Japanese and disambiguates\n * it from `hani` (Chinese, or kanji-only Japanese). Returns `undefined` when\n * the text contains no lettered script class.\n */\nexport function detectLanguageHint(text: string): LanguageHint | undefined {\n  const counts = new Map<LanguageHint | \"kana\", number>();\n  for (let i = 0; i < text.length; i += 1) {\n    const code = text.charCodeAt(i);\n    for (const [script, low, high] of SCRIPT_RANGES) {\n      if (code < low) break;\n      if (code <= high) {\n        counts.set(script, (counts.get(script) ?? 0) + 1);\n        break;\n      }\n    }\n  }\n  // SCRIPT_RANGES is sorted by start codepoint, so `break` on the first\n  // range starting past the codepoint is exact — one range test per char.\n  if (counts.has(\"kana\")) return \"jpan\";\n  let best: LanguageHint | undefined;\n  let bestCount = 0;\n  for (const [script, count] of counts) {\n    if (script === \"kana\") continue;\n    if (count > bestCount) {\n      best = script;\n      bestCount = count;\n    }\n  }\n  return best;\n}\n\n/** Dominant hint over a corpus sample; `undefined` entries (legacy files) never vote. */\nexport function corpusDominantLanguage(\n  hints: Iterable<string | undefined>,\n): LanguageHint | undefined {\n  const counts = new Map<string, number>();\n  for (const hint of hints) {\n    if (hint === undefined || hint === \"\") continue;\n    counts.set(hint, (counts.get(hint) ?? 0) + 1);\n  }\n  let best: string | undefined;\n  let bestCount = 0;\n  for (const [hint, count] of counts) {\n    if (count > bestCount) {\n      best = hint;\n      bestCount = count;\n    }\n  }\n  return best as LanguageHint | undefined;\n}\n\n/** Planner decision for one recall query. */\nexport interface CrossScriptPlan {\n  queryLanguage: LanguageHint | undefined;\n  corpusLanguage: LanguageHint | undefined;\n  /** True when both hints resolved and differ — lexical tiers cannot serve this query. */\n  crossScript: boolean;\n  /** Emitted when `crossScript` is true and no vector tier can compensate. */\n  degradation?: SearchDegradation;\n}\n\n/**\n * Pure planner core: compare query/corpus hints and, on a mismatch without a\n * vector tier, build the visible degradation signal.\n */\nexport function planCrossScript(input: {\n  queryLanguage: LanguageHint | undefined;\n  corpusLanguage: LanguageHint | undefined;\n  vectorTierAvailable: boolean;\n}): CrossScriptPlan {\n  const crossScript =\n    input.queryLanguage !== undefined &&\n    input.corpusLanguage !== undefined &&\n    input.queryLanguage !== input.corpusLanguage;\n  return {\n    queryLanguage: input.queryLanguage,\n    corpusLanguage: input.corpusLanguage,\n    crossScript,\n    degradation:\n      crossScript && !input.vectorTierAvailable\n        ? {\n            backend: \"qmd\",\n            code: \"vector_tier_unavailable\",\n            detail:\n              `cross-script query (${input.queryLanguage}) over a ${input.corpusLanguage} corpus: ` +\n              \"lexical recall cannot match across scripts — enable a multilingual embedding model \" +\n              \"(embedding fallback) so the vector tier can serve it\",\n          }\n        : undefined,\n  };\n}\n\n/** Corpus sample cap: dominant script stabilizes well below the full corpus. */\nconst CORPUS_SAMPLE_CAP = 500;\n\n/** Memoized dominant corpus language per storage dir, keyed by corpus scan version. */\nconst corpusLanguageCache = new Map<string, { version: string; language: LanguageHint | undefined }>();\n\n/**\n * Dominant corpus language for a storage manager, sampled from the newest\n * frontmatter `language` hints (capped, memoized on the corpus scan version so\n * recurring recalls pay one pass per corpus generation, not per query).\n * Read failures degrade to `undefined` — never break recall.\n */\nexport async function dominantCorpusLanguage(\n  storage: CorpusLanguageStorage,\n): Promise<LanguageHint | undefined> {\n  try {\n    const version = storage.getCorpusScanVersion();\n    const cached = corpusLanguageCache.get(storage.dir);\n    if (cached?.version === version) return cached.language;\n    const memories = await storage.readAllMemories();\n    const language = corpusDominantLanguage(\n      memories.slice(0, CORPUS_SAMPLE_CAP).map((memory: MemoryFile) => memory.frontmatter.language),\n    );\n    if (corpusLanguageCache.size > 8) corpusLanguageCache.clear();\n    corpusLanguageCache.set(storage.dir, { version, language });\n    return language;\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-EIR5VLIH.js → chunk-4K7IW3F7.js}

@@ -16,7 +16,7 @@ function runSerialized(key, task) {
   });
   return next;
 }
-var MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES = /* @__PURE__ */ new Set(["fact"]);
+var MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES = /* @__PURE__ */ new Set(["fact", "procedure"]);
 function memoryWorthOutcomeEligibleCategories() {
   return new Set(MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES);
 }
@@ -87,4 +87,4 @@ export {
   memoryWorthOutcomeEligibleCategories,
   recordMemoryOutcome
 };
-//# sourceMappingURL=chunk-EIR5VLIH.js.map
+//# sourceMappingURL=chunk-4K7IW3F7.js.map

package/dist/chunk-4K7IW3F7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-worth-outcomes.ts"],"sourcesContent":["/**\n * Issue #560 PR 3 — Memory Worth outcome signal pipeline.\n *\n * PR 1 added `mw_success` / `mw_fail` fields to MemoryFrontmatter. PR 2 added\n * a pure scoring helper. This module adds the one piece tying the two\n * together: a way for callers to record a single outcome observation against\n * a memory, which increments the appropriate counter in frontmatter.\n *\n * The public entry point is `recordMemoryOutcome({ memoryPath, outcome, ... })`.\n * Callers pass the full path to the memory file (not just the ID) because in\n * the usual outcome source — the observation ledger — the memory path is\n * already captured in the event payload, and path-based lookup avoids a\n * full-corpus scan.\n *\n * Intentional properties:\n *   - Works on a per-memory basis (no bulk API in this slice). Bulk update is\n *     an easy layer on top of this once a second caller needs it.\n *   - Reuses the existing `updateMemoryFrontmatter(id, patch)` write path so\n *     unrelated fields (confidence, importance, lifecycle hooks, etc.) are\n *     preserved. The PR 1 serializer rejects negative / non-integer counters,\n *     so we rely on that for defensive validation rather than duplicating it.\n *   - Only instruments categories in `MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES`\n *     (currently `fact` and `procedure` — procedures joined in issue #2370 —\n *     matching `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in operator-toolkit.ts for\n *     the doctor audit). Non-eligible memories return\n *     `{ ok: false, reason: \"ineligible_category\" }` rather than throwing so\n *     the caller — typically a ledger consumer draining heterogeneous events\n *     — doesn't need to pre-filter by category.\n *   - Missing / unknown memory IDs return `{ ok: false, reason: \"not_found\" }`\n *     rather than throwing, because outcome events may reference memories\n *     that were archived/deleted between the session and the ledger drain.\n *     That isn't an operator-actionable error.\n *   - On success, returns the new counter values so observability surfaces\n *     can report the increment without a second read.\n *\n * Out of scope (later PRs):\n *   - Recall filter reading the counters (PR 4).\n *   - Benchmark + default flip (PR 5).\n *   - Automatic increments from extraction or summarization. Only the\n *     explicit `MEM_OUTCOME` ledger tag or an MCP tool call drives writes.\n */\n\nimport path from \"node:path\";\n\nimport type { StorageManager } from \"./storage.js\";\nimport type { MemoryFrontmatter } from \"./types.js\";\n\n/**\n * Per-memory-ID serialization of the read-modify-write increment.\n *\n * Codex P1: without this, concurrent calls for the same memory race. Both\n * callers read the same `mw_*` values, each writes +1, and one increment\n * is lost — silently undercounting outcomes. We chain an async promise\n * per memory ID so read-then-write is atomic with respect to other calls\n * into this module.\n *\n * This serializes only THIS module. Direct writers (e.g. hand-rolled\n * frontmatter patches) still bypass the lock, but the documented surface\n * for Memory Worth increments is this function, and the bench only uses\n * this path.\n *\n * The lock map is WeakRef-free by design: the chain self-cleans once the\n * last pending write resolves (we delete the entry inside the `.finally`\n * of the tail), so memory use stays bounded even for long-running\n * processes that touch many different memory IDs.\n */\nconst outcomeLocks = new Map<string, Promise<unknown>>();\n\nfunction runSerialized<T>(key: string, task: () => Promise<T>): Promise<T> {\n  const prev = outcomeLocks.get(key) ?? Promise.resolve();\n  // Swallow upstream errors so a failed outcome for memory A doesn't\n  // permanently poison the chain for memory A. We still propagate our own\n  // result/errors to the caller.\n  const next = prev.catch(() => undefined).then(task);\n  outcomeLocks.set(key, next);\n  // Chain the cleanup off `next` BUT attach a `.catch` so the cleanup\n  // promise itself never surfaces as an unhandled rejection. The caller\n  // gets `next` back and handles it their own way; this detached cleanup\n  // chain has no observer, so without the .catch Node would crash the\n  // process on a task rejection even when the caller awaited `next` and\n  // handled the error correctly.\n  next\n    .then(\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      },\n      () => {\n        if (outcomeLocks.get(key) === next) outcomeLocks.delete(key);\n      },\n    )\n    .catch(() => {\n      // Defensive no-op in case a hook inside the cleanup branches throws.\n    });\n  return next;\n}\n\n/**\n * Categories currently instrumented for Memory Worth counters. `procedure`\n * joined in issue #2370 — the procedure library-health maintenance loop\n * retires on failure-dominant `mw_*` counters, so injected procedures must\n * be able to accrue outcomes. Must be kept in sync with\n * `MEMORY_WORTH_ELIGIBLE_CATEGORIES` in `operator-toolkit.ts`. Declared\n * here (not imported) to avoid a circular dep with operator-toolkit, which\n * imports from this file's peers. The two constants are validated by a\n * test to stay in lockstep.\n */\nconst MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES: ReadonlySet<MemoryFrontmatter[\"category\"]> =\n  new Set([\"fact\", \"procedure\"]);\n\n/**\n * Exported so downstream tests / operators can query the allowlist without\n * re-declaring it. Returned as a frozen copy so consumers cannot mutate the\n * module-internal set.\n */\nexport function memoryWorthOutcomeEligibleCategories(): ReadonlySet<MemoryFrontmatter[\"category\"]> {\n  return new Set(MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES);\n}\n\n/**\n * The direction of an outcome — whether the session that consumed this\n * memory succeeded or failed. Restricted to a string literal union so\n * callers in TypeScript land can't pass arbitrary tags.\n */\nexport type MemoryOutcomeKind = \"success\" | \"failure\";\n\n/**\n * Arguments to `recordMemoryOutcome`.\n *\n * `memoryPath` is the filesystem path to the memory; we derive the ID from\n * the basename, matching how the operator-toolkit and recall layers map\n * paths to IDs.\n */\nexport interface RecordMemoryOutcomeInput {\n  /**\n   * Absolute or repo-relative path to the memory file. Typically the value\n   * of `MemoryFile.path` for a memory returned by `readAllMemories`.\n   */\n  memoryPath: string;\n  /** Outcome direction — \"success\" bumps mw_success; \"failure\" bumps mw_fail. */\n  outcome: MemoryOutcomeKind;\n  /**\n   * Optional observation timestamp for audit / telemetry. This PR doesn't\n   * persist the timestamp (PR 4/5 will use `lastAccessed`, which already\n   * covers the recency-decay requirement), but accepting it here keeps the\n   * call shape stable so future ledger integrations don't need a breaking\n   * change.\n   */\n  timestamp?: Date | string;\n}\n\n/**\n * Outcome of a `recordMemoryOutcome` call.\n *\n * `ok: true` means the counter was incremented and flushed. The returned\n * values reflect the post-increment state, so callers can log\n * `\"fact-xyz: 4/1 → 5/1\"` without re-reading.\n *\n * `ok: false` carries a short machine-readable `reason` so a ledger drainer\n * can aggregate metrics (\"how many events hit not_found this hour?\"). The\n * human-readable `message` is a friendlier version for logs.\n */\nexport type RecordMemoryOutcomeResult =\n  | {\n      ok: true;\n      memoryId: string;\n      /** New value of `mw_success` after the increment. */\n      mw_success: number;\n      /** New value of `mw_fail` after the increment. */\n      mw_fail: number;\n    }\n  | {\n      ok: false;\n      reason:\n        | \"not_found\"\n        | \"ineligible_category\"\n        | \"invalid_outcome\"\n        | \"invalid_path\";\n      message: string;\n    };\n\n/**\n * Extract the memory ID from a file path. Memory files are stored as\n * `<id>.md`, matching the rest of the system (see `getMemoryById`, which\n * infers paths from IDs).\n *\n * Returns `null` for any path that does not end in `.md`. The check is\n * unconditional — `path.basename` strips directory components before the\n * suffix check, so previous conditional logic silently accepted\n * directory-prefixed paths like `/tmp/facts/2026-01-01/not-a-memory`\n * (the basename `not-a-memory` is not equal to the input, so the `.md`\n * guard was skipped). The new check looks at the raw input once.\n */\nfunction memoryIdFromPath(memoryPath: string): string | null {\n  if (!memoryPath || typeof memoryPath !== \"string\") return null;\n  if (!memoryPath.endsWith(\".md\")) return null;\n  const basename = path.basename(memoryPath, \".md\");\n  if (!basename) return null;\n  return basename;\n}\n\n/**\n * Record a single outcome observation against a memory. Increments\n * `mw_success` or `mw_fail` on the memory's frontmatter (preserving all\n * other fields) via the existing `updateMemoryFrontmatter` write path.\n *\n * See the top-of-file doc comment for policy details (eligible categories,\n * error semantics, and what is intentionally out of scope).\n */\nexport async function recordMemoryOutcome(\n  storage: StorageManager,\n  input: RecordMemoryOutcomeInput,\n): Promise<RecordMemoryOutcomeResult> {\n  if (input.outcome !== \"success\" && input.outcome !== \"failure\") {\n    return {\n      ok: false,\n      reason: \"invalid_outcome\",\n      message: `outcome must be \"success\" or \"failure\"; got ${JSON.stringify(input.outcome)}`,\n    };\n  }\n\n  const memoryId = memoryIdFromPath(input.memoryPath);\n  if (memoryId === null) {\n    return {\n      ok: false,\n      reason: \"invalid_path\",\n      message: `memoryPath must end in .md; got ${JSON.stringify(input.memoryPath)}`,\n    };\n  }\n\n  // Serialize the read-modify-write per memory ID so concurrent callers\n  // (parallel ledger drain, multiple MCP clients, etc.) can't each read\n  // the same snapshot and race to write `+1`, losing an increment.\n  return runSerialized(memoryId, async () => {\n    const memory = await storage.getMemoryById(memoryId);\n    if (!memory) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `no memory with id ${memoryId}`,\n      };\n    }\n\n    if (!MEMORY_WORTH_OUTCOME_ELIGIBLE_CATEGORIES.has(memory.frontmatter.category)) {\n      return {\n        ok: false,\n        reason: \"ineligible_category\",\n        message: `category ${memory.frontmatter.category} is not instrumented for Memory Worth`,\n      };\n    }\n\n    // Absent counters are treated as 0 (matching the PR 1 semantics — legacy\n    // memories implicitly have Beta(1,1) priors). Increments land on the\n    // actual counter regardless of whether the field was previously set.\n    const currentSuccess = memory.frontmatter.mw_success ?? 0;\n    const currentFail = memory.frontmatter.mw_fail ?? 0;\n\n    const nextSuccess = input.outcome === \"success\" ? currentSuccess + 1 : currentSuccess;\n    const nextFail = input.outcome === \"failure\" ? currentFail + 1 : currentFail;\n\n    // `updateMemoryFrontmatter` goes through `writeMemoryFrontmatter`, which\n    // routes through the PR 1 serializer — so a stored corrupt value (e.g., a\n    // pre-existing float) would be rejected here. That is intentional: we\n    // refuse to layer a fresh increment on top of garbage. Operators should\n    // use `remnic doctor` to find and fix those rows before PR 4 ships.\n    //\n    // `updateMemoryFrontmatter` returns `false` when the memory is no\n    // longer present (archived / deleted between `getMemoryById` and the\n    // write). Surface that as `not_found` so callers see an honest result\n    // — silently returning `ok: true` with a counter that never landed\n    // would skew downstream worth scoring.\n    const updated = await storage.updateMemoryFrontmatter(memoryId, {\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    });\n    if (!updated) {\n      return {\n        ok: false,\n        reason: \"not_found\",\n        message: `memory ${memoryId} disappeared between read and write`,\n      };\n    }\n\n    return {\n      ok: true,\n      memoryId,\n      mw_success: nextSuccess,\n      mw_fail: nextFail,\n    };\n  });\n}\n"],"mappings":";AA0CA,OAAO,UAAU;AAwBjB,IAAM,eAAe,oBAAI,IAA8B;AAEvD,SAAS,cAAiB,KAAa,MAAoC;AACzE,QAAM,OAAO,aAAa,IAAI,GAAG,KAAK,QAAQ,QAAQ;AAItD,QAAM,OAAO,KAAK,MAAM,MAAM,MAAS,EAAE,KAAK,IAAI;AAClD,eAAa,IAAI,KAAK,IAAI;AAO1B,OACG;AAAA,IACC,MAAM;AACJ,UAAI,aAAa,IAAI,GAAG,MAAM,KAAM,cAAa,OAAO,GAAG;AAAA,IAC7D;AAAA,IACA,MAAM;AACJ,UAAI,aAAa,IAAI,GAAG,MAAM,KAAM,cAAa,OAAO,GAAG;AAAA,IAC7D;AAAA,EACF,EACC,MAAM,MAAM;AAAA,EAEb,CAAC;AACH,SAAO;AACT;AAYA,IAAM,2CACJ,oBAAI,IAAI,CAAC,QAAQ,WAAW,CAAC;AAOxB,SAAS,uCAAmF;AACjG,SAAO,IAAI,IAAI,wCAAwC;AACzD;AA4EA,SAAS,iBAAiB,YAAmC;AAC3D,MAAI,CAAC,cAAc,OAAO,eAAe,SAAU,QAAO;AAC1D,MAAI,CAAC,WAAW,SAAS,KAAK,EAAG,QAAO;AACxC,QAAM,WAAW,KAAK,SAAS,YAAY,KAAK;AAChD,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO;AACT;AAUA,eAAsB,oBACpB,SACA,OACoC;AACpC,MAAI,MAAM,YAAY,aAAa,MAAM,YAAY,WAAW;AAC9D,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR,SAAS,+CAA+C,KAAK,UAAU,MAAM,OAAO,CAAC;AAAA,IACvF;AAAA,EACF;AAEA,QAAM,WAAW,iBAAiB,MAAM,UAAU;AAClD,MAAI,aAAa,MAAM;AACrB,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR,SAAS,mCAAmC,KAAK,UAAU,MAAM,UAAU,CAAC;AAAA,IAC9E;AAAA,EACF;AAKA,SAAO,cAAc,UAAU,YAAY;AACzC,UAAM,SAAS,MAAM,QAAQ,cAAc,QAAQ;AACnD,QAAI,CAAC,QAAQ;AACX,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,qBAAqB,QAAQ;AAAA,MACxC;AAAA,IACF;AAEA,QAAI,CAAC,yCAAyC,IAAI,OAAO,YAAY,QAAQ,GAAG;AAC9E,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,YAAY,OAAO,YAAY,QAAQ;AAAA,MAClD;AAAA,IACF;AAKA,UAAM,iBAAiB,OAAO,YAAY,cAAc;AACxD,UAAM,cAAc,OAAO,YAAY,WAAW;AAElD,UAAM,cAAc,MAAM,YAAY,YAAY,iBAAiB,IAAI;AACvE,UAAM,WAAW,MAAM,YAAY,YAAY,cAAc,IAAI;AAajE,UAAM,UAAU,MAAM,QAAQ,wBAAwB,UAAU;AAAA,MAC9D,YAAY;AAAA,MACZ,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,SAAS,UAAU,QAAQ;AAAA,MAC7B;AAAA,IACF;AAEA,WAAO;AAAA,MACL,IAAI;AAAA,MACJ;AAAA,MACA,YAAY;AAAA,MACZ,SAAS;AAAA,IACX;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/{chunk-HBKFYXBA.js → chunk-4KYOLI6M.js}

@@ -1,27 +1,27 @@
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
+import {
+  AdapterRegistry
+} from "./chunk-RKNJBZ55.js";
 import {
   WriteRateLimiter
 } from "./chunk-TB6CBZ5V.js";
-import {
-  AdapterRegistry
-} from "./chunk-JBPKEARU.js";
 import {
   serializeInlineScriptValue
 } from "./chunk-3HSRWJTC.js";
 import {
   handleSupportPassportOwnerHttp
-} from "./chunk-P4CQCL27.js";
+} from "./chunk-S2DPMJXH.js";
 import {
   buildSupportPassportPublicRequestHandler
-} from "./chunk-FFPBTNLC.js";
+} from "./chunk-Z7PBQPJ4.js";
 import {
   nonEmptyQueryParam,
   optionalNamespaceKindQueryParam,
   optionalQueryString,
   positiveIntQueryParam
-} from "./chunk-CESQ4CMC.js";
+} from "./chunk-5YQ63T4B.js";
 import {
   EngramMcpServer,
   MCP_SUPPORTED_PROTOCOL_VERSIONS,
@@ -31,14 +31,14 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-RQYV6M2T.js";
+} from "./chunk-TF77C7SV.js";
 import {
   RelayMissionStoreError
-} from "./chunk-U56TGYVS.js";
+} from "./chunk-OCZIYAE5.js";
 import {
   executeResolution,
   isValidResolutionVerb
-} from "./chunk-MDVBCPOS.js";
+} from "./chunk-XCTXS7VY.js";
 import {
   isDefaultReviewNamespace,
   listPairs,
@@ -46,7 +46,7 @@ import {
 } from "./chunk-35NN3ZFA.js";
 import {
   validateRequest
-} from "./chunk-5HK3CJAR.js";
+} from "./chunk-W675UJCZ.js";
 import {
   maybeHandleLifecycleFlush
 } from "./chunk-TIDEL77O.js";
@@ -61,15 +61,15 @@ import {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace,
   probeOperationAuthorization
-} from "./chunk-PDKBKBC2.js";
+} from "./chunk-UIN2BWDD.js";
 import {
   CorrectionContractError,
   getOperation,
   resolveQueryNamespaceWritablePreflight
-} from "./chunk-YHSNAGN3.js";
+} from "./chunk-SB7D4BT7.js";
 import {
   handleWhoKnowsHttpQuery
-} from "./chunk-KLPVXLQJ.js";
+} from "./chunk-SPUJNJJC.js";
 import {
   isTrustZoneName
 } from "./chunk-5QZR2RA3.js";
@@ -78,7 +78,7 @@ import {
 } from "./chunk-DEUNUKTD.js";
 import {
   isRecallDisclosure
-} from "./chunk-VRYEXPRX.js";
+} from "./chunk-SBDCZ2AX.js";
 import {
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
@@ -3388,4 +3388,4 @@ export {
   resolveDefaultAdminConsolePublicDir,
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-HBKFYXBA.js.map
+//# sourceMappingURL=chunk-4KYOLI6M.js.map

package/dist/chunk-573TEZCD.js

@@ -0,0 +1,88 @@
+// src/memory-subject-cli.ts
+function parsePromotionCandidatesCliOptions(args) {
+  let limit = 20;
+  if (args.limit !== void 0) {
+    const parsed = Number(args.limit);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {
+      throw new Error(
+        `promotion-candidates: --limit expects an integer in [1, 100] (got ${JSON.stringify(args.limit)})`
+      );
+    }
+    limit = parsed;
+  }
+  return {
+    ...args.namespace !== void 0 && args.namespace !== "" ? { namespace: args.namespace } : {},
+    ...args.targetNamespace !== void 0 && args.targetNamespace !== "" ? { targetNamespace: args.targetNamespace } : {},
+    limit,
+    json: args.json === true
+  };
+}
+function renderPromotionCandidates(result, json) {
+  if (json) return JSON.stringify(result, null, 2);
+  const lines = [
+    `Namespace: ${result.namespace}  Target layer: ${result.targetNamespace}  (minAccessCount ${result.minAccessCount})`
+  ];
+  if (result.candidates.length === 0) {
+    lines.push("No promotion candidates.");
+    return lines.join("\n");
+  }
+  for (const c of result.candidates) {
+    lines.push(
+      `- ${c.id} [${c.category}] signal=${c.reuseSignal} access=${c.accessCount} reinforced=${c.reinforcementCount} mw=${c.mwSuccess}/${c.mwFail}`
+    );
+    lines.push(`  ${c.content.replace(/\s+/g, " ").slice(0, 100)}`);
+  }
+  lines.push("Promote explicitly with the existing promotion commands; nothing is auto-promoted.");
+  return lines.join("\n");
+}
+async function runPromotionCandidatesCommand(rest, io) {
+  const flag = (name) => {
+    const hit = rest.find((a) => a.startsWith(`--${name}=`));
+    return hit === void 0 ? void 0 : hit.slice(name.length + 3);
+  };
+  const options = parsePromotionCandidatesCliOptions({
+    namespace: flag("namespace"),
+    targetNamespace: flag("target-namespace"),
+    limit: flag("limit"),
+    json: rest.includes("--json")
+  });
+  const result = await io.promotionCandidates({
+    ...options.namespace !== void 0 ? { namespace: options.namespace } : {},
+    ...options.targetNamespace !== void 0 ? { targetNamespace: options.targetNamespace } : {},
+    limit: options.limit
+  });
+  io.stdout(renderPromotionCandidates(result, options.json));
+}
+function parseSubjectsBackfillCliOptions(args) {
+  return {
+    mode: args.apply === true ? "apply" : "shadow",
+    ...args.namespace !== void 0 && args.namespace !== "" ? { namespace: args.namespace } : {}
+  };
+}
+async function runSubjectsBackfillCommand(rest, io) {
+  const namespaceFlag = rest.find((a) => a.startsWith("--namespace="))?.slice("--namespace=".length);
+  const options = parseSubjectsBackfillCliOptions({
+    apply: rest.includes("--apply"),
+    namespace: namespaceFlag
+  });
+  const report = await io.backfill(options);
+  const lines = [
+    `Mode: ${report.mode}  Scanned: ${report.scanned}  Already stamped: ${report.alreadyStamped}  To stamp: ${report.stamped}`
+  ];
+  for (const stamp of report.stamps) {
+    lines.push(`- ${stamp.id} [${stamp.category}] \u2192 subject: ${stamp.subject}`);
+  }
+  if (report.mode === "shadow") {
+    lines.push("Shadow run \u2014 nothing written. Re-run with --apply to stamp.");
+  }
+  io.stdout(lines.join("\n"));
+}
+
+export {
+  parsePromotionCandidatesCliOptions,
+  renderPromotionCandidates,
+  runPromotionCandidatesCommand,
+  parseSubjectsBackfillCliOptions,
+  runSubjectsBackfillCommand
+};
+//# sourceMappingURL=chunk-573TEZCD.js.map

package/dist/chunk-573TEZCD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-subject-cli.ts"],"sourcesContent":["/**\n * CLI surface for memory-subject operations (issue #2372).\n *\n * `remnic promotion-candidates` — read-only surfacing of agent-subject,\n * reuse-signaled promotion candidates. `remnic subjects backfill` — the\n * deterministic shadow/apply stamp for unstamped memories. Runners take an\n * io seam (service/storage callbacks + stdout) so tests drive them without\n * booting an orchestrator; the remnic-cli entry supplies the real ones.\n */\n\nimport type {\n  PromotionCandidatesResult,\n  SubjectBackfillReport,\n} from \"./memory-subject.js\";\n\nexport interface PromotionCandidatesCliOptions {\n  namespace?: string;\n  targetNamespace?: string;\n  limit: number;\n  json: boolean;\n}\n\nexport function parsePromotionCandidatesCliOptions(args: {\n  namespace?: string;\n  targetNamespace?: string;\n  limit?: string;\n  json?: boolean;\n}): PromotionCandidatesCliOptions {\n  let limit = 20;\n  if (args.limit !== undefined) {\n    const parsed = Number(args.limit);\n    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {\n      throw new Error(\n        `promotion-candidates: --limit expects an integer in [1, 100] (got ${JSON.stringify(args.limit)})`,\n      );\n    }\n    limit = parsed;\n  }\n  return {\n    ...(args.namespace !== undefined && args.namespace !== \"\" ? { namespace: args.namespace } : {}),\n    ...(args.targetNamespace !== undefined && args.targetNamespace !== \"\"\n      ? { targetNamespace: args.targetNamespace }\n      : {}),\n    limit,\n    json: args.json === true,\n  };\n}\n\nexport function renderPromotionCandidates(result: PromotionCandidatesResult, json: boolean): string {\n  if (json) return JSON.stringify(result, null, 2);\n  const lines = [\n    `Namespace: ${result.namespace}  Target layer: ${result.targetNamespace}  (minAccessCount ${result.minAccessCount})`,\n  ];\n  if (result.candidates.length === 0) {\n    lines.push(\"No promotion candidates.\");\n    return lines.join(\"\\n\");\n  }\n  for (const c of result.candidates) {\n    lines.push(\n      `- ${c.id} [${c.category}] signal=${c.reuseSignal} access=${c.accessCount} reinforced=${c.reinforcementCount} mw=${c.mwSuccess}/${c.mwFail}`,\n    );\n    lines.push(`  ${c.content.replace(/\\s+/g, \" \").slice(0, 100)}`);\n  }\n  lines.push(\"Promote explicitly with the existing promotion commands; nothing is auto-promoted.\");\n  return lines.join(\"\\n\");\n}\n\nexport async function runPromotionCandidatesCommand(\n  rest: string[],\n  io: {\n    promotionCandidates: (request: {\n      namespace?: string;\n      targetNamespace?: string;\n      limit?: number;\n    }) => Promise<PromotionCandidatesResult>;\n    stdout: (line: string) => void;\n  },\n): Promise<void> {\n  const flag = (name: string): string | undefined => {\n    const hit = rest.find((a) => a.startsWith(`--${name}=`));\n    return hit === undefined ? undefined : hit.slice(name.length + 3);\n  };\n  const options = parsePromotionCandidatesCliOptions({\n    namespace: flag(\"namespace\"),\n    targetNamespace: flag(\"target-namespace\"),\n    limit: flag(\"limit\"),\n    json: rest.includes(\"--json\"),\n  });\n  const result = await io.promotionCandidates({\n    ...(options.namespace !== undefined ? { namespace: options.namespace } : {}),\n    ...(options.targetNamespace !== undefined ? { targetNamespace: options.targetNamespace } : {}),\n    limit: options.limit,\n  });\n  io.stdout(renderPromotionCandidates(result, options.json));\n}\n\nexport interface SubjectsBackfillCliOptions {\n  mode: \"shadow\" | \"apply\";\n  namespace?: string;\n}\n\nexport function parseSubjectsBackfillCliOptions(args: {\n  apply?: boolean;\n  namespace?: string;\n}): SubjectsBackfillCliOptions {\n  return {\n    mode: args.apply === true ? \"apply\" : \"shadow\",\n    ...(args.namespace !== undefined && args.namespace !== \"\" ? { namespace: args.namespace } : {}),\n  };\n}\n\nexport async function runSubjectsBackfillCommand(\n  rest: string[],\n  io: {\n    backfill: (options: { mode: \"shadow\" | \"apply\"; namespace?: string }) => Promise<SubjectBackfillReport>;\n    stdout: (line: string) => void;\n  },\n): Promise<void> {\n  const namespaceFlag = rest.find((a) => a.startsWith(\"--namespace=\"))?.slice(\"--namespace=\".length);\n  const options = parseSubjectsBackfillCliOptions({\n    apply: rest.includes(\"--apply\"),\n    namespace: namespaceFlag,\n  });\n  const report = await io.backfill(options);\n  const lines = [\n    `Mode: ${report.mode}  Scanned: ${report.scanned}  Already stamped: ${report.alreadyStamped}  To stamp: ${report.stamped}`,\n  ];\n  for (const stamp of report.stamps) {\n    lines.push(`- ${stamp.id} [${stamp.category}] → subject: ${stamp.subject}`);\n  }\n  if (report.mode === \"shadow\") {\n    lines.push(\"Shadow run — nothing written. Re-run with --apply to stamp.\");\n  }\n  io.stdout(lines.join(\"\\n\"));\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-RNKNL5GQ.js → chunk-5NM4OH4P.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-WHA6ISFX.js";
+} from "./chunk-JYYBA7TF.js";
 import {
   StorageManager
-} from "./chunk-ZAI5R6DW.js";
+} from "./chunk-J275IYMG.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -1005,4 +1005,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-RNKNL5GQ.js.map
+//# sourceMappingURL=chunk-5NM4OH4P.js.map

package/dist/{chunk-CESQ4CMC.js → chunk-5YQ63T4B.js}

@@ -1,6 +1,6 @@
 import {
   isNamespaceKind
-} from "./chunk-CCP6LXQJ.js";
+} from "./chunk-SQI57UCJ.js";
 import {
   EngramAccessInputError
 } from "./chunk-2Z24E5W2.js";
@@ -40,4 +40,4 @@ export {
   positiveIntQueryParam,
   optionalNamespaceKindQueryParam
 };
-//# sourceMappingURL=chunk-CESQ4CMC.js.map
+//# sourceMappingURL=chunk-5YQ63T4B.js.map

package/dist/{chunk-PMVPCZJZ.js → chunk-6433HV72.js}

@@ -19,7 +19,7 @@ import {
 import {
   decryptCapsuleFileInMemory,
   isEncryptedCapsuleFile
-} from "./chunk-X7Y7WX73.js";
+} from "./chunk-DQEMWVMT.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
@@ -294,4 +294,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-PMVPCZJZ.js.map
+//# sourceMappingURL=chunk-6433HV72.js.map

package/dist/{chunk-4NZHHGVL.js → chunk-7BDZTALN.js}

@@ -69,6 +69,9 @@ var ExtractedFactSchema = z.object({
   scope: z.enum(["project", "global"]).optional().nullable().describe(
     'Scope classification: "global" for cross-project knowledge (framework bugs, library behavior, API patterns, user preferences, general coding patterns); "project" for project-specific knowledge (file paths, env configs, deployment details, project workarounds) and for tool, command, or CLI-flag instructions tied to one agent, since the same tool name can mean different things across agents. When keeping such an agent-tied instruction, begin the fact with a leading "In <agent>," clause naming that agent. Defaults to "project" when a coding context is active.'
   ),
+  subject: z.enum(["user", "agent"]).optional().nullable().describe(
+    'Memory subject: "user" when the fact models the person (preferences, relationships, biography, moments, commitments about their life); "agent" when it is reusable operating knowledge (procedures, principles, tool-usage lessons, debugging strategies, environment facts with no personal content). Emit only for fact/decision-like facts; the category defaults cover preference, relationship, moment, commitment, procedure, principle, and skill.'
+  ),
   quote: z.string().optional().nullable().describe(
     "The EXACT verbatim words from the conversation that support this fact. Copy a contiguous span from a single speaker turn (not a paraphrase). Cap at ~300 characters. This is the grounding evidence for downstream faithfulness verification (issue #1575)."
   ),
@@ -301,4 +304,4 @@ export {
   BehaviorLoopAdjustmentSchema,
   BehaviorLoopPolicyStateSchema
 };
-//# sourceMappingURL=chunk-4NZHHGVL.js.map
+//# sourceMappingURL=chunk-7BDZTALN.js.map

package/dist/chunk-7BDZTALN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const MemoryActionTypeSchema = z.enum([\n  \"store_episode\",\n  \"store_note\",\n  \"update_note\",\n  \"create_artifact\",\n  \"summarize_node\",\n  \"discard\",\n  \"link_graph\",\n]);\n\nexport const MemoryActionEligibilityContextSchema = z\n  .object({\n    confidence: z.number().min(0).max(1),\n    lifecycleState: z.enum([\"active\", \"validated\", \"candidate\", \"stale\", \"archived\"]),\n    importance: z.number().min(0).max(1),\n    source: z.enum([\"extraction\", \"consolidation\", \"replay\", \"manual\", \"unknown\"]),\n  })\n  .strict();\n\nexport function parseMemoryActionType(value: unknown): z.infer<typeof MemoryActionTypeSchema> {\n  const parsed = MemoryActionTypeSchema.safeParse(value);\n  return parsed.success ? parsed.data : \"discard\";\n}\n\nexport function parseMemoryActionEligibilityContext(\n  value: unknown,\n): z.infer<typeof MemoryActionEligibilityContextSchema> {\n  const parsed = MemoryActionEligibilityContextSchema.safeParse(value);\n  if (parsed.success) return parsed.data;\n  return {\n    confidence: 0,\n    lifecycleState: \"candidate\",\n    importance: 0,\n    source: \"unknown\",\n  };\n}\n\nexport const ProcedureStepExtractSchema = z.object({\n  order: z.number(),\n  intent: z.string(),\n  toolCall: z\n    .object({\n      kind: z.string(),\n      signature: z.string(),\n    })\n    .optional()\n    .nullable(),\n  expectedOutcome: z.string().optional().nullable(),\n  optional: z.boolean().optional().nullable(),\n});\n\nexport const ExtractedFactSchema = z.object({\n  category: z.enum([\n    \"fact\",\n    \"preference\",\n    \"correction\",\n    \"entity\",\n    \"decision\",\n    \"relationship\",\n    \"principle\",\n    \"commitment\",\n    \"moment\",\n    \"skill\",\n    \"rule\",\n    \"procedure\",\n    \"reasoning_trace\",\n  ]),\n  content: z\n    .string()\n    .describe(\"The memory content — a clear, standalone statement\"),\n  confidence: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How confident are you this is correct (0-1)\"),\n  tags: z.array(z.string()).describe(\"Relevant tags for categorization\"),\n  entityRef: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If about an entity, its normalized name (e.g. person-jane-doe)\"),\n  cueAnchors: z\n    .array(\n      z.object({\n        type: z.enum([\"entity\", \"file\", \"tool\", \"outcome\", \"constraint\", \"date\"]),\n        value: z.string(),\n      }),\n    )\n    .optional()\n    .nullable()\n    .describe(\"Up to three short retrieval cues for this fact.\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this fact.\"),\n  scope: z\n    .enum([\"project\", \"global\"])\n    .optional()\n    .nullable()\n    .describe(\n      'Scope classification: \"global\" for cross-project knowledge (framework bugs, library behavior, API patterns, user preferences, general coding patterns); \"project\" for project-specific knowledge (file paths, env configs, deployment details, project workarounds) and for tool, command, or CLI-flag instructions tied to one agent, since the same tool name can mean different things across agents. When keeping such an agent-tied instruction, begin the fact with a leading \"In <agent>,\" clause naming that agent. Defaults to \"project\" when a coding context is active.',\n    ),\n  subject: z\n    .enum([\"user\", \"agent\"])\n    .optional()\n    .nullable()\n    .describe(\n      'Memory subject: \"user\" when the fact models the person (preferences, relationships, biography, moments, commitments about their life); \"agent\" when it is reusable operating knowledge (procedures, principles, tool-usage lessons, debugging strategies, environment facts with no personal content). Emit only for fact/decision-like facts; the category defaults cover preference, relationship, moment, commitment, procedure, principle, and skill.',\n    ),\n  quote: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      \"The EXACT verbatim words from the conversation that support this fact. Copy a contiguous span from a single speaker turn (not a paraphrase). Cap at ~300 characters. This is the grounding evidence for downstream faithfulness verification (issue #1575).\",\n    ),\n  structuredAttributes: z\n    .record(z.string(), z.string())\n    .optional()\n    .nullable()\n    .describe(\"Structured key-value attributes when the fact contains measurable or categorical data (e.g., {\\\"price\\\": \\\"29.99\\\", \\\"color\\\": \\\"blue\\\", \\\"date\\\": \\\"2024-03-15\\\"}).\"),\n  procedureSteps: z\n    .array(ProcedureStepExtractSchema)\n    .optional()\n    .nullable()\n    .describe(\n      'For category \"procedure\" only: ordered steps (intent per step). At least two steps; include explicit trigger phrasing in content (e.g. \"When you deploy…\").',\n    ),\n  reasoningTrace: z\n    .object({\n      steps: z\n        .array(\n          z.object({\n            order: z.number(),\n            description: z.string(),\n          }),\n        )\n        // Prompts and normalizer require >=2 ordered steps; enforce it at\n        // the schema layer so gateway-path parsing rejects malformed traces\n        // rather than persisting them (local/direct-client normalization\n        // already enforces this, keeping the two paths symmetric).\n        .min(2)\n        .describe(\"Ordered reasoning steps the user walked through (require >=2).\"),\n      // Accept snake_case aliases so a loose gateway model using\n      // `final_answer` / `observed_outcome` does not fail schema parsing\n      // and drop the entire extraction result. Local/direct-client\n      // normalization already tolerates these keys; the gateway path must\n      // too. Zod's `union` keeps the parse successful either way.\n      finalAnswer: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"The conclusion, decision, or answer the chain arrived at.\"),\n      final_answer: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Alias for finalAnswer (snake_case). Gateway-tolerance shim.\"),\n      observedOutcome: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Optional note about how the answer actually played out.\"),\n      observed_outcome: z\n        .string()\n        .optional()\n        .nullable()\n        .describe(\"Alias for observedOutcome (snake_case). Gateway-tolerance shim.\"),\n    })\n    // Either finalAnswer OR final_answer must be present — enforce here so\n    // the rest of the pipeline can assume a usable string downstream.\n    .refine(\n      (v) =>\n        (typeof v.finalAnswer === \"string\" && v.finalAnswer.trim().length > 0) ||\n        (typeof v.final_answer === \"string\" && v.final_answer.trim().length > 0),\n      { message: \"reasoningTrace requires finalAnswer (or final_answer)\" },\n    )\n    .optional()\n    .nullable()\n    .describe(\n      'For category \"reasoning_trace\" only: a stored solution chain with ordered steps, a final answer, and an optional observed outcome. Require at least two steps.',\n    ),\n  eventTime: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      'Optional event-time expression for bi-temporal validity (#1578). An ISO date (\"2025-03-01\") or a relative expression verbatim (\"last March\", \"yesterday\", \"since 2024\", \"until 2025-06-01\"). Resolved against the source turn timestamp at write time — NOT wall-clock. Omit when the fact has no explicit temporal anchor.',\n    ),\n  event_time: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Alias for eventTime (snake_case). Gateway-tolerance shim (#1578).\"),\n}).superRefine((value, ctx) => {\n  if (value.category === \"procedure\" && (!Array.isArray(value.procedureSteps) || value.procedureSteps.length < 2)) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      path: [\"procedureSteps\"],\n      message: \"procedure facts require at least two procedureSteps\",\n    });\n  }\n\n  if (value.category === \"reasoning_trace\" && value.reasoningTrace == null) {\n    ctx.addIssue({\n      code: z.ZodIssueCode.custom,\n      path: [\"reasoningTrace\"],\n      message: \"reasoning_trace facts require reasoningTrace\",\n    });\n  }\n});\n\nexport const EntityMentionSchema = z.object({\n  name: z\n    .string()\n    .describe(\"Normalized entity name (e.g. jane-doe, acme-corp, my-project)\"),\n  type: z.enum([\"person\", \"project\", \"tool\", \"company\", \"place\", \"other\"]),\n  facts: z\n    .array(z.string())\n    .describe(\"New facts learned about this entity in this conversation\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this entity.\"),\n  structuredSections: z\n    .array(z.object({\n      key: z.string(),\n      title: z.string(),\n      facts: z.array(z.string()),\n    }))\n    .optional()\n    .nullable()\n    .describe(\"Optional named sections for entity-specific facts. Use when facts clearly belong under a durable heading such as Beliefs or Building / Working On.\"),\n});\n\nexport const ExtractedQuestionSchema = z.object({\n  question: z.string().describe(\"A genuine question the AI is curious about based on this conversation\"),\n  context: z.string().describe(\"Why this question matters or what prompted it\"),\n  priority: z.number().min(0).max(1).describe(\"How important/urgent this question is (0-1)\"),\n});\n\nexport const ProactiveQuestionsResultSchema = z.object({\n  questions: z\n    .array(ExtractedQuestionSchema)\n    .describe(\"Additional follow-up questions discovered in a proactive second-pass extraction.\"),\n});\n\nexport const ExtractedRelationshipSchema = z.object({\n  source: z.string().describe(\"Source entity name (normalized, e.g. person-jane-doe)\"),\n  target: z.string().describe(\"Target entity name (normalized, e.g. company-acme-corp)\"),\n  label: z.string().describe(\"Relationship label (e.g. 'works at', 'created', 'manages')\"),\n  promptedByQuestion: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Optional proactive follow-up question that surfaced this relationship.\"),\n});\n\nexport const ProactiveExtractionResultSchema = z.object({\n  facts: z\n    .array(ExtractedFactSchema)\n    .describe(\n      \"Additional high-confidence memories recovered only after answering proactive follow-up questions from the same buffered conversation.\",\n    ),\n  profileUpdates: z\n    .array(z.string())\n    .describe(\n      \"Additional profile updates directly supported by the buffered conversation. Omit anything speculative.\",\n    ),\n  entities: z\n    .array(EntityMentionSchema)\n    .describe(\n      \"Additional entities or entity facts surfaced by the proactive follow-up pass.\",\n    ),\n  relationships: z\n    .array(ExtractedRelationshipSchema)\n    .optional()\n    .nullable()\n    .describe(\n      \"Additional relationships surfaced by the proactive follow-up pass.\",\n    ),\n});\n\n/**\n * Salvage array for model-produced extraction output (issue #2455).\n *\n * Mixed valid+invalid items parse to the valid subset so one malformed\n * element no longer discards the whole extraction. A non-empty array with\n * zero valid items still fails, so bounded retry stays effective and wholly\n * malformed output is never silently accepted as empty. Empty arrays stay\n * valid. Consolidation schemas intentionally stay strict — do not use this\n * for them.\n */\nfunction salvageArray<T extends z.ZodTypeAny>(itemSchema: T) {\n  return z\n    .array(z.unknown())\n    .transform((items, ctx) => {\n      const valid: z.infer<T>[] = [];\n      for (const raw of items) {\n        const parsed = itemSchema.safeParse(raw);\n        if (parsed.success) {\n          valid.push(parsed.data);\n        }\n      }\n      if (items.length > 0 && valid.length === 0) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          message: \"array contains no items matching the schema\",\n        });\n        return z.NEVER;\n      }\n      return valid;\n    });\n}\n\nexport const ExtractionResultSchema = z.object({\n  facts: salvageArray(ExtractedFactSchema).describe(\n    \"Extracted memories from the conversation. Include facts, preferences, corrections, and decisions. Only extract genuinely new, durable information — skip transient task state.\",\n  ),\n  profileUpdates: salvageArray(z.string()).describe(\n    \"Updates to the user's behavioral profile. Each string is a standalone statement about the user's preferences, habits, or personality. Only include genuinely new insights.\",\n  ),\n  entities: salvageArray(EntityMentionSchema).describe(\n    \"Entities mentioned in the conversation with new facts about them.\",\n  ),\n  questions: salvageArray(ExtractedQuestionSchema).describe(\n    \"Zero to three source-grounded questions useful in future sessions. Return an empty array when the conversation supports none.\",\n  ),\n  identityReflection: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\n      \"A brief reflection on what you learned about yourself as an agent in this interaction — patterns in your behavior, growth, things you did well or could improve.\",\n    ),\n  episodeTitle: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"A six-to-eight word title for this conversation segment.\"),\n  relationships: salvageArray(ExtractedRelationshipSchema)\n    .optional()\n    .nullable()\n    .describe(\n      \"Relationships between entities discovered in this conversation. Max 5 per extraction. Format: {source, target, label}.\",\n    ),\n});\n\nexport const ConsolidationItemSchema = z.object({\n  existingId: z\n    .string()\n    .describe(\"The ID of the existing memory being evaluated\"),\n  action: z.enum([\"ADD\", \"MERGE\", \"UPDATE\", \"INVALIDATE\", \"SKIP\"]),\n  mergeWith: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If MERGE, the ID of the memory to merge with\"),\n  updatedContent: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"If UPDATE or MERGE, the new content\"),\n  reason: z.string().describe(\"Brief reason for this decision\"),\n});\n\nexport const ConsolidationResultSchema = z.object({\n  items: z\n    .array(ConsolidationItemSchema)\n    .describe(\n      \"Decisions for each existing memory: ADD (keep as-is), MERGE (combine with another), UPDATE (revise content), INVALIDATE (mark as outdated/wrong), SKIP (no action needed)\",\n    ),\n  profileUpdates: z\n    .array(z.string())\n    .describe(\"New profile statements to add or update\"),\n  entityUpdates: z\n    .array(EntityMentionSchema)\n    .describe(\"Entity updates from consolidation analysis\"),\n});\n\nexport function buildProfileConsolidationResultSchema(targetLines: number) {\n  return z.object({\n    consolidatedProfile: z\n      .string()\n      .describe(\n        `The full consolidated profile as markdown. Preserve all ## section headers. Merge duplicate or near-duplicate bullets into single clear statements. Remove stale or superseded information. Keep the most important and durable observations. Target roughly ${targetLines} lines.`,\n      ),\n    removedCount: z\n      .number()\n      .describe(\"Number of bullets removed or merged during consolidation\"),\n    summary: z\n      .string()\n      .describe(\"Brief summary of what was consolidated\"),\n  });\n}\n\nexport const ProfileConsolidationResultSchema = buildProfileConsolidationResultSchema(50);\n\nexport const IdentityConsolidationResultSchema = z.object({\n  learnedPatterns: z\n    .array(z.string())\n    .describe(\n      \"Consolidated behavioral patterns and lessons learned, each a concise standalone statement\",\n    ),\n  summary: z\n    .string()\n    .describe(\n      \"A brief paragraph summarizing the agent's core identity insights\",\n    ),\n});\n\nexport type IdentityConsolidationResultParsed = z.infer<\n  typeof IdentityConsolidationResultSchema\n>;\n\n// Contradiction Verification (Phase 2B)\nexport const ContradictionVerificationSchema = z.object({\n  isContradiction: z\n    .boolean()\n    .describe(\"Whether the two memories truly contradict each other\"),\n  confidence: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How confident are you in this assessment (0-1)\"),\n  reasoning: z\n    .string()\n    .describe(\"Explanation of why these are or are not contradictory\"),\n  whichIsNewer: z\n    .enum([\"first\", \"second\", \"unclear\"])\n    .describe(\"Which memory represents the more recent/current state\"),\n});\n\nexport type ContradictionVerificationResult = z.infer<\n  typeof ContradictionVerificationSchema\n>;\n\n// Memory Linking (Phase 3A)\nexport const MemoryLinkSchema = z.object({\n  targetId: z\n    .string()\n    .describe(\"The ID of the memory this links to\"),\n  linkType: z\n    .enum([\"follows\", \"references\", \"contradicts\", \"supports\", \"related\"])\n    .describe(\"The type of relationship\"),\n  strength: z\n    .number()\n    .min(0)\n    .max(1)\n    .describe(\"How strong is this relationship (0-1)\"),\n  reason: z\n    .string()\n    .optional()\n    .nullable()\n    .describe(\"Why this link exists\"),\n});\n\nexport const SuggestedLinksSchema = z.object({\n  links: z\n    .array(MemoryLinkSchema)\n    .describe(\"Suggested links between memories based on semantic analysis\"),\n});\n\nexport type MemoryLink = z.infer<typeof MemoryLinkSchema>;\nexport type SuggestedLinks = z.infer<typeof SuggestedLinksSchema>;\n\n// Memory Summarization (Phase 4A)\nexport const MemorySummarySchema = z.object({\n  summaryText: z\n    .string()\n    .describe(\"A concise summary of the batch of memories\"),\n  keyFacts: z\n    .array(z.string())\n    .describe(\"The most important facts extracted from these memories\"),\n  keyEntities: z\n    .array(z.string())\n    .describe(\"Key entities mentioned across these memories\"),\n});\n\nexport type MemorySummaryResult = z.infer<typeof MemorySummarySchema>;\n\nexport const DaySummaryResultSchema = z.object({\n  summary: z.string().min(1).describe(\"A concise end-of-day summary paragraph.\"),\n  bullets: z.array(z.string()).default([]).describe(\"The most important moments from the day.\"),\n  next_actions: z.array(z.string()).default([]).describe(\"Concrete next actions for tomorrow.\"),\n  risks_or_open_loops: z.array(z.string()).default([]).describe(\"Open loops, blockers, or fragile assumptions still needing attention.\"),\n});\n\n// v8.15 behavior-loop auto-tuning state contracts\nexport const BehaviorLoopAdjustmentSchema = z.object({\n  parameter: z.string().min(1),\n  previousValue: z.number(),\n  nextValue: z.number(),\n  delta: z.number(),\n  evidenceCount: z.number().int().min(0),\n  confidence: z.number().min(0).max(1),\n  reason: z.string(),\n  appliedAt: z.string(),\n});\n\nexport const BehaviorLoopPolicyStateSchema = z.object({\n  version: z.number().int().min(0),\n  windowDays: z.number().int().min(0),\n  minSignalCount: z.number().int().min(0),\n  maxDeltaPerCycle: z.number().min(0).max(1),\n  protectedParams: z.array(z.string()),\n  adjustments: z.array(BehaviorLoopAdjustmentSchema),\n  updatedAt: z.string(),\n});\n\nexport type BehaviorLoopAdjustmentParsed = z.infer<typeof BehaviorLoopAdjustmentSchema>;\nexport type BehaviorLoopPolicyStateParsed = z.infer<typeof BehaviorLoopPolicyStateSchema>;\n\nexport type MemoryActionTypeParsed = z.infer<typeof MemoryActionTypeSchema>;\nexport type MemoryActionEligibilityContextParsed = z.infer<typeof MemoryActionEligibilityContextSchema>;\nexport type ExtractedFactParsed = z.infer<typeof ExtractedFactSchema>;\nexport type EntityMentionParsed = z.infer<typeof EntityMentionSchema>;\nexport type ExtractedQuestionParsed = z.infer<typeof ExtractedQuestionSchema>;\nexport type ProactiveQuestionsResultParsed = z.infer<typeof ProactiveQuestionsResultSchema>;\nexport type ExtractionResultParsed = z.infer<typeof ExtractionResultSchema>;\nexport type ConsolidationItemParsed = z.infer<typeof ConsolidationItemSchema>;\nexport type ConsolidationResultParsed = z.infer<\n  typeof ConsolidationResultSchema\n>;\n"],"mappings":"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","names":[]}

package/dist/{chunk-NS5ETDYD.js → chunk-7BEPVIH3.js}

@@ -2,11 +2,11 @@ import {
   buildExplicitCaptureDedupKey,
   isTombstoneBlockedCaptureWriteLockBusy,
   normalizeExplicitCaptureContent
-} from "./chunk-MUJ4QFUQ.js";
+} from "./chunk-W4BMEGQA.js";
 import {
   TAG_LIMITS,
   composeMemoryEnvelope
-} from "./chunk-LCU5R6TQ.js";
+} from "./chunk-RAIUTAZZ.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-XDL5CYZN.js";
@@ -787,4 +787,4 @@ export {
   shouldProcessInlineExplicitCapture,
   InlineExplicitCaptureProcessor
 };
-//# sourceMappingURL=chunk-NS5ETDYD.js.map
+//# sourceMappingURL=chunk-7BEPVIH3.js.map

package/dist/{chunk-JG22O53B.js → chunk-7CBKAQIG.js}

@@ -19,6 +19,7 @@ var EXTRACTION_RESPONSE_SHAPE = `{
     "promptedByQuestion": "<optional source-grounded question>",
     "quote": "<optional exact contiguous source span>",
     "scope": "<optional project-or-global>",
+    "subject": "<optional user-or-agent>",
     "structuredAttributes": {"<key>": "<value>"},
     "procedureSteps": [{"order": 1, "intent": "<step>"}, {"order": 2, "intent": "<step>"}],
     "reasoningTrace": {
@@ -194,4 +195,4 @@ export {
   buildConsolidationSystemPrompt,
   buildProfileConsolidationSystemPrompt
 };
-//# sourceMappingURL=chunk-JG22O53B.js.map
+//# sourceMappingURL=chunk-7CBKAQIG.js.map

package/dist/chunk-7CBKAQIG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-prompt.ts"],"sourcesContent":["/**\n * Extraction prompt construction (issue #1995 sibling extraction).\n *\n * The system prompt, its JSON response shape, and the placeholder table\n * derived from that shape are prompt DATA, not engine behavior. They live here\n * so `extraction.ts` holds the pipeline and one module owns the text every\n * extraction path — local LLM, direct client, gateway fallback — sends.\n */\n\nimport { AMBIENT_CAPTURE_PROMPT_SECTION, AMBIENT_SPECULATIVE_TIER_CLAUSE } from \"./ambient-provenance.js\";\nimport { resolveMemoryLifecycleCapabilities, resolveRecallAuxiliaryCapabilities } from \"./capabilities.js\";\nimport type { PluginConfig } from \"./types.js\";\n\nexport const EXTRACTION_RESPONSE_SHAPE = `{\n  \"facts\": [{\n    \"category\": \"<category>\",\n    \"content\": \"<source-grounded statement>\",\n    \"confidence\": 0.0,\n    \"tags\": [\"<tag>\"],\n    \"entityRef\": \"<optional normalized-name>\",\n    \"cueAnchors\": [{\"type\": \"<anchor-type>\", \"value\": \"<entity-or-topic plus key aspect>\"}],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"quote\": \"<optional exact contiguous source span>\",\n    \"scope\": \"<optional project-or-global>\",\n    \"subject\": \"<optional user-or-agent>\",\n    \"structuredAttributes\": {\"<key>\": \"<value>\"},\n    \"procedureSteps\": [{\"order\": 1, \"intent\": \"<step>\"}, {\"order\": 2, \"intent\": \"<step>\"}],\n    \"reasoningTrace\": {\n      \"steps\": [{\"order\": 1, \"description\": \"<step>\"}, {\"order\": 2, \"description\": \"<step>\"}],\n      \"finalAnswer\": \"<answer>\",\n      \"observedOutcome\": \"<optional outcome>\"\n    },\n    \"eventTime\": \"<optional source temporal expression>\"\n  }],\n  \"entities\": [{\n    \"name\": \"<normalized-name>\",\n    \"type\": \"<entity-type>\",\n    \"facts\": [\"<source-grounded statement>\"],\n    \"promptedByQuestion\": \"<optional source-grounded question>\",\n    \"structuredSections\": [{\"key\": \"<section-key>\", \"title\": \"<section-title>\", \"facts\": [\"<source-grounded statement>\"]}]\n  }],\n  \"profileUpdates\": [\"<source-grounded profile update>\"],\n  \"questions\": [{\"question\": \"<source-grounded unresolved question>\", \"context\": \"<source-grounded context>\", \"priority\": 0.0}],\n  \"identityReflection\": \"<conversation-grounded agent reflection>\",\n  \"episodeTitle\": \"<six-to-eight word conversation segment title>\",\n  \"relationships\": [{\"source\": \"<normalized-name>\", \"target\": \"<normalized-name>\", \"label\": \"<source-grounded relationship>\"}]\n}`;\nexport const EXTRACTION_RESPONSE_PLACEHOLDERS: Record<string, true> = {};\nfor (const placeholder of EXTRACTION_RESPONSE_SHAPE.match(/<[^<>\\r\\n]+>/g) ?? []) {\n  EXTRACTION_RESPONSE_PLACEHOLDERS[placeholder] = true;\n}\nexport const CUE_ANCHOR_PROMPT_INSTRUCTION = `- For each fact, emit at most 3 \"cueAnchors\".\n- Each cue anchor value must be a source-grounded search hook of at most 120 characters, in the form \"<main entity or topic> <key aspect>\".\n- Set each cue anchor type to entity, file, tool, outcome, constraint, or date.\n- Omit cue anchors when the conversation does not support a useful search hook.\n- Example: \"Alice booked Bistro Max for Mike's surprise party\" can use {\"type\":\"entity\",\"value\":\"Mike surprise party\"} and {\"type\":\"entity\",\"value\":\"Alice restaurant booking\"}.`;\n\n/**\n * Output-language policy (issue #2190). Every prompt that produces memory\n * content embeds this verbatim so non-English conversations are not silently\n * translated to English — translated memories fail later lexical recall.\n */\nexport const OUTPUT_LANGUAGE_POLICY = `Output language: write facts, profile updates, entity names and aliases, tags, questions, and any rewritten or merged memory content in the source language of the conversation or input memories. Never translate into English or another language unless the user explicitly asked for a translation.`;\n\n/**\n * Bi-temporal event-time extraction instruction (#1578 PR2). Emitted on\n * every extraction entry path when `temporal.biTemporal` is on so the LLM\n * emits an optional per-fact `eventTime` expression. The expression is\n * resolved against the source turn timestamp at write time — never\n * wall-clock — so replay/import of old transcripts anchors correctly.\n * Returns an empty string when the gate is off (byte-identical prompt).\n */\nexport function eventTimePromptInstruction(config: PluginConfig): string {\n  if (!config.temporalBiTemporal) return \"\";\n  return `\nWhen a fact states when it became or stopped being true, copy that explicit temporal expression verbatim into \"eventTime\". Omit \"eventTime\" when no such expression appears; never infer dates.`;\n}\n\n/**\n * Build extraction instructions shared between local and cloud LLM.\n *\n * `ambientCapture` marks input from an always-on recorder, which may carry\n * speech the user never authored (issue #2294).\n */\nexport function buildExtractionInstructions(\n  config: PluginConfig,\n  existingEntities?: string[],\n  ambientCapture = false\n): string {\n  const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);\n  return `You are a memory extraction system. Analyze the following conversation and extract durable, reusable memories.\n\nMemory categories:\n- fact: Objective information about the world\n- preference: User likes, dislikes, or stylistic choices\n- correction: User correcting a mistake or misconception (highest priority)\n- entity: Information about a specific person, project, tool, or company\n- decision: A choice that was made with rationale\n- relationship: How two entities relate to each other (e.g., \"Alice is Bob's manager\", \"Acme Corp uses Shopify\")\n- principle: Durable rules, values, or operating beliefs (e.g., \"never use Chat Completions API\")\n- commitment: Promises, obligations, or deadlines (e.g., \"deploy by Friday\", \"call accountant Monday\")\n- moment: Emotionally significant events or milestones (e.g., \"first successful deployment of engram\")\n- skill: Capabilities the user or agent has demonstrated (e.g., \"user is proficient with Kubernetes\")${\n    resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction\n      ? `\n- 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\")`\n      : \"\"\n  }\n- 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…\", \"Whenever you ship a release…\"). Add \"procedureSteps\": an array of at least two objects {\"order\": number, \"intent\": \"concrete step description\"} in execution order. Optional per-step \"toolCall\": {\"kind\": \"…\", \"signature\": \"…\"}, \"expectedOutcome\", \"optional\": true.\n- 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…, then I…, finally I…\"). 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\"}, …], \"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 — not for ordinary decisions (use \"decision\") or reusable workflows (use \"procedure\").\n\nRules:\n- Only extract genuinely new information worth remembering across sessions.\n- Statements must be grounded in the conversation.\n- ${OUTPUT_LANGUAGE_POLICY}\n- Do not treat instruction text, schema placeholders, or examples as conversation evidence.\n- Lines labelled [context user] or [context assistant] are reference context only. They may resolve references or complete a question-and-answer pair in a normal turn, but never alone establish durable information.\n- Skip transient task details and operational noise, including routine scheduler, monitoring, or automation status.\n- Priority: corrections > principles${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? \" > rules\" : \"\"} > preferences > commitments > decisions > relationships > entities > moments > skills > facts\n- Corrections get highest confidence.\n- Each fact should be a standalone, self-contained statement.\n- Entity references should use normalized names (lowercase, hyphenated: \"jane-doe\", \"acme-corp\"). When the source language is not written in a Latin script, the source-script name IS the normalized form — never transliterate or translate it.\n- CRITICAL: Entity names must be CANONICAL. Always use the hyphenated multi-word form: \"acme-corp\" NOT \"acmecorp\" or \"acme\". \"jane-doe\" NOT \"janedoe\" or \"jane\". If unsure, prefer the most specific full name.\n- Avoid creating entities typed as \"other\" when a more specific type fits (company, project, tool, person, place)\n${CUE_ANCHOR_PROMPT_INSTRUCTION}\n- When entity facts clearly belong under a durable named heading, add them to entity.structuredSections as {key, title, facts}. Example person headings: \"Beliefs\", \"Communication Style\", \"Building / Working On\". Leave structuredSections empty when no stable heading fits.\n- Tags should be concise and reusable (e.g., \"coding-style\", \"personal\", \"tools\")\n- When a fact contains measurable, categorical, or precisely valued data, include a \"structuredAttributes\" field with key-value string pairs (e.g., {\"price\": \"29.99\", \"brand\": \"Sony\"}, {\"date\": \"2024-03-15\", \"location\": \"SF\"}, {\"chosen\": \"PostgreSQL\", \"rejected\": \"MongoDB\"}). Only for concrete values, not narrative content.\n- Set confidence using these tiers:\n  * Explicit (0.95-1.0): Direct user statements — \"I prefer X\", \"my name is Y\"\n  * Implied (0.70-0.94): Strong contextual inference — user consistently does X, clear from conversation flow\n  * Inferred (0.40-0.69): Pattern recognition — reasonable guess from limited evidence\n  * Speculative (0.00-0.39): Tentative hypothesis — weak signal, needs future confirmation. Speculative memories auto-expire after 30 days if not confirmed.${ambientCapture ? AMBIENT_SPECULATIVE_TIER_CLAUSE : \"\"}${\n    config.provenance?.enabled\n      ? `\n- Source quotes: For each fact, include a \"quote\" field containing the EXACT verbatim words from the conversation that support the fact. Copy a contiguous span from a single speaker turn (not a paraphrase, not a summary). Cap at ~300 characters. This grounds every memory in the literal utterance that created it.`\n      : \"\"\n  }\n- For commitments: include any deadline or timeframe mentioned${\n    lifecycleCaps.extractionScopeClassification\n      ? `\n\nScope classification:\nFor each fact, set \"scope\" to one of:\n- \"global\" — knowledge that applies across projects: core framework/library bugs, API behavior patterns, user preferences (editor, language, style), general coding patterns, infrastructure knowledge, technology facts not tied to one codebase\n- \"project\" — knowledge specific to one codebase: file paths, environment configs, deployment details, project-specific workarounds, team/stakeholder info tied to one project, repo-specific conventions. Tool, command, or CLI-flag instructions TIED TO ONE AGENT are also \"project\", because the same tool name means different things in different agent integrations (a \"search\" tool may search repository code in one agent and the web in another); when keeping such an agent-tied instruction, the fact text MUST name the originating agent as a leading \"In <agent>,\" clause (e.g. \"In Pi, use the search tool with a repository path.\"). A tool/command fact that holds in every agent and every repo is NOT agent-tied — leave it \"global\" and do not add a qualifier (e.g. \"\\`git status --short\\` emits compact output\"). Examples: \"In Pi, the search tool takes a repository path\" -> \"project\"; \"\\`git status --short\\` emits compact output\" -> \"global\".\nWhen in doubt, prefer \"project\" — it is safer to keep knowledge scoped narrowly.`\n      : \"\"\n  }\n${\n  ambientCapture\n    ? `${AMBIENT_CAPTURE_PROMPT_SECTION}\n`\n    : \"\"\n}\nEntity creation rules (STRICT):\n- Only create entities for DURABLE things: real people, companies, products, tools, ongoing projects\n- NEVER create entities for transient items: individual PRs, branches, Jira tickets, meetings, agent task IDs, log files, database tables, cron job runs, sessions\n- When you learn something about a transient item (e.g., PR #58 fixed a bug), store it as a FACT with an entityRef to the parent project — do NOT create an entity for the PR itself\n- Prefer attaching facts to broad parent entities rather than creating sub-entities. E.g., \"acme-store uses Algolia for search\" is a fact on entity \"acme-store\", NOT a new entity \"acme-store-algolia-connector\"\n- The entity list should be SHORT — think \"things that would have their own Wikipedia page\" not \"things mentioned in passing\"\n\n${\n  existingEntities && existingEntities.length > 0\n    ? `\nKNOWN ENTITIES (use these exact names when referencing existing things):\n${existingEntities.join(\", \")}\n\nWhen you see something that matches a known entity, use THAT name exactly. Only create a NEW entity if nothing in this list represents it.\n`\n    : \"\"\n}\n${eventTimePromptInstruction(config)}\nAlso extract relationships between entities mentioned in the conversation.\n- Format: {source: \"entity-name\", target: \"entity-name\", label: \"relationship description\"}\n- Max 5 relationships per extraction\n- Only include clear, durable relationships (e.g., \"works at\", \"created\", \"manages\", \"uses\")\n- Use normalized entity names (e.g., \"person-jane-doe\", \"company-acme-corp\")\n\n\nAlso emit \"episodeTitle\" as a six-to-eight word title for this conversation segment.\nQuestions are optional. Include only source-grounded unresolved questions that would be useful in future sessions; otherwise return an empty array.\n\nFinally, write a brief identity reflection about the agent who had this conversation, based only on the conversation. Do not write about the extraction process.`;\n}\n\nexport const CONSOLIDATION_RESPONSE_SCHEMA = `{\n  \"items\": [\n    {\n      \"existingId\": \"id\",\n      \"action\": \"ADD\",\n      \"mergeWith\": \"optional-existing-id\",\n      \"updatedContent\": \"optional replacement content\",\n      \"reason\": \"brief reason for this action\"\n    }\n  ],\n  \"profileUpdates\": [\"optional profile update\"],\n  \"entityUpdates\": [{\"name\": \"person-jane-doe\", \"type\": \"person\", \"facts\": [\"Now leads the backend team\", \"Recently migrated the user service to TypeScript\"]}]\n}`;\n\nexport const PROFILE_CONSOLIDATION_RESPONSE_SCHEMA = `{\n  \"consolidatedProfile\": \"# Behavioral Profile\\\\n\\\\n... (complete markdown)\",\n  \"removedCount\": 42,\n  \"summary\": \"brief summary of what was consolidated\"\n}`;\n\n/**\n * System prompt shared by every consolidation path (gateway, direct client,\n * local LLM). Owns the causal-rule clause and the output-language policy so\n * the three paths cannot drift (issue #2190).\n */\nexport function buildConsolidationSystemPrompt(config: PluginConfig): string {\n  return `You are a memory consolidation system. Compare new memories against existing ones and decide what to do with each.\n\nActions:\n- ADD: Keep the new memory as-is (no duplicate exists)\n- MERGE: Combine with an existing memory (provide mergeWith ID and updated content)\n- UPDATE: Replace existing memory content (provide updated content)\n- INVALIDATE: Remove existing memory (it's been superseded or is wrong)\n- SKIP: This new memory is redundant (exact duplicate or subset of existing)\n\nAlso:\n- Suggest profile updates based on patterns across memories\n- Identify entity updates for entity tracking${resolveRecallAuxiliaryCapabilities(config).causalRuleExtraction ? `\n- When merging or updating memories, look for IF→THEN causal patterns. If a memory describes \"X failed/succeeded because Y\" or \"doing X led to Y\", rewrite its content to make the causal rule explicit in the form \"IF <condition> THEN <action/outcome>\".` : \"\"}\n- ${OUTPUT_LANGUAGE_POLICY}`;\n}\n\n/**\n * System prompt shared by every profile-consolidation path (gateway, direct\n * client, local LLM). Owns the output-language policy (issue #2190).\n */\nexport function buildProfileConsolidationSystemPrompt(targetLines: number): string {\n  return `You are a profile consolidation system. You are given a behavioral profile (markdown) that has grown too large. Your job is to produce a CONSOLIDATED version that:\n\n1. PRESERVES all ## section headers and their structure\n2. MERGES duplicate or near-duplicate bullet points into single, clear statements\n3. REMOVES stale information that has been superseded by newer bullets\n4. REMOVES trivial or overly specific operational details that won't be useful across sessions\n5. KEEPS the most important, durable observations about the user's preferences, habits, identity, and working style\n6. Target roughly ${targetLines} lines — this is a soft target, prioritize quality over length\n7. Write in the same style as the existing profile — concise bullets, no fluff\n8. ${OUTPUT_LANGUAGE_POLICY}\n\nThe output should be the COMPLETE consolidated profile as valid markdown, starting with \"# Behavioral Profile\".`;\n}\n"],"mappings":";;;;;;;;;;AAaO,IAAM,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkClC,IAAM,mCAAyD,CAAC;AACvE,WAAW,eAAe,0BAA0B,MAAM,eAAe,KAAK,CAAC,GAAG;AAChF,mCAAiC,WAAW,IAAI;AAClD;AACO,IAAM,gCAAgC;AAAA;AAAA;AAAA;AAAA;AAWtC,IAAM,yBAAyB;AAU/B,SAAS,2BAA2B,QAA8B;AACvE,MAAI,CAAC,OAAO,mBAAoB,QAAO;AACvC,SAAO;AAAA;AAET;AAQO,SAAS,4BACd,QACA,kBACA,iBAAiB,OACT;AACR,QAAM,gBAAgB,mCAAmC,MAAM;AAC/D,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uGAaL,mCAAmC,MAAM,EAAE,uBACvC;AAAA,+LAEA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOE,sBAAsB;AAAA;AAAA;AAAA;AAAA,sCAIY,mCAAmC,MAAM,EAAE,uBAAuB,aAAa,EAAE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMrH,6BAA6B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mKAQ+H,iBAAiB,kCAAkC,EAAE,GAC/M,OAAO,YAAY,UACf;AAAA,6TAEA,EACN;AAAA,gEAEE,cAAc,gCACV;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yFAOA,EACN;AAAA,EAEA,iBACI,GAAG,8BAA8B;AAAA,IAEjC,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASE,oBAAoB,iBAAiB,SAAS,IAC1C;AAAA;AAAA,EAEJ,iBAAiB,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,IAIvB,EACN;AAAA,EACE,2BAA2B,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYpC;AAEO,IAAM,gCAAgC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AActC,IAAM,wCAAwC;AAAA;AAAA;AAAA;AAAA;AAW9C,SAAS,+BAA+B,QAA8B;AAC3E,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+CAWsC,mCAAmC,MAAM,EAAE,uBAAuB;AAAA,oQAC8I,EAAE;AAAA,IAC7P,sBAAsB;AAC1B;AAMO,SAAS,sCAAsC,aAA6B;AACjF,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAOW,WAAW;AAAA;AAAA,KAE1B,sBAAsB;AAAA;AAAA;AAG3B;","names":[]}

package/dist/{chunk-SHQFYZTD.js → chunk-7YQ4IYS2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-IFK3PVM7.js";
+} from "./chunk-3I7ASZN3.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -606,4 +606,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-SHQFYZTD.js.map
+//# sourceMappingURL=chunk-7YQ4IYS2.js.map