@remnic/core 9.3.688 → 9.3.690

package/src/recall-pipeline-stages.test.ts

@@ -0,0 +1,269 @@
+// Issue #1539 PR2 — unit tests for the recall pipeline spine module.
+//
+// These tests verify `unifiedDedupeAndRank` produces the correct results for
+// each declared divergence dimension, WITHOUT changing any existing pipeline.
+// PRs 3–6 will migrate each pipeline to call this function; at that point the
+// characterization snapshots (tests/recall-pipeline-unified.test.ts) verify
+// end-to-end byte-for-byte parity.
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { EvidencePackItem } from "./evidence-pack.js";
+import {
+  unifiedDedupeAndRank,
+  type RankedEvidenceItem,
+} from "./recall-pipeline-stages.js";
+
+const NO_INTENTS: never[] = [];
+const constantScorer = (_item: EvidencePackItem): number => 10;
+
+function item(
+  turnIndex: number,
+  content: string,
+  overrides: Partial<EvidencePackItem> = {},
+): EvidencePackItem {
+  return {
+    id: `s1:${turnIndex}`,
+    sessionId: "s1",
+    turnIndex,
+    role: "user",
+    content,
+    ...overrides,
+  };
+}
+
+test("unifiedDedupeAndRank: dedup collapses identical ids", () => {
+  const items = [
+    item(3, "Content A"),
+    item(3, "Content A"), // same id → deduped
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+  });
+  assert.equal(result.length, 1);
+  assert.equal(result[0]?.turnIndex, 3);
+});
+
+test("unifiedDedupeAndRank: dedup collapses identical normalized content under different ids", () => {
+  const items = [
+    item(10, "My monthly expenses are $2,400."),
+    item(11, "MY   MONTHLY   EXPENSES ARE $2,400."), // same normalized content
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+  });
+  assert.equal(result.length, 1, "expected content dedup to collapse the two items");
+  assert.equal(result[0]?.turnIndex, 10, "first-seen wins");
+});
+
+test("unifiedDedupeAndRank: DESC sort (default) orders turnIndex descending on score ties", () => {
+  const items = [
+    item(2, "Oldest"),
+    item(5, "Middle"),
+    item(9, "Newest"),
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer, // all tied → turnIndex DESC
+  });
+  const turns = result.map((r) => r.turnIndex);
+  assert.deepEqual(turns, [9, 5, 2]);
+});
+
+test("unifiedDedupeAndRank: ASC sort orders turnIndex ascending on score ties", () => {
+  const items = [
+    item(30, "Latest"),
+    item(10, "Earliest"),
+    item(20, "Middle"),
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+    turnIndexSortDirection: "asc",
+  });
+  const turns = result.map((r) => r.turnIndex);
+  assert.deepEqual(turns, [10, 20, 30]);
+});
+
+test("unifiedDedupeAndRank: rank primary key is always DESC regardless of turnIndex direction", () => {
+  const items = [
+    item(1, "Low rank", { score: 0 }),
+    item(2, "High rank", { score: 0 }),
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: (i) => (i.turnIndex === 2 ? 100 : 1),
+    turnIndexSortDirection: "asc",
+  });
+  // rank DESC wins over turnIndex ASC: turn 2 (rank 100) comes first despite ASC.
+  assert.equal(result[0]?.turnIndex, 2);
+  assert.equal(result[1]?.turnIndex, 1);
+});
+
+test("unifiedDedupeAndRank: rankThreshold drops items below the declared threshold", () => {
+  const items = [
+    item(1, "Weak", { score: 0 }),
+    item(2, "Strong", { score: 0 }),
+    item(3, "Medium", { score: 0 }),
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: (i) => {
+      if (i.turnIndex === 1) return 3;
+      if (i.turnIndex === 2) return 10;
+      return 6;
+    },
+    rankThreshold: 6,
+  });
+  const turns = result.map((r) => r.turnIndex).sort((a, b) => (a ?? 0) - (b ?? 0));
+  assert.deepEqual(turns, [2, 3], "turn 1 (rank 3) is below threshold 6 and dropped");
+});
+
+test("unifiedDedupeAndRank: transformContent is applied to output but NOT to scorer input", () => {
+  const items = [item(5, "original content")];
+  let scorerSawTransformed = false;
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: (i) => {
+      if (i.content.includes("APPENDED CUE")) scorerSawTransformed = true;
+      return 5;
+    },
+    transformContent: (content) => `${content}\nAPPENDED CUE`,
+  });
+  assert.equal(scorerSawTransformed, false, "scorer must see ORIGINAL content");
+  assert.ok(result[0]?.content.includes("APPENDED CUE"), "output must have transformed content");
+});
+
+test("unifiedDedupeAndRank: undefined turnIndex sorts to the bottom of DESC (-1 sentinel)", () => {
+  const items = [
+    item(5, "Has turn"),
+    { id: "s1:x", sessionId: "s1", role: "user", content: "No turn" }, // no turnIndex
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+    // default DESC
+  });
+  assert.equal(result[1]?.id, "s1:x", "undefined-turnIndex item sorts last in DESC");
+});
+
+test("unifiedDedupeAndRank: undefined turnIndex sorts to the bottom of ASC (MAX sentinel)", () => {
+  const items = [
+    item(5, "Has turn"),
+    { id: "s1:x", sessionId: "s1", role: "user", content: "No turn" },
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+    turnIndexSortDirection: "asc",
+  });
+  assert.equal(result[1]?.id, "s1:x", "undefined-turnIndex item sorts last in ASC");
+});
+
+test("unifiedDedupeAndRank: DESC tertiary tiebreaker is score DESC", () => {
+  // Same rank (all tied via constantScorer) AND same turnIndex → score breaks the tie.
+  const items = [
+    item(5, "Low score", { score: 10 }),
+    item(5, "High score", { score: 90 }), // same turn, deduped by content? No — different content
+  ];
+  // Wait — both have turn 5 so same id "s1:5" → second is deduped. Use different sessions.
+  const itemsDistinct: EvidencePackItem[] = [
+    { id: "s1:5", sessionId: "s1", turnIndex: 5, role: "user", content: "A", score: 10 },
+    { id: "s2:5", sessionId: "s2", turnIndex: 5, role: "user", content: "B", score: 90 },
+  ];
+  const result = unifiedDedupeAndRank(itemsDistinct, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer, // rank tied → turnIndex tied → score DESC
+  });
+  assert.equal(result[0]?.id, "s2:5", "higher score (90) ranks first on DESC tertiary");
+  assert.equal(result[1]?.id, "s1:5");
+});
+
+test("unifiedDedupeAndRank: ASC tertiary tiebreaker is content.localeCompare", () => {
+  const items: EvidencePackItem[] = [
+    { id: "s2:5", sessionId: "s2", turnIndex: 5, role: "user", content: "Banana" },
+    { id: "s1:5", sessionId: "s1", turnIndex: 5, role: "user", content: "Apple" },
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer, // rank tied → turnIndex tied → content localeCompare
+    turnIndexSortDirection: "asc",
+  });
+  assert.equal(result[0]?.content, "Apple", "localeCompare ASC: Apple < Banana");
+  assert.equal(result[1]?.content, "Banana");
+});
+
+test("unifiedDedupeAndRank: RankedEvidenceItem carries the computed rank", () => {
+  const items = [item(1, "content")];
+  const result: RankedEvidenceItem[] = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: () => 42,
+  });
+  assert.equal(result[0]?.rank, 42);
+});
+
+test("unifiedDedupeAndRank: fallback id uses sessionId:turnIndex when id is absent", () => {
+  const items: EvidencePackItem[] = [
+    { sessionId: "s1", turnIndex: 7, role: "user", content: "No explicit id" },
+    { sessionId: "s1", turnIndex: 7, role: "user", content: "Same fallback id → deduped" },
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+  });
+  assert.equal(result.length, 1, "fallback id dedup must collapse the two items");
+});
+
+test("unifiedDedupeAndRank: dedupByContent false keeps distinct ids with identical content (event-order shape)", () => {
+  // Event-order's rankAndSelectEventOrderItems deduplicates by turn id only and
+  // keeps distinct turns even when two turns share the same cue-appended body.
+  // The spine must express that as a declared config field so PR 6's migration
+  // does not silently drop valid turns (cursor bugbot a4299851).
+  const items: EvidencePackItem[] = [
+    item(1, "What time is it?", { id: "s1:1" }),
+    item(5, "What time is it?", { id: "s1:5" }),
+  ];
+  const result = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+    dedupByContent: false,
+  });
+  assert.equal(result.length, 2, "distinct ids with identical content must both survive when dedupByContent is false");
+});
+
+test("unifiedDedupeAndRank: dedupByContent true (default) still collapses identical content under different ids", () => {
+  const items: EvidencePackItem[] = [
+    item(1, "Duplicate body", { id: "s1:1" }),
+    item(2, "Duplicate body", { id: "s1:2" }),
+  ];
+  const resultDefault = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+  });
+  assert.equal(resultDefault.length, 1, "default dedupByContent collapses identical content");
+  const resultExplicit = unifiedDedupeAndRank(items, {
+    query: "q",
+    intents: NO_INTENTS,
+    scoreEvidence: constantScorer,
+    dedupByContent: true,
+  });
+  assert.equal(resultExplicit.length, 1, "explicit dedupByContent: true collapses identical content");
+});

