@remnic/core 9.3.688 → 9.3.690

package/dist/recall-pipeline-stages.d.ts

@@ -0,0 +1,167 @@
+import { EvidencePackItem } from './evidence-pack.js';
+
+/**
+ * Issue #1539 PR2 — the staged recall pipeline spine.
+ *
+ * The four recall pipelines (`targeted-fact-recall.ts`, `response-guidance-
+ * recall.ts`, `explicit-cue-recall.ts`, `event-order-recall.ts`) implement
+ * the same stage sequence — intent → candidate collection → dedup → rank →
+ * filter → slice → metadata insertion → token budgeting — with ~70%
+ * near-duplicate code. The most dangerous divergence is the sort
+ * comparator: guidance/targeted-fact sort `turnIndex` DESC (recency) while
+ * event-order sorts `turnIndex` ASC (chronological). The comparators are
+ * byte-identical except for this direction — copy-pasting into a new
+ * chronological pipeline silently inverts the ordering.
+ *
+ * This module centralizes the **dedup + score + threshold-filter + sort**
+ * stages behind one declared config object. Per-tier divergence (threshold
+ * value, sort direction, content transformation) becomes a declared config
+ * field instead of embedded code.
+ *
+ * **PR 2 scope:** extract the module with NO pipeline changes. PRs 3–6
+ * migrate each pipeline to call `unifiedDedupeAndRank` one at a time,
+ * re-running the characterization snapshots
+ * (`tests/recall-pipeline-unified.test.ts`) to verify byte-for-byte parity.
+ *
+ * Future PRs will add the remaining stages from the issue's Solution
+ * (`mergeAcrossLcmKeys`, `insertMetadata`) once the per-tier hooks are
+ * factored out of each pipeline.
+ *
+ * @see https://github.com/joshuaswarren/remnic/issues/1539
+ */
+
+/** A ranked evidence item: an `EvidencePackItem` with a computed `rank`. */
+interface RankedEvidenceItem extends EvidencePackItem {
+    rank: number;
+}
+/**
+ * Sort direction for the turn-index secondary key. This is the divergence
+ * issue #1539 identifies: relevance-ranked pipelines (targeted-fact,
+ * response-guidance) sort `turnIndex` DESC (recency — latest first); the
+ * chronological pipeline (event-order) sorts `turnIndex` ASC (earliest
+ * first). The rank primary key is ALWAYS DESC (higher rank first); only
+ * the `turnIndex` tiebreaker flips direction.
+ */
+type TurnIndexSortDirection = "desc" | "asc";
+/**
+ * Configuration for the unified dedup + score + threshold-filter + sort
+ * pass. Each pipeline declares its divergences as fields here instead of
+ * embedding them in pipeline-specific code.
+ *
+ * The issue's Solution defines the intended full config object
+ * (`RecallPipelineConfig`); this interface is extracted incrementally:
+ *   - PR 2 (this PR): dedup/score/threshold/sort only
+ *   - PRs 3–6: migrate each pipeline to consume the spine
+ *   - future: add `mergeAcrossLcmKeys`, `insertMetadata` once the per-tier
+ *     hooks are factored out of each pipeline
+ */
+interface UnifiedRankConfig<TIntent> {
+    /** The user query — passed to the scorer. */
+    query: string;
+    /**
+     * Per-tier intent classification result (already computed by the caller;
+     * intent classification stays per-tier because it is genuinely
+     * per-tier per issue #1539 Pitfall 1).
+     */
+    intents: TIntent[];
+    /**
+     * Score an item using its ORIGINAL (pre-transform) content. Higher = more
+     * relevant. The return value becomes the item's `rank`. For pipelines
+     * that don't score (explicit-cue), pass a constant scorer — the config
+     * makes the no-scoring policy explicit.
+     */
+    scoreEvidence: (item: EvidencePackItem, query: string, intents: TIntent[]) => number;
+    /**
+     * Optional content transformation applied to each surviving item's
+     * OUTPUT content (NOT to the content the scorer sees). Per-tier
+     * cue-appenders go here:
+     *   - targeted-fact: `appendNormalizedNumericCues`
+     *   - response-guidance: `appendGuidanceCues`
+     *   - event-order: `appendChronologicalCues`
+     *
+     * The dedup key uses the TRANSFORMED content. This is equivalent to
+     * deduping on original content for all existing pipelines because every
+     * transform is a deterministic append (same original → same transformed →
+     * same key; different originals → different transformed → different key).
+     */
+    transformContent?: (content: string, intents: TIntent[]) => string;
+    /**
+     * Whether to deduplicate by normalized (transformed) content in addition to
+     * id. Default `true` — matches targeted-fact, response-guidance, and
+     * explicit-cue, which all collapse later items sharing a normalized content
+     * key. Event-order sets this to `false`: its rank pass
+     * (`rankAndSelectEventOrderItems`) deduplicates by turn id only and keeps
+     * distinct turns even when two turns share the same cue-appended body
+     * (legitimate repeated turns in a chronological transcript). Making this a
+     * declared field prevents PR 6's migration from silently dropping valid
+     * turns (cursor bugbot a4299851).
+     */
+    dedupByContent?: boolean;
+    /**
+     * Items with `rank` below this threshold are dropped. `undefined` = no
+     * filter. Event-order declares `rankThreshold: 6` here instead of
+     * inlining an undocumented `.filter((item) => item.rank >= 6)` (the
+     * "hardcoded rank threshold that exists in no config and no other
+     * pipeline" from issue #1539's audit).
+     */
+    rankThreshold?: number;
+    /**
+     * Sort direction for the `turnIndex` secondary key.
+     *
+     * - `"desc"` (default): relevance-ranked pipelines (targeted-fact,
+     *   response-guidance) sort `turnIndex` DESC. Undefined `turnIndex`
+     *   falls to `-1` (bottom of a DESC list). Tertiary tiebreaker:
+     *   `score DESC`.
+     * - `"asc"`: the chronological pipeline (event-order) sorts `turnIndex`
+     *   ASC. Undefined `turnIndex` falls to `Number.MAX_SAFE_INTEGER`
+     *   (bottom of an ASC list). Tertiary tiebreaker: `content.localeCompare`.
+     *
+     * The rank primary key is ALWAYS DESC regardless of this setting.
+     */
+    turnIndexSortDirection?: TurnIndexSortDirection;
+}
+/**
+ * Deduplicate, score, threshold-filter, and sort evidence items under one
+ * unified policy.
+ *
+ * **Stage order** (matches every existing pipeline's rank/dedupe function):
+ *   1. **dedup** by `id` + normalized content (first-seen wins). The dedup
+ *      key uses transformed content if `transformContent` is declared.
+ *   2. **score** each surviving item on its ORIGINAL content (the transform
+ *      does not influence the score).
+ *   3. **threshold-filter**: drop items with `rank < rankThreshold` (if
+ *      declared).
+ *   4. **sort**: `rank DESC` → `turnIndex` (direction-configurable) →
+ *      tertiary tiebreaker (`score DESC` for relevance pipelines,
+ *      `content.localeCompare` for chronological pipelines).
+ *
+ * This function does NOT slice (`maxResults`), budget, or format — those
+ * stages remain per-tier because they interact with per-tier metadata
+ * insertion. The issue's Solution describes a future `insertMetadata` hook
+ * that will make budget-adjustment uniform; that lands in the per-tier
+ * migration PRs.
+ *
+ * @example
+ * // Relevance-ranked pipeline (targeted-fact shape):
+ * unifiedDedupeAndRank(items, {
+ *   query,
+ *   intents: [],
+ *   scoreEvidence: (item, q) => scoreTargetedFact(item, q),
+ *   transformContent: (content) => appendNormalizedNumericCues(content),
+ *   // turnIndexSortDirection defaults to "desc"
+ * });
+ *
+ * @example
+ * // Chronological pipeline (event-order shape):
+ * unifiedDedupeAndRank(items, {
+ *   query,
+ *   intents: [],
+ *   scoreEvidence: (item, q) => scoreEventOrder(item, q),
+ *   transformContent: (content) => appendChronologicalCues(content, query),
+ *   rankThreshold: 6,           // declared, not inlined
+ *   turnIndexSortDirection: "asc",
+ * });
+ */
+declare function unifiedDedupeAndRank<TIntent>(items: readonly EvidencePackItem[], config: UnifiedRankConfig<TIntent>): RankedEvidenceItem[];
+
+export { type RankedEvidenceItem, type TurnIndexSortDirection, type UnifiedRankConfig, unifiedDedupeAndRank };

package/dist/recall-pipeline-stages.js

@@ -0,0 +1,61 @@
+import "./chunk-PZ5AY32C.js";
+
+// src/recall-pipeline-stages.ts
+var UNDEFINED_TURN_INDEX_DESC_SENTINEL = -1;
+var UNDEFINED_TURN_INDEX_ASC_SENTINEL = Number.MAX_SAFE_INTEGER;
+function unifiedDedupeAndRank(items, config) {
+  const transformContent = config.transformContent ?? ((content) => content);
+  const direction = config.turnIndexSortDirection ?? "desc";
+  const dedupByContent = config.dedupByContent !== false;
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenContent = /* @__PURE__ */ new Set();
+  const survivors = [];
+  for (const item of items) {
+    const id = resolveItemId(item);
+    if (id && seenIds.has(id)) continue;
+    const transformedContent = transformContent(item.content, config.intents);
+    if (dedupByContent) {
+      const contentKey = transformedContent.toLowerCase().replace(/\s+/g, " ").trim();
+      if (seenContent.has(contentKey)) continue;
+      seenContent.add(contentKey);
+    }
+    if (id) seenIds.add(id);
+    survivors.push({ original: item, transformedContent });
+  }
+  const scored = survivors.map(({ original, transformedContent }) => ({
+    ...original,
+    content: transformedContent,
+    rank: config.scoreEvidence(original, config.query, config.intents)
+  }));
+  const filtered = typeof config.rankThreshold === "number" ? scored.filter((item) => item.rank >= config.rankThreshold) : scored;
+  return filtered.sort(makeComparator(direction));
+}
+function makeComparator(direction) {
+  if (direction === "asc") {
+    return (left, right) => {
+      if (right.rank !== left.rank) return right.rank - left.rank;
+      const leftTurn = typeof left.turnIndex === "number" ? left.turnIndex : UNDEFINED_TURN_INDEX_ASC_SENTINEL;
+      const rightTurn = typeof right.turnIndex === "number" ? right.turnIndex : UNDEFINED_TURN_INDEX_ASC_SENTINEL;
+      if (leftTurn !== rightTurn) return leftTurn - rightTurn;
+      return left.content.localeCompare(right.content);
+    };
+  }
+  return (left, right) => {
+    if (right.rank !== left.rank) return right.rank - left.rank;
+    const leftTurn = typeof left.turnIndex === "number" ? left.turnIndex : UNDEFINED_TURN_INDEX_DESC_SENTINEL;
+    const rightTurn = typeof right.turnIndex === "number" ? right.turnIndex : UNDEFINED_TURN_INDEX_DESC_SENTINEL;
+    if (rightTurn !== leftTurn) return rightTurn - leftTurn;
+    return (right.score ?? 0) - (left.score ?? 0);
+  };
+}
+function resolveItemId(item) {
+  if (item.id) return item.id;
+  if (item.sessionId && typeof item.turnIndex === "number") {
+    return `${item.sessionId}:${item.turnIndex}`;
+  }
+  return void 0;
+}
+export {
+  unifiedDedupeAndRank
+};
+//# sourceMappingURL=recall-pipeline-stages.js.map