package/src/recall-pipeline-stages.ts

@@ -0,0 +1,294 @@
+/**
+ * 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
+ */
+
+import type { EvidencePackItem } from "./evidence-pack.js";
+
+/** A ranked evidence item: an `EvidencePackItem` with a computed `rank`. */
+export 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.
+ */
+export 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
+ */
+export 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;
+}
+
+/**
+ * Sentinel for undefined `turnIndex` when sorting DESC. `-1` sorts below
+ * every real turn index (which are `>= 0`), so missing `turn_index` always
+ * lands at the bottom of a DESC-ordered list — never wins ordering over a
+ * real turn.
+ */
+const UNDEFINED_TURN_INDEX_DESC_SENTINEL = -1;
+
+/**
+ * Sentinel for undefined `turnIndex` when sorting ASC.
+ * `Number.MAX_SAFE_INTEGER` sorts above every real turn index, so missing
+ * `turn_index` always lands at the bottom of an ASC-ordered list.
+ */
+const UNDEFINED_TURN_INDEX_ASC_SENTINEL = Number.MAX_SAFE_INTEGER;
+
+/**
+ * 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",
+ * });
+ */
+export function unifiedDedupeAndRank<TIntent>(
+  items: readonly EvidencePackItem[],
+  config: UnifiedRankConfig<TIntent>,
+): RankedEvidenceItem[] {
+  const transformContent = config.transformContent ?? ((content: string) => content);
+  const direction: TurnIndexSortDirection = config.turnIndexSortDirection ?? "desc";
+  const dedupByContent = config.dedupByContent !== false;
+
+  // Stage 1: dedup by id (+ normalized transformed content when enabled).
+  // First-seen wins, matching every existing pipeline. Event-order opts out
+  // of content dedup (dedupByContent: false) because it keeps distinct turns
+  // even when two turns share the same cue-appended body.
+  const seenIds = new Set<string>();
+  const seenContent = new Set<string>();
+  const survivors: Array<{ original: EvidencePackItem; transformedContent: string }> = [];
+
+  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 });
+  }
+
+  // Stage 2: score on ORIGINAL content (transforms don't influence the score).
+  const scored: RankedEvidenceItem[] = survivors.map(({ original, transformedContent }) => ({
+    ...original,
+    content: transformedContent,
+    rank: config.scoreEvidence(original, config.query, config.intents),
+  }));
+
+  // Stage 3: threshold-filter (declared, not inlined).
+  const filtered =
+    typeof config.rankThreshold === "number"
+      ? scored.filter((item) => item.rank >= (config.rankThreshold as number))
+      : scored;
+
+  // Stage 4: sort.
+  // rank is ALWAYS DESC (higher rank first).
+  // turnIndex direction is configurable: DESC (relevance) or ASC (chronology).
+  // The tertiary tiebreaker follows the direction:
+  //   DESC → score DESC; ASC → content.localeCompare.
+  return filtered.sort(makeComparator(direction));
+}
+
+/**
+ * Build the sort comparator for the configured direction. Extracted so the
+ * comparator's two shapes (DESC / ASC) can be tested independently and so
+ * the direction divergence is visible in ONE place.
+ */
+function makeComparator(
+  direction: TurnIndexSortDirection,
+): (left: RankedEvidenceItem, right: RankedEvidenceItem) => number {
+  if (direction === "asc") {
+    // Chronological (event-order): rank DESC → turnIndex ASC → content localeCompare.
+    // Matches event-order-recall.ts:159-164 (rankedByScore sort) byte-for-byte.
+    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);
+    };
+  }
+  // Relevance-ranked (targeted-fact, response-guidance):
+  // rank DESC → turnIndex DESC → score DESC.
+  // Matches targeted-fact-recall.ts:239-245 and response-guidance-recall.ts:374-380
+  // byte-for-byte.
+  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);
+  };
+}
+
+
+/**
+ * Resolve an evidence item's id. Falls back to `sessionId:turnIndex` when
+ * `id` is absent — mirrors every existing pipeline's fallback and
+ * `evidence-pack.ts`'s `evidenceItemFallbackId`.
+ */
+function resolveItemId(item: EvidencePackItem): string | undefined {
+  if (item.id) return item.id;
+  if (item.sessionId && typeof item.turnIndex === "number") {
+    return `${item.sessionId}:${item.turnIndex}`;
+  }
+  return undefined;
+}