package/dist/recall-pipeline-stages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-pipeline-stages.ts"],"sourcesContent":["/**\n * Issue #1539 PR2 — the staged recall pipeline spine.\n *\n * The four recall pipelines (`targeted-fact-recall.ts`, `response-guidance-\n * recall.ts`, `explicit-cue-recall.ts`, `event-order-recall.ts`) implement\n * the same stage sequence — intent → candidate collection → dedup → rank →\n * filter → slice → metadata insertion → token budgeting — with ~70%\n * near-duplicate code. The most dangerous divergence is the sort\n * comparator: guidance/targeted-fact sort `turnIndex` DESC (recency) while\n * event-order sorts `turnIndex` ASC (chronological). The comparators are\n * byte-identical except for this direction — copy-pasting into a new\n * chronological pipeline silently inverts the ordering.\n *\n * This module centralizes the **dedup + score + threshold-filter + sort**\n * stages behind one declared config object. Per-tier divergence (threshold\n * value, sort direction, content transformation) becomes a declared config\n * field instead of embedded code.\n *\n * **PR 2 scope:** extract the module with NO pipeline changes. PRs 3–6\n * migrate each pipeline to call `unifiedDedupeAndRank` one at a time,\n * re-running the characterization snapshots\n * (`tests/recall-pipeline-unified.test.ts`) to verify byte-for-byte parity.\n *\n * Future PRs will add the remaining stages from the issue's Solution\n * (`mergeAcrossLcmKeys`, `insertMetadata`) once the per-tier hooks are\n * factored out of each pipeline.\n *\n * @see https://github.com/joshuaswarren/remnic/issues/1539\n */\n\nimport type { EvidencePackItem } from \"./evidence-pack.js\";\n\n/** A ranked evidence item: an `EvidencePackItem` with a computed `rank`. */\nexport interface RankedEvidenceItem extends EvidencePackItem {\n  rank: number;\n}\n\n/**\n * Sort direction for the turn-index secondary key. This is the divergence\n * issue #1539 identifies: relevance-ranked pipelines (targeted-fact,\n * response-guidance) sort `turnIndex` DESC (recency — latest first); the\n * chronological pipeline (event-order) sorts `turnIndex` ASC (earliest\n * first). The rank primary key is ALWAYS DESC (higher rank first); only\n * the `turnIndex` tiebreaker flips direction.\n */\nexport type TurnIndexSortDirection = \"desc\" | \"asc\";\n\n/**\n * Configuration for the unified dedup + score + threshold-filter + sort\n * pass. Each pipeline declares its divergences as fields here instead of\n * embedding them in pipeline-specific code.\n *\n * The issue's Solution defines the intended full config object\n * (`RecallPipelineConfig`); this interface is extracted incrementally:\n *   - PR 2 (this PR): dedup/score/threshold/sort only\n *   - PRs 3–6: migrate each pipeline to consume the spine\n *   - future: add `mergeAcrossLcmKeys`, `insertMetadata` once the per-tier\n *     hooks are factored out of each pipeline\n */\nexport interface UnifiedRankConfig<TIntent> {\n  /** The user query — passed to the scorer. */\n  query: string;\n  /**\n   * Per-tier intent classification result (already computed by the caller;\n   * intent classification stays per-tier because it is genuinely\n   * per-tier per issue #1539 Pitfall 1).\n   */\n  intents: TIntent[];\n  /**\n   * Score an item using its ORIGINAL (pre-transform) content. Higher = more\n   * relevant. The return value becomes the item's `rank`. For pipelines\n   * that don't score (explicit-cue), pass a constant scorer — the config\n   * makes the no-scoring policy explicit.\n   */\n  scoreEvidence: (\n    item: EvidencePackItem,\n    query: string,\n    intents: TIntent[],\n  ) => number;\n  /**\n   * Optional content transformation applied to each surviving item's\n   * OUTPUT content (NOT to the content the scorer sees). Per-tier\n   * cue-appenders go here:\n   *   - targeted-fact: `appendNormalizedNumericCues`\n   *   - response-guidance: `appendGuidanceCues`\n   *   - event-order: `appendChronologicalCues`\n   *\n   * The dedup key uses the TRANSFORMED content. This is equivalent to\n   * deduping on original content for all existing pipelines because every\n   * transform is a deterministic append (same original → same transformed →\n   * same key; different originals → different transformed → different key).\n   */\n  transformContent?: (content: string, intents: TIntent[]) => string;\n  /**\n   * Whether to deduplicate by normalized (transformed) content in addition to\n   * id. Default `true` — matches targeted-fact, response-guidance, and\n   * explicit-cue, which all collapse later items sharing a normalized content\n   * key. Event-order sets this to `false`: its rank pass\n   * (`rankAndSelectEventOrderItems`) deduplicates by turn id only and keeps\n   * distinct turns even when two turns share the same cue-appended body\n   * (legitimate repeated turns in a chronological transcript). Making this a\n   * declared field prevents PR 6's migration from silently dropping valid\n   * turns (cursor bugbot a4299851).\n   */\n  dedupByContent?: boolean;\n  /**\n   * Items with `rank` below this threshold are dropped. `undefined` = no\n   * filter. Event-order declares `rankThreshold: 6` here instead of\n   * inlining an undocumented `.filter((item) => item.rank >= 6)` (the\n   * \"hardcoded rank threshold that exists in no config and no other\n   * pipeline\" from issue #1539's audit).\n   */\n  rankThreshold?: number;\n  /**\n   * Sort direction for the `turnIndex` secondary key.\n   *\n   * - `\"desc\"` (default): relevance-ranked pipelines (targeted-fact,\n   *   response-guidance) sort `turnIndex` DESC. Undefined `turnIndex`\n   *   falls to `-1` (bottom of a DESC list). Tertiary tiebreaker:\n   *   `score DESC`.\n   * - `\"asc\"`: the chronological pipeline (event-order) sorts `turnIndex`\n   *   ASC. Undefined `turnIndex` falls to `Number.MAX_SAFE_INTEGER`\n   *   (bottom of an ASC list). Tertiary tiebreaker: `content.localeCompare`.\n   *\n   * The rank primary key is ALWAYS DESC regardless of this setting.\n   */\n  turnIndexSortDirection?: TurnIndexSortDirection;\n}\n\n/**\n * Sentinel for undefined `turnIndex` when sorting DESC. `-1` sorts below\n * every real turn index (which are `>= 0`), so missing `turn_index` always\n * lands at the bottom of a DESC-ordered list — never wins ordering over a\n * real turn.\n */\nconst UNDEFINED_TURN_INDEX_DESC_SENTINEL = -1;\n\n/**\n * Sentinel for undefined `turnIndex` when sorting ASC.\n * `Number.MAX_SAFE_INTEGER` sorts above every real turn index, so missing\n * `turn_index` always lands at the bottom of an ASC-ordered list.\n */\nconst UNDEFINED_TURN_INDEX_ASC_SENTINEL = Number.MAX_SAFE_INTEGER;\n\n/**\n * Deduplicate, score, threshold-filter, and sort evidence items under one\n * unified policy.\n *\n * **Stage order** (matches every existing pipeline's rank/dedupe function):\n *   1. **dedup** by `id` + normalized content (first-seen wins). The dedup\n *      key uses transformed content if `transformContent` is declared.\n *   2. **score** each surviving item on its ORIGINAL content (the transform\n *      does not influence the score).\n *   3. **threshold-filter**: drop items with `rank < rankThreshold` (if\n *      declared).\n *   4. **sort**: `rank DESC` → `turnIndex` (direction-configurable) →\n *      tertiary tiebreaker (`score DESC` for relevance pipelines,\n *      `content.localeCompare` for chronological pipelines).\n *\n * This function does NOT slice (`maxResults`), budget, or format — those\n * stages remain per-tier because they interact with per-tier metadata\n * insertion. The issue's Solution describes a future `insertMetadata` hook\n * that will make budget-adjustment uniform; that lands in the per-tier\n * migration PRs.\n *\n * @example\n * // Relevance-ranked pipeline (targeted-fact shape):\n * unifiedDedupeAndRank(items, {\n *   query,\n *   intents: [],\n *   scoreEvidence: (item, q) => scoreTargetedFact(item, q),\n *   transformContent: (content) => appendNormalizedNumericCues(content),\n *   // turnIndexSortDirection defaults to \"desc\"\n * });\n *\n * @example\n * // Chronological pipeline (event-order shape):\n * unifiedDedupeAndRank(items, {\n *   query,\n *   intents: [],\n *   scoreEvidence: (item, q) => scoreEventOrder(item, q),\n *   transformContent: (content) => appendChronologicalCues(content, query),\n *   rankThreshold: 6,           // declared, not inlined\n *   turnIndexSortDirection: \"asc\",\n * });\n */\nexport function unifiedDedupeAndRank<TIntent>(\n  items: readonly EvidencePackItem[],\n  config: UnifiedRankConfig<TIntent>,\n): RankedEvidenceItem[] {\n  const transformContent = config.transformContent ?? ((content: string) => content);\n  const direction: TurnIndexSortDirection = config.turnIndexSortDirection ?? \"desc\";\n  const dedupByContent = config.dedupByContent !== false;\n\n  // Stage 1: dedup by id (+ normalized transformed content when enabled).\n  // First-seen wins, matching every existing pipeline. Event-order opts out\n  // of content dedup (dedupByContent: false) because it keeps distinct turns\n  // even when two turns share the same cue-appended body.\n  const seenIds = new Set<string>();\n  const seenContent = new Set<string>();\n  const survivors: Array<{ original: EvidencePackItem; transformedContent: string }> = [];\n\n  for (const item of items) {\n    const id = resolveItemId(item);\n    if (id && seenIds.has(id)) continue;\n\n    const transformedContent = transformContent(item.content, config.intents);\n    if (dedupByContent) {\n      const contentKey = transformedContent.toLowerCase().replace(/\\s+/g, \" \").trim();\n      if (seenContent.has(contentKey)) continue;\n      seenContent.add(contentKey);\n    }\n    if (id) seenIds.add(id);\n    survivors.push({ original: item, transformedContent });\n  }\n\n  // Stage 2: score on ORIGINAL content (transforms don't influence the score).\n  const scored: RankedEvidenceItem[] = survivors.map(({ original, transformedContent }) => ({\n    ...original,\n    content: transformedContent,\n    rank: config.scoreEvidence(original, config.query, config.intents),\n  }));\n\n  // Stage 3: threshold-filter (declared, not inlined).\n  const filtered =\n    typeof config.rankThreshold === \"number\"\n      ? scored.filter((item) => item.rank >= (config.rankThreshold as number))\n      : scored;\n\n  // Stage 4: sort.\n  // rank is ALWAYS DESC (higher rank first).\n  // turnIndex direction is configurable: DESC (relevance) or ASC (chronology).\n  // The tertiary tiebreaker follows the direction:\n  //   DESC → score DESC; ASC → content.localeCompare.\n  return filtered.sort(makeComparator(direction));\n}\n\n/**\n * Build the sort comparator for the configured direction. Extracted so the\n * comparator's two shapes (DESC / ASC) can be tested independently and so\n * the direction divergence is visible in ONE place.\n */\nfunction makeComparator(\n  direction: TurnIndexSortDirection,\n): (left: RankedEvidenceItem, right: RankedEvidenceItem) => number {\n  if (direction === \"asc\") {\n    // Chronological (event-order): rank DESC → turnIndex ASC → content localeCompare.\n    // Matches event-order-recall.ts:159-164 (rankedByScore sort) byte-for-byte.\n    return (left, right) => {\n      if (right.rank !== left.rank) return right.rank - left.rank;\n      const leftTurn =\n        typeof left.turnIndex === \"number\"\n          ? left.turnIndex\n          : UNDEFINED_TURN_INDEX_ASC_SENTINEL;\n      const rightTurn =\n        typeof right.turnIndex === \"number\"\n          ? right.turnIndex\n          : UNDEFINED_TURN_INDEX_ASC_SENTINEL;\n      if (leftTurn !== rightTurn) return leftTurn - rightTurn;\n      return left.content.localeCompare(right.content);\n    };\n  }\n  // Relevance-ranked (targeted-fact, response-guidance):\n  // rank DESC → turnIndex DESC → score DESC.\n  // Matches targeted-fact-recall.ts:239-245 and response-guidance-recall.ts:374-380\n  // byte-for-byte.\n  return (left, right) => {\n    if (right.rank !== left.rank) return right.rank - left.rank;\n    const leftTurn =\n      typeof left.turnIndex === \"number\"\n        ? left.turnIndex\n        : UNDEFINED_TURN_INDEX_DESC_SENTINEL;\n    const rightTurn =\n      typeof right.turnIndex === \"number\"\n        ? right.turnIndex\n        : UNDEFINED_TURN_INDEX_DESC_SENTINEL;\n    if (rightTurn !== leftTurn) return rightTurn - leftTurn;\n    return (right.score ?? 0) - (left.score ?? 0);\n  };\n}\n\n\n/**\n * Resolve an evidence item's id. Falls back to `sessionId:turnIndex` when\n * `id` is absent — mirrors every existing pipeline's fallback and\n * `evidence-pack.ts`'s `evidenceItemFallbackId`.\n */\nfunction resolveItemId(item: EvidencePackItem): string | undefined {\n  if (item.id) return item.id;\n  if (item.sessionId && typeof item.turnIndex === \"number\") {\n    return `${item.sessionId}:${item.turnIndex}`;\n  }\n  return undefined;\n}\n"],"mappings":";;;AAuIA,IAAM,qCAAqC;AAO3C,IAAM,oCAAoC,OAAO;AA4C1C,SAAS,qBACd,OACA,QACsB;AACtB,QAAM,mBAAmB,OAAO,qBAAqB,CAAC,YAAoB;AAC1E,QAAM,YAAoC,OAAO,0BAA0B;AAC3E,QAAM,iBAAiB,OAAO,mBAAmB;AAMjD,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,cAAc,oBAAI,IAAY;AACpC,QAAM,YAA+E,CAAC;AAEtF,aAAW,QAAQ,OAAO;AACxB,UAAM,KAAK,cAAc,IAAI;AAC7B,QAAI,MAAM,QAAQ,IAAI,EAAE,EAAG;AAE3B,UAAM,qBAAqB,iBAAiB,KAAK,SAAS,OAAO,OAAO;AACxE,QAAI,gBAAgB;AAClB,YAAM,aAAa,mBAAmB,YAAY,EAAE,QAAQ,QAAQ,GAAG,EAAE,KAAK;AAC9E,UAAI,YAAY,IAAI,UAAU,EAAG;AACjC,kBAAY,IAAI,UAAU;AAAA,IAC5B;AACA,QAAI,GAAI,SAAQ,IAAI,EAAE;AACtB,cAAU,KAAK,EAAE,UAAU,MAAM,mBAAmB,CAAC;AAAA,EACvD;AAGA,QAAM,SAA+B,UAAU,IAAI,CAAC,EAAE,UAAU,mBAAmB,OAAO;AAAA,IACxF,GAAG;AAAA,IACH,SAAS;AAAA,IACT,MAAM,OAAO,cAAc,UAAU,OAAO,OAAO,OAAO,OAAO;AAAA,EACnE,EAAE;AAGF,QAAM,WACJ,OAAO,OAAO,kBAAkB,WAC5B,OAAO,OAAO,CAAC,SAAS,KAAK,QAAS,OAAO,aAAwB,IACrE;AAON,SAAO,SAAS,KAAK,eAAe,SAAS,CAAC;AAChD;AAOA,SAAS,eACP,WACiE;AACjE,MAAI,cAAc,OAAO;AAGvB,WAAO,CAAC,MAAM,UAAU;AACtB,UAAI,MAAM,SAAS,KAAK,KAAM,QAAO,MAAM,OAAO,KAAK;AACvD,YAAM,WACJ,OAAO,KAAK,cAAc,WACtB,KAAK,YACL;AACN,YAAM,YACJ,OAAO,MAAM,cAAc,WACvB,MAAM,YACN;AACN,UAAI,aAAa,UAAW,QAAO,WAAW;AAC9C,aAAO,KAAK,QAAQ,cAAc,MAAM,OAAO;AAAA,IACjD;AAAA,EACF;AAKA,SAAO,CAAC,MAAM,UAAU;AACtB,QAAI,MAAM,SAAS,KAAK,KAAM,QAAO,MAAM,OAAO,KAAK;AACvD,UAAM,WACJ,OAAO,KAAK,cAAc,WACtB,KAAK,YACL;AACN,UAAM,YACJ,OAAO,MAAM,cAAc,WACvB,MAAM,YACN;AACN,QAAI,cAAc,SAAU,QAAO,YAAY;AAC/C,YAAQ,MAAM,SAAS,MAAM,KAAK,SAAS;AAAA,EAC7C;AACF;AAQA,SAAS,cAAc,MAA4C;AACjE,MAAI,KAAK,GAAI,QAAO,KAAK;AACzB,MAAI,KAAK,aAAa,OAAO,KAAK,cAAc,UAAU;AACxD,WAAO,GAAG,KAAK,SAAS,IAAI,KAAK,SAAS;AAAA,EAC5C;AACA,SAAO;AACT;","names":[]}

package/dist/schemas.d.ts

@@ -351,13 +351,13 @@ declare const ExtractedRelationshipSchema: z.ZodObject<{
     promptedByQuestion: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     source: string;
-    label: string;
     target: string;
+    label: string;
     promptedByQuestion?: string | null | undefined;
 }, {
     source: string;
-    label: string;
     target: string;
+    label: string;
     promptedByQuestion?: string | null | undefined;
 }>;
 declare const ProactiveExtractionResultSchema: z.ZodObject<{
@@ -620,13 +620,13 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
         promptedByQuestion: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }, {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }>, "many">>>;
 }, "strip", z.ZodTypeAny, {
@@ -674,8 +674,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
     profileUpdates: string[];
     relationships?: {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }[] | null | undefined;
 }, {
@@ -723,8 +723,8 @@ declare const ProactiveExtractionResultSchema: z.ZodObject<{
     profileUpdates: string[];
     relationships?: {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }[] | null | undefined;
 }>;
@@ -1002,13 +1002,13 @@ declare const ExtractionResultSchema: z.ZodObject<{
         promptedByQuestion: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }, {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }>, "many">>>;
 }, "strip", z.ZodTypeAny, {
@@ -1061,8 +1061,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
     profileUpdates: string[];
     relationships?: {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }[] | null | undefined;
     identityReflection?: string | null | undefined;
@@ -1116,8 +1116,8 @@ declare const ExtractionResultSchema: z.ZodObject<{
     profileUpdates: string[];
     relationships?: {
         source: string;
-        label: string;
         target: string;
+        label: string;
         promptedByQuestion?: string | null | undefined;
     }[] | null | undefined;
     identityReflection?: string | null | undefined;

package/dist/search/factory.js

@@ -2,19 +2,19 @@ import {
   createConversationIndexRuntime,
   createConversationSearchBackend,
   createSearchBackend
-} from "../chunk-2KAYTPPT.js";
+} from "../chunk-TYF3D4MS.js";
+import "../chunk-5CEJH5ZN.js";
 import "../chunk-WRFKZEO6.js";
 import "../chunk-CYEPCZN5.js";
 import "../chunk-LQ6JI4VH.js";
 import "../chunk-SANZHXY2.js";
-import "../chunk-EHISUJFN.js";
-import "../chunk-5CEJH5ZN.js";
 import "../chunk-AER6MT24.js";
+import "../chunk-EHISUJFN.js";
 import "../chunk-CINZGPSJ.js";
-import "../chunk-DCWIQFNA.js";
-import "../chunk-XBZQRZ6G.js";
+import "../chunk-ZUDM75KG.js";
 import "../chunk-KCQA46NR.js";
 import "../chunk-SJHM6I4J.js";
+import "../chunk-XBZQRZ6G.js";
 import "../chunk-K43PI6DQ.js";
 import "../chunk-YNQ6DFSV.js";
 import "../chunk-O75CRYGF.js";

package/dist/search/index.js

@@ -2,7 +2,10 @@ import {
   createConversationIndexRuntime,
   createConversationSearchBackend,
   createSearchBackend
-} from "../chunk-2KAYTPPT.js";
+} from "../chunk-TYF3D4MS.js";
+import {
+  LanceDbBackend
+} from "../chunk-5CEJH5ZN.js";
 import {
   MeilisearchBackend
 } from "../chunk-WRFKZEO6.js";