package/src/storage.ts

@@ -1175,26 +1175,12 @@ export class ContentHashIndex {
  *   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.
- */
-export function stripAttributesSuffix(content: string): string {
-  const trimmed = content.trimEnd();
-  if (!trimmed.endsWith("]")) return content.trim();
-  const marker = "\n[Attributes: ";
-  const markerIndex = trimmed.lastIndexOf(marker);
-  if (markerIndex === -1) return content.trim();
-  // The block must be the FINAL line and contain no "]" before the
-  // closing bracket (mirrors the shape normalizeAttributePairs emits).
-  const inner = trimmed.slice(markerIndex + marker.length, -1);
-  if (inner.includes("]") || inner.includes("\n")) return content.trim();
-  return trimmed.slice(0, markerIndex).trim();
-}
+// `stripAttributesSuffix` now lives in ./structured-attributes.ts (shared with
+// the coding surfaces + wearable service). Imported here so internal callers
+// (snapshotBeforeWrite, snapshotForProvenance) resolve, and re-exported to
+// keep the public storage API stable for existing callers (wearables, dist).
+import { stripAttributesSuffix } from "./structured-attributes.js";
+export { stripAttributesSuffix };
 
 export function normalizeAttributePairs(pairs: Record<string, string>): string {
   return Object.entries(pairs)

package/src/structured-attributes.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+export function stripAttributesSuffix(content: string): string {
+  const trimmed = content.trimEnd();
+  if (!trimmed.endsWith("]")) return content.trim();
+  const marker = "\n[Attributes: ";
+  const markerIndex = trimmed.lastIndexOf(marker);
+  if (markerIndex === -1) return content.trim();
+  // The block must be the FINAL line and contain no "]" before the
+  // closing bracket (mirrors the shape normalizeAttributePairs emits).
+  const inner = trimmed.slice(markerIndex + marker.length, -1);
+  if (inner.includes("]") || inner.includes("\n")) return content.trim();
+  return trimmed.slice(0, markerIndex).trim();
+}