@@ -15,20 +18,17 @@ import {
 import {
   RemoteSearchBackend
 } from "../chunk-SANZHXY2.js";
-import {
-  EmbedHelper
-} from "../chunk-EHISUJFN.js";
-import {
-  LanceDbBackend
-} from "../chunk-5CEJH5ZN.js";
 import {
   scanMemoryDir
 } from "../chunk-AER6MT24.js";
+import {
+  EmbedHelper
+} from "../chunk-EHISUJFN.js";
 import "../chunk-CINZGPSJ.js";
-import "../chunk-DCWIQFNA.js";
-import "../chunk-XBZQRZ6G.js";
+import "../chunk-ZUDM75KG.js";
 import "../chunk-KCQA46NR.js";
 import "../chunk-SJHM6I4J.js";
+import "../chunk-XBZQRZ6G.js";
 import "../chunk-K43PI6DQ.js";
 import "../chunk-YNQ6DFSV.js";
 import "../chunk-O75CRYGF.js";

package/dist/semantic-consolidation.js

@@ -7,17 +7,18 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-GS55WYRL.js";
-import "./chunk-QANVLERJ.js";
+} from "./chunk-PHZKALOE.js";
+import "./chunk-UPIBE2DK.js";
 import "./chunk-UUH4YQOF.js";
 import {
   resolveExtensionsRoot
 } from "./chunk-JLNBQWZ2.js";
 import "./chunk-3UXOZBHV.js";
-import "./chunk-BLIWOONZ.js";
+import "./chunk-CUNTLEJP.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-SVOZFLIQ.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-NGFEWFNK.js";
 import "./chunk-MB5RSUW6.js";

package/dist/semantic-rule-promotion.js

@@ -1,11 +1,12 @@
 import {
   promoteSemanticRuleFromMemory,
   setSemanticRulePromotionTestHooks
-} from "./chunk-UTYBJR7M.js";
-import "./chunk-BLIWOONZ.js";
+} from "./chunk-SB6CQTKP.js";
+import "./chunk-CUNTLEJP.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-SVOZFLIQ.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-NGFEWFNK.js";
 import "./chunk-MB5RSUW6.js";

package/dist/semantic-rule-verifier.js

@@ -1,11 +1,12 @@
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-PH3HOKYW.js";
-import "./chunk-BLIWOONZ.js";
+} from "./chunk-67MMWC74.js";
+import "./chunk-CUNTLEJP.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-SVOZFLIQ.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-NGFEWFNK.js";
 import "./chunk-MB5RSUW6.js";

package/dist/storage.d.ts

@@ -2,6 +2,7 @@ import { VersioningConfig } from './page-versioning.js';
 import { ConsolidationOperator } from './consolidation-operator.js';
 import { P as PluginConfig, h as MemoryStatus, M as MemoryCategory, I as ImportanceScore, i as MemoryLink, j as MemoryFrontmatter, g as MemoryFile, E as EntityStructuredSection, k as BufferState, l as MetaState, m as MemoryActionEvent, n as MemoryLifecycleEvent, o as BufferSurpriseEvent, B as BehaviorSignalEvent, C as CompressionGuidelineOptimizerState, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, r as ContinuityIncidentCloseInput, s as ContinuityImprovementLoop, t as ContinuityLoopUpsertInput, u as ContinuityLoopReviewInput, F as FileHygieneConfig, v as EntityRelationship, w as EntityActivityEntry, x as EntityFile, y as AccessTrackingEntry, z as MemoryProjectionCurrentState, D as MemorySummary, T as TopicScore } from './types-Dm5xxVrr.js';
 import { ProjectedMemoryBrowseOptions, ProjectedMemoryBrowsePage, readProjectedGovernanceRecord } from './memory-projection-store.js';
+export { stripAttributesSuffix } from './structured-attributes.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 import './maintenance/memory-governance.js';
@@ -84,32 +85,7 @@ declare class ContentHashIndex {
     /** Normalize content and compute SHA-256 hash. */
     static computeHash(content: string): string;
 }
-/**
- * Render a structured-attributes map into a stable, canonical string fragment
- * suitable for appending to enriched memory content before hashing.
- *
- * Normalization rules:
- *   - Keys are trimmed and lowercased (values are trimmed but preserve case)
- *   - Key-value pairs are sorted alphabetically by normalized key
- *   - Pairs are joined with "; " and rendered as "key: value"
- *
- * Using this helper at BOTH the write path (enrichedContent) and the
- * dedup-lookup path (dedupContent) guarantees identical output regardless of
- * the insertion order or casing used by the caller.
- *
- * @example
- *   normalizeAttributePairs({ foo: "bar", BAZ: "qux" })
- *   // → "baz: qux; foo: bar"
- */
-/**
- * Remove the "[Attributes: ...]" suffix `writeMemory` appends to the
- * stored body when structuredAttributes are present, yielding the raw
- * fact text for content comparison. Inverse companion of
- * `normalizeAttributePairs` enrichment. String operations, not regex —
- * CodeQL js/polynomial-redos on a suffix-anchored pattern over
- * library-supplied content.
- */
-declare function stripAttributesSuffix(content: string): string;
+
 declare function normalizeAttributePairs(pairs: Record<string, string>): string;
 declare function compareEntityTimestamps(left?: string, right?: string): number;
 declare function fingerprintEntityStructuredFacts(entity: Pick<EntityFile, "structuredSections">): string | undefined;
@@ -893,4 +869,4 @@ declare class StorageManager {
     private appendGeneratedMemoryLifecycleEventFailOpen;
 }
 
-export { ContentHashIndex, type MemoryLifecycleEventWriteOptions, type ReextractJobRequest, StorageManager, compareEntityTimestamps, fingerprintEntityStructuredFacts, isEntitySynthesisStale, normalizeAttributePairs, normalizeEntityName, parseEntityFile, serializeEntityFile, stripAttributesSuffix };
+export { ContentHashIndex, type MemoryLifecycleEventWriteOptions, type ReextractJobRequest, StorageManager, compareEntityTimestamps, fingerprintEntityStructuredFacts, isEntitySynthesisStale, normalizeAttributePairs, normalizeEntityName, parseEntityFile, serializeEntityFile };

package/dist/storage.js

@@ -7,12 +7,14 @@ import {
   normalizeAttributePairs,
   normalizeEntityName,
   parseEntityFile,
-  serializeEntityFile,
-  stripAttributesSuffix
-} from "./chunk-BLIWOONZ.js";
+  serializeEntityFile
+} from "./chunk-CUNTLEJP.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-SVOZFLIQ.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-NGFEWFNK.js";
 import "./chunk-MB5RSUW6.js";

package/dist/structured-attributes.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared helpers for the `\n[Attributes: …]` enrichment suffix that
+ * `writeMemory` appends to a stored body when `structuredAttributes` are
+ * present.
+ *
+ * Extracted here (out of `storage.ts`) so every reader — the storage
+ * manager, the wearable service, and the coding surfaces — strips the suffix
+ * with ONE definition. Previously `coding/architecture-surfaces.ts` carried a
+ * weaker local copy that only checked the trailing `]`, which could truncate
+ * card markdown that legitimately ends in a `[Attributes: …]` line (cursor
+ * review: duplicate attribute suffix stripper).
+ *
+ * String operations, not regex — CodeQL `js/polynomial-redos` flags
+ * suffix-anchored patterns over library-supplied content.
+ */
+/**
+ * Remove the `[Attributes: …]` suffix `writeMemory` appends to the stored
+ * body when structuredAttributes are present, yielding the raw fact/card text
+ * for content comparison or client display. Inverse companion of
+ * `normalizeAttributePairs` enrichment in `storage.ts`.
+ *
+ * Returns the stripped (trimmed) body when the marker opens the final
+ * non-empty line and its inner payload contains no premature `]` or newline
+ * (mirrors the exact shape `normalizeAttributePairs` emits). Otherwise
+ * returns the trimmed input unchanged — never truncates legitimate content.
+ */
+declare function stripAttributesSuffix(content: string): string;
+
+export { stripAttributesSuffix };

package/dist/structured-attributes.js

@@ -0,0 +1,8 @@
+import {
+  stripAttributesSuffix
+} from "./chunk-SVOZFLIQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  stripAttributesSuffix
+};
+//# sourceMappingURL=structured-attributes.js.map

package/dist/structured-attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/temporal-supersession.d.ts

@@ -8,6 +8,7 @@ import './memory-projection-store.js';
 import './maintenance/memory-governance.js';
 import './runtime/better-sqlite.js';
 import 'better-sqlite3';
+import './structured-attributes.js';
 
 /**
  * Temporal Supersession (issue #375)

package/dist/tier-migration.d.ts

@@ -10,6 +10,7 @@ import './memory-projection-store.js';
 import './maintenance/memory-governance.js';
 import './runtime/better-sqlite.js';
 import 'better-sqlite3';
+import './structured-attributes.js';
 import './lifecycle.js';
 
 interface TierMigrationRequest {

package/dist/verified-recall.js

@@ -1,12 +1,13 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-4FE2K57M.js";
+} from "./chunk-RTFAZOIR.js";
 import "./chunk-7FL4CNPV.js";
-import "./chunk-BLIWOONZ.js";
+import "./chunk-CUNTLEJP.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-5GPPACXK.js";
+import "./chunk-SVOZFLIQ.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-NGFEWFNK.js";
 import "./chunk-MB5RSUW6.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.688",
+  "version": "9.3.690",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2931,7 +2931,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.688"
+    "@remnic/coding-graph": "^9.3.690"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-boundary.ts

@@ -34,7 +34,8 @@ export type OperationName =
   | "memory_get"
   | "memory_search"
   | "memory_store"
-  | "coding_decision";
+  | "coding_decision"
+  | "coding_architecture";
 
 // ---------------------------------------------------------------------------
 // Operation context — what every handler receives