@remnic/core 9.52.2 → 9.54.0

package/dist/{chunk-NDAH7BJ5.js → chunk-HVP33QVW.js}

@@ -110,6 +110,55 @@ async function saveCorrectionsFile(memoryDir, rules) {
   }
 }
 
+// src/wearables/text-language.ts
+var PREFIXABLE_EDGE_CHAR = /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Hangul}\p{N}]/u;
+var SUFFIXABLE_EDGE_CHAR = /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Script=Arabic}\p{Script=Hebrew}\p{N}\p{M}]/u;
+var PROCLITIC_EDGE_CHAR = /[\p{Script=Arabic}\p{Script=Hebrew}]/u;
+var PROCLITIC_LETTERS = "\u0648\u0641\u0628\u0643\u0644\u0633\u05D4\u05D5\u05DB\u05DC\u05DE\u05E9\u05D1";
+var BOUNDARY_LOOKBEHIND = "(?<![\\p{L}\\p{M}\\p{N}])";
+var BOUNDARY_LOOKAHEAD = "(?![\\p{L}\\p{M}\\p{N}])";
+var PROCLITIC_LOOKBEHIND = `(?:${BOUNDARY_LOOKBEHIND}|(?<=${BOUNDARY_LOOKBEHIND}[${PROCLITIC_LETTERS}]))`;
+var HAS_KANA = /[\p{Script=Hiragana}\p{Script=Katakana}]/u;
+var HAS_HAN = /\p{Script=Han}/u;
+var HAS_HANGUL = /\p{Script=Hangul}/u;
+var HAS_ARABIC = /\p{Script=Arabic}/u;
+var HAS_CYRILLIC = /\p{Script=Cyrillic}/u;
+function foldForMatching(text) {
+  return text.normalize("NFC").replace(/[\u0131\u0130I]/g, "i");
+}
+function detectScriptHints(text) {
+  const hints = ["latin"];
+  if (HAS_KANA.test(text)) hints.push("japanese");
+  else if (HAS_HAN.test(text)) hints.push("han");
+  if (HAS_HANGUL.test(text)) hints.push("korean");
+  if (HAS_ARABIC.test(text)) hints.push("arabic");
+  if (HAS_CYRILLIC.test(text)) hints.push("cyrillic");
+  return hints;
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPhraseMatcher(phrases) {
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of phrases) {
+    if (typeof raw !== "string") continue;
+    const phrase = foldForMatching(raw.trim());
+    if (phrase.length === 0) continue;
+    const key = phrase.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const characters = Array.from(phrase);
+    const body = phrase.split(/\s+/).map((word) => escapeRegExp2(word)).join("\\s+");
+    const first = characters[0];
+    const lead = PROCLITIC_EDGE_CHAR.test(first) ? PROCLITIC_LOOKBEHIND : PREFIXABLE_EDGE_CHAR.test(first) ? BOUNDARY_LOOKBEHIND : "";
+    const tail = SUFFIXABLE_EDGE_CHAR.test(characters[characters.length - 1]) ? BOUNDARY_LOOKAHEAD : "";
+    parts.push(`${lead}${body}${tail}`);
+  }
+  if (parts.length === 0) return null;
+  return new RegExp(parts.join("|"), "iu");
+}
+
 // src/wearables/redaction.ts
 var REDACTION_PLACEHOLDER = "[redacted]";
 var BUILT_IN_PATTERNS = [
@@ -163,14 +212,57 @@ function compileRedactionPatterns(patterns) {
     }
   });
 }
-var OFF_THE_RECORD = /\boff\s+the\s+record\b/i;
-var BACK_ON_THE_RECORD = /\b(?:back\s+)?on\s+the\s+record\b/i;
-function applyOffTheRecord(conversation) {
+var BUILT_IN_OFF_THE_RECORD_START = [
+  "off the record",
+  "fuera de registro",
+  "extraoficialmente",
+  "fora de registro",
+  "fora do registro",
+  "hors micro",
+  "nicht f\xFCrs protokoll",
+  "nicht f\xFCr das protokoll",
+  "fuori registro",
+  "\u30AA\u30D5\u30EC\u30B3",
+  "\uC624\uD504\uB354\uB808\uCF54\uB4DC",
+  "\u4E0D\u8981\u8BB0\u5F55",
+  "\u043D\u0435 \u0434\u043B\u044F \u043F\u0440\u043E\u0442\u043E\u043A\u043E\u043B\u0430",
+  "\u0628\u062F\u0648\u0646 \u062A\u0633\u062C\u064A\u0644"
+];
+var BUILT_IN_OFF_THE_RECORD_END = [
+  "back on the record",
+  "on the record",
+  "de nuevo en registro",
+  "de volta ao registro",
+  "wieder f\xFCrs protokoll",
+  "wieder f\xFCr das protokoll",
+  "\u30AA\u30F3\u30EC\u30B3",
+  "\uC628\uB354\uB808\uCF54\uB4DC"
+];
+function compileOffTheRecordMarkers(settings) {
+  const useBuiltIns = settings?.useBuiltIns !== false;
+  const start = [
+    ...useBuiltIns ? BUILT_IN_OFF_THE_RECORD_START : [],
+    ...settings?.start ?? []
+  ];
+  const end = [
+    ...useBuiltIns ? BUILT_IN_OFF_THE_RECORD_END : [],
+    ...settings?.end ?? []
+  ];
+  return {
+    start: buildPhraseMatcher(start),
+    end: buildPhraseMatcher(end)
+  };
+}
+function applyOffTheRecord(conversation, markers = compileOffTheRecordMarkers()) {
+  if (!markers.start) {
+    return { conversation, droppedSegments: 0 };
+  }
   let offRecord = false;
   let droppedSegments = 0;
   const segments = [];
   for (const segment of conversation.segments) {
-    if (!offRecord && OFF_THE_RECORD.test(segment.text)) {
+    const probe = foldForMatching(segment.text);
+    if (!offRecord && markers.start.test(probe)) {
       offRecord = true;
       segments.push({
         ...segment,
@@ -179,7 +271,7 @@ function applyOffTheRecord(conversation) {
       continue;
     }
     if (offRecord) {
-      if (BACK_ON_THE_RECORD.test(segment.text)) {
+      if (markers.end?.test(probe)) {
         offRecord = false;
         segments.push({
           ...segment,
@@ -205,9 +297,14 @@ export {
   correctionsFilePath,
   loadCorrectionsFile,
   saveCorrectionsFile,
+  detectScriptHints,
+  buildPhraseMatcher,
   REDACTION_PLACEHOLDER,
   redactText,
   compileRedactionPatterns,
+  BUILT_IN_OFF_THE_RECORD_START,
+  BUILT_IN_OFF_THE_RECORD_END,
+  compileOffTheRecordMarkers,
   applyOffTheRecord
 };
-//# sourceMappingURL=chunk-NDAH7BJ5.js.map
+//# sourceMappingURL=chunk-HVP33QVW.js.map

package/dist/chunk-HVP33QVW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wearables/corrections.ts","../src/wearables/text-language.ts","../src/wearables/redaction.ts"],"sourcesContent":["/**\n * Wearable transcript corrections — user-specific replacement rules.\n *\n * ASR engines consistently mishear the same proper nouns for the same\n * person (\"remnick\" for \"Remnic\", a colleague's name, product jargon).\n * Rules come from two places, merged at sync time:\n *\n *  1. `wearables.corrections` in plugin config (declarative, versioned\n *     with the operator's config).\n *  2. A CLI-managed rules file at `state/wearables/corrections.json`\n *     (added interactively via `remnic wearables corrections add`).\n *\n * Literal rules are regex-escaped before compilation and replacements\n * are applied via a function (never a replacement string) so `$` in\n * either side can't corrupt output.\n */\n\nimport { promises as fsPromises } from \"node:fs\";\nimport * as path from \"node:path\";\n\nimport type { WearableCorrectionRule } from \"./types.js\";\n\nexport interface CompiledCorrectionRule {\n  rule: WearableCorrectionRule;\n  pattern: RegExp;\n}\n\nexport interface CorrectionApplication {\n  text: string;\n  applied: number;\n}\n\n/** Hard cap on rule pattern length (bounds hostile/pathological regexes). */\nconst MAX_PATTERN_LENGTH = 256;\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Validate and compile a correction rule. Throws a descriptive error on\n * invalid input (empty match, regex that doesn't compile, regex that\n * matches the empty string) — callers surface this at config parse or\n * CLI time rather than skipping the rule silently.\n */\nexport function compileCorrectionRule(\n  rule: WearableCorrectionRule,\n  label: string,\n): CompiledCorrectionRule {\n  if (typeof rule.match !== \"string\" || rule.match.length === 0) {\n    throw new Error(`${label}: match must be a non-empty string`);\n  }\n  if (rule.match.length > MAX_PATTERN_LENGTH) {\n    throw new Error(\n      `${label}: match exceeds ${MAX_PATTERN_LENGTH} characters — correction patterns must stay short`,\n    );\n  }\n  if (typeof rule.replace !== \"string\") {\n    throw new Error(`${label}: replace must be a string`);\n  }\n  const flags = rule.caseInsensitive === false ? \"g\" : \"gi\";\n  let pattern: RegExp;\n  if (rule.regex === true) {\n    try {\n      // Operator-supplied regexes are the documented feature here\n      // (rules live in the operator's own config / state file, never in\n      // request input); the length cap above bounds pathological\n      // patterns. CodeQL js/regex-injection is dismissed by design for\n      // this site.\n      pattern = new RegExp(rule.match, flags);\n    } catch (err) {\n      throw new Error(\n        `${label}: match is not a valid regular expression: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  } else {\n    // Literal rules match on word boundaries when both edges of the\n    // match are word characters, so \"remnick\" doesn't fire inside\n    // \"remnickson\" unless the user opts into regex mode.\n    const escaped = escapeRegExp(rule.match);\n    const leading = /^[\\p{L}\\p{N}_]/u.test(rule.match) ? \"\\\\b\" : \"\";\n    const trailing = /[\\p{L}\\p{N}_]$/u.test(rule.match) ? \"\\\\b\" : \"\";\n    pattern = new RegExp(`${leading}${escaped}${trailing}`, flags);\n  }\n  if (pattern.test(\"\")) {\n    throw new Error(\n      `${label}: pattern matches the empty string and would corrupt every transcript`,\n    );\n  }\n  pattern.lastIndex = 0;\n  return { rule, pattern };\n}\n\n/** Compile a rule list, labeling errors with their index. */\nexport function compileCorrectionRules(\n  rules: WearableCorrectionRule[],\n  labelPrefix: string,\n): CompiledCorrectionRule[] {\n  return rules.map((rule, index) =>\n    compileCorrectionRule(rule, `${labelPrefix}[${index}]`),\n  );\n}\n\n/** Apply every applicable rule to a piece of transcript text. */\nexport function applyCorrections(\n  text: string,\n  rules: CompiledCorrectionRule[],\n  sourceId: string,\n): CorrectionApplication {\n  let applied = 0;\n  let result = text;\n  for (const { rule, pattern } of rules) {\n    if (\n      Array.isArray(rule.sources) &&\n      rule.sources.length > 0 &&\n      !rule.sources.includes(sourceId)\n    ) {\n      continue;\n    }\n    pattern.lastIndex = 0;\n    result = result.replace(pattern, () => {\n      applied += 1;\n      // Replacement via function: `$` in rule.replace stays literal.\n      return rule.replace;\n    });\n  }\n  return { text: result, applied };\n}\n\n// ---------------------------------------------------------------------------\n// CLI-managed rules file\n// ---------------------------------------------------------------------------\n\ninterface CorrectionsFileShape {\n  version: 1;\n  rules: WearableCorrectionRule[];\n}\n\nexport function correctionsFilePath(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"wearables\", \"corrections.json\");\n}\n\n/**\n * Load CLI-managed correction rules. A missing file means no rules; a\n * malformed file throws (operators should know their corrections are\n * not being applied rather than silently losing them).\n */\nexport async function loadCorrectionsFile(\n  memoryDir: string,\n): Promise<WearableCorrectionRule[]> {\n  const filePath = correctionsFilePath(memoryDir);\n  let raw: string;\n  try {\n    raw = await fsPromises.readFile(filePath, \"utf-8\");\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw err;\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (err) {\n    throw new Error(\n      `wearables corrections file is not valid JSON (state/wearables/corrections.json): ${\n        err instanceof Error ? err.message : String(err)\n      }`,\n    );\n  }\n  if (\n    typeof parsed !== \"object\" ||\n    parsed === null ||\n    Array.isArray(parsed) ||\n    !Array.isArray((parsed as CorrectionsFileShape).rules)\n  ) {\n    throw new Error(\n      'wearables corrections file has an unexpected shape (state/wearables/corrections.json); expected {\"version\":1,\"rules\":[...]}',\n    );\n  }\n  const rules = (parsed as CorrectionsFileShape).rules;\n  // Validate every persisted rule up front so a hand-edited bad rule\n  // fails at load with its index, not mid-sync.\n  compileCorrectionRules(rules, \"state corrections\");\n  return rules;\n}\n\n/** Persist CLI-managed rules atomically (temp file + rename). */\nexport async function saveCorrectionsFile(\n  memoryDir: string,\n  rules: WearableCorrectionRule[],\n): Promise<void> {\n  compileCorrectionRules(rules, \"state corrections\");\n  const filePath = correctionsFilePath(memoryDir);\n  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });\n  const payload: CorrectionsFileShape = { version: 1, rules };\n  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;\n  await fsPromises.writeFile(\n    tmpPath,\n    `${JSON.stringify(payload, null, 2)}\\n`,\n    \"utf-8\",\n  );\n  try {\n    await fsPromises.rename(tmpPath, filePath);\n  } catch (err) {\n    // Clean up the temp file on rename failure; the original (if any)\n    // is untouched.\n    await fsPromises.unlink(tmpPath).catch(() => undefined);\n    throw err;\n  }\n}\n","/**\n * Script-aware text helpers shared by wearable cleanup and redaction.\n *\n * Both features were written for space-delimited English. A spoken\n * marker phrase or a filler token in Japanese, Korean, Chinese, Arabic,\n * or Russian never matched, so a privacy feature silently did nothing\n * (issue #2196). These helpers make phrase matching correct for scripts\n * that do not separate words with spaces.\n */\n\n/** Coarse script class used to select built-in token sets. */\nexport type ScriptHint =\n  | \"latin\"\n  | \"japanese\"\n  | \"han\"\n  | \"korean\"\n  | \"arabic\"\n  | \"cyrillic\";\n\n/**\n * Whether a phrase edge needs a word boundary is decided per EDGE and per\n * script, because scripts attach material at different ends.\n *\n * Leading edge: guarded for every script that spaces its words, so a\n * marker cannot match at the tail of a longer word — Korean `기록` must\n * not fire inside `신기록`, Arabic `خاص` must not fire inside `أشخاص`.\n * Arabic and Hebrew additionally write single-letter proclitics (`و`,\n * `ف`, `ב`, `ל`) with no space, so their guard admits ONE such letter\n * when that letter itself starts a word: `وبدون تسجيل` still reaches the\n * built-in `بدون تسجيل`.\n *\n * Trailing edge: guarded for the space-delimited scripts, so `بدون تسجيل`\n * does not match inside `بدون تسجيلات`. Hangul is excluded — Korean\n * particles attach to the END of a word, and guarding there would stop\n * `기록을` from matching `기록`.\n *\n * Han and Kana running text has no boundary at either end: requiring one\n * is the bug that made every non-Latin marker unreachable.\n */\nconst PREFIXABLE_EDGE_CHAR =\n  /[\\p{Script=Latin}\\p{Script=Cyrillic}\\p{Script=Greek}\\p{Script=Arabic}\\p{Script=Hebrew}\\p{Script=Hangul}\\p{N}]/u;\nconst SUFFIXABLE_EDGE_CHAR =\n  /[\\p{Script=Latin}\\p{Script=Cyrillic}\\p{Script=Greek}\\p{Script=Arabic}\\p{Script=Hebrew}\\p{N}\\p{M}]/u;\nconst PROCLITIC_EDGE_CHAR = /[\\p{Script=Arabic}\\p{Script=Hebrew}]/u;\n\n/**\n * Single-letter proclitics that attach to the following word in Arabic\n * and Hebrew. Kept to the unambiguous conjunctions and prepositions;\n * a longer prefix is a different word, not a clitic.\n */\nconst PROCLITIC_LETTERS = \"وفبكلسהוכלמשב\";\n\n/**\n * Combining marks count as word characters. Without `\\p{M}` a decomposed\n * `café` (base `e` plus U+0301) would let the phrase `cafe` match its\n * prefix and elide a span nobody marked.\n */\nconst BOUNDARY_LOOKBEHIND = \"(?<![\\\\p{L}\\\\p{M}\\\\p{N}])\";\nconst BOUNDARY_LOOKAHEAD = \"(?![\\\\p{L}\\\\p{M}\\\\p{N}])\";\n/** Word start, or exactly one word-initial proclitic before the phrase. */\nconst PROCLITIC_LOOKBEHIND = `(?:${BOUNDARY_LOOKBEHIND}|(?<=${BOUNDARY_LOOKBEHIND}[${PROCLITIC_LETTERS}]))`;\n\nconst HAS_KANA = /[\\p{Script=Hiragana}\\p{Script=Katakana}]/u;\nconst HAS_HAN = /\\p{Script=Han}/u;\nconst HAS_HANGUL = /\\p{Script=Hangul}/u;\nconst HAS_ARABIC = /\\p{Script=Arabic}/u;\nconst HAS_CYRILLIC = /\\p{Script=Cyrillic}/u;\n\n/**\n * Normalize text for phrase matching: NFC, then fold the Turkic dotted and\n * dotless I onto plain `i`.\n *\n * JavaScript's `/iu` folding is locale-independent, so it equates `i` with\n * `I` but never `ı` with `I` or `i` with `İ`. A Turkish marker such as\n * `kayıt dışı` would therefore miss an uppercase `KAYIT DIŞI` transcript and\n * leave the span on the record. Both sides of the comparison run through\n * this, so the fold cannot make one side drift from the other.\n */\nexport function foldForMatching(text: string): string {\n  return text.normalize(\"NFC\").replace(/[\\u0131\\u0130I]/g, \"i\");\n}\n\n/**\n * Report which script-specific token sets apply to `text`.\n *\n * `latin` is always present: transcripts mix scripts freely, and the\n * Latin filler tokens are whole-token matches that cannot fire inside\n * non-Latin text. Japanese wins over Han when kana are present, because\n * Japanese text also contains Han characters.\n */\nexport function detectScriptHints(text: string): ScriptHint[] {\n  const hints: ScriptHint[] = [\"latin\"];\n  if (HAS_KANA.test(text)) hints.push(\"japanese\");\n  else if (HAS_HAN.test(text)) hints.push(\"han\");\n  if (HAS_HANGUL.test(text)) hints.push(\"korean\");\n  if (HAS_ARABIC.test(text)) hints.push(\"arabic\");\n  if (HAS_CYRILLIC.test(text)) hints.push(\"cyrillic\");\n  return hints;\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Compile `phrases` into one case-insensitive matcher, or `null` when\n * no usable phrase remains.\n *\n * Internal whitespace matches any whitespace run, so a transcript that\n * breaks a phrase across a line still matches. Letter boundaries are\n * added per edge, and only when that edge is a space-delimited script.\n */\nexport function buildPhraseMatcher(\n  phrases: readonly string[],\n): RegExp | null {\n  const parts: string[] = [];\n  const seen = new Set<string>();\n  for (const raw of phrases) {\n    if (typeof raw !== \"string\") continue;\n    // Folded on both sides (the tester folds its input too): an ASR that\n    // emits decomposed or Turkic-uppercase text would otherwise never match\n    // its marker, and the span would be persisted (issue #2196).\n    const phrase = foldForMatching(raw.trim());\n    if (phrase.length === 0) continue;\n    const key = phrase.toLowerCase();\n    if (seen.has(key)) continue;\n    seen.add(key);\n    const characters = Array.from(phrase);\n    const body = phrase\n      .split(/\\s+/)\n      .map((word) => escapeRegExp(word))\n      .join(\"\\\\s+\");\n    const first = characters[0];\n    const lead = PROCLITIC_EDGE_CHAR.test(first)\n      ? PROCLITIC_LOOKBEHIND\n      : PREFIXABLE_EDGE_CHAR.test(first)\n        ? BOUNDARY_LOOKBEHIND\n        : \"\";\n    const tail = SUFFIXABLE_EDGE_CHAR.test(characters[characters.length - 1])\n      ? BOUNDARY_LOOKAHEAD\n      : \"\";\n    parts.push(`${lead}${body}${tail}`);\n  }\n  if (parts.length === 0) return null;\n  return new RegExp(parts.join(\"|\"), \"iu\");\n}\n","/**\n * Wearable transcript redaction — privacy guard applied before any\n * transcript text is persisted or fed to extraction.\n *\n * Always-on recorders capture things nobody intended to store: card\n * numbers read aloud, SSNs dictated to a pharmacy line. Built-in\n * patterns cover the unambiguous, high-sensitivity cases; users can add\n * their own regexes via `wearables.redactionPatterns` (validated at\n * config parse — invalid patterns are rejected loudly, never ignored).\n *\n * All built-in patterns are simple linear scans (no nested quantifiers)\n * to stay safely outside polynomial-ReDoS territory.\n */\n\nimport { buildPhraseMatcher, foldForMatching } from \"./text-language.js\";\nimport type {\n  OffTheRecordMarkerSettings,\n  WearableConversation,\n} from \"./types.js\";\n\nexport const REDACTION_PLACEHOLDER = \"[redacted]\";\n\n/**\n * Built-in patterns. Conservative by design — false positives erase\n * real transcript content, so each pattern targets formats that are\n * near-certain PII:\n *  - US SSN with separators (123-45-6789). Bare 9-digit runs are NOT\n *    matched (too many false positives: ids, tracking numbers).\n *  - Payment-card-like runs: 13–19 digits in groups separated by\n *    spaces/dashes (4111 1111 1111 1111) or contiguous 15–16 digits.\n */\nconst BUILT_IN_PATTERNS: RegExp[] = [\n  /\\b\\d{3}-\\d{2}-\\d{4}\\b/g,\n  // Starts and ENDS on a digit so a trailing separator is never\n  // consumed (replacing it would glue the placeholder to the next word).\n  /\\b\\d(?:[ -]?\\d){12,18}\\b/g,\n];\n\n/** Minimum digit count before a digit-run is treated as a card number. */\nconst CARD_MIN_DIGITS = 13;\n\nexport interface RedactionResult {\n  text: string;\n  redactions: number;\n}\n\nexport function redactText(\n  text: string,\n  userPatterns: RegExp[],\n): RedactionResult {\n  let redactions = 0;\n  let result = text;\n\n  // SSN pattern first (more specific than the digit-run pattern).\n  result = result.replace(BUILT_IN_PATTERNS[0], () => {\n    redactions += 1;\n    return REDACTION_PLACEHOLDER;\n  });\n\n  // Digit-run pattern with a post-match digit-count check so short\n  // grouped numbers (\"call 555 0125 today\") survive.\n  result = result.replace(BUILT_IN_PATTERNS[1], (match) => {\n    const digits = match.replace(/\\D/g, \"\");\n    if (digits.length < CARD_MIN_DIGITS || digits.length > 19) {\n      return match;\n    }\n    redactions += 1;\n    return REDACTION_PLACEHOLDER;\n  });\n\n  for (const pattern of userPatterns) {\n    result = result.replace(pattern, () => {\n      redactions += 1;\n      return REDACTION_PLACEHOLDER;\n    });\n  }\n\n  return { text: result, redactions };\n}\n\n/**\n * Compile user-supplied redaction patterns. Throws with a descriptive\n * message on the first invalid pattern — config parsing surfaces this\n * to the operator instead of silently skipping the rule.\n */\nexport function compileRedactionPatterns(patterns: string[]): RegExp[] {\n  return patterns.map((pattern, index) => {\n    if (typeof pattern !== \"string\" || pattern.trim().length === 0) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] must be a non-empty string`,\n      );\n    }\n    if (pattern.length > 256) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] exceeds 256 characters — redaction patterns must stay short`,\n      );\n    }\n    try {\n      // Operator-supplied regexes from the operator's own config —\n      // length-capped above; never request input.\n      return new RegExp(pattern, \"gi\");\n    } catch (err) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] is not a valid regular expression: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  });\n}\n\n/**\n * Built-in phrases that BEGIN an off-the-record span.\n *\n * Conservative by design: a false positive elides real transcript\n * content. Every phrase is a fixed multi-word expression, or a loanword\n * that only means \"off the record\" (issue #2196). Operators extend this\n * list through `wearables.offTheRecordMarkers.start`.\n */\nexport const BUILT_IN_OFF_THE_RECORD_START: readonly string[] = [\n  \"off the record\",\n  \"fuera de registro\",\n  \"extraoficialmente\",\n  \"fora de registro\",\n  \"fora do registro\",\n  \"hors micro\",\n  \"nicht fürs protokoll\",\n  \"nicht für das protokoll\",\n  \"fuori registro\",\n  \"オフレコ\",\n  \"오프더레코드\",\n  \"不要记录\",\n  \"не для протокола\",\n  \"بدون تسجيل\",\n];\n\n/**\n * Built-in phrases that END an off-the-record span.\n *\n * Shorter than the start list on purpose. A start phrase with no\n * matching end phrase elides through the end of the conversation, which\n * is the fail-closed direction; an over-eager end phrase would leak. So\n * a language only appears here when the phrase is unambiguous.\n */\nexport const BUILT_IN_OFF_THE_RECORD_END: readonly string[] = [\n  \"back on the record\",\n  \"on the record\",\n  \"de nuevo en registro\",\n  \"de volta ao registro\",\n  \"wieder fürs protokoll\",\n  \"wieder für das protokoll\",\n  \"オンレコ\",\n  \"온더레코드\",\n];\n\n/**\n * Loose form of the parsed `OffTheRecordMarkerSettings`: callers that\n * only override one field pass a partial, so every property is\n * optional and read-only here.\n */\nexport type OffTheRecordMarkerInput = {\n  readonly [K in keyof OffTheRecordMarkerSettings]?: K extends \"useBuiltIns\"\n    ? boolean\n    : readonly string[];\n};\n\nexport interface CompiledOffTheRecordMarkers {\n  start: RegExp | null;\n  end: RegExp | null;\n}\n\n/**\n * Compile marker settings into matchers. Omitting `settings` yields the\n * built-in lists, so callers that never configured markers keep the\n * previous behavior plus the new languages.\n */\nexport function compileOffTheRecordMarkers(\n  settings?: OffTheRecordMarkerInput,\n): CompiledOffTheRecordMarkers {\n  const useBuiltIns = settings?.useBuiltIns !== false;\n  const start = [\n    ...(useBuiltIns ? BUILT_IN_OFF_THE_RECORD_START : []),\n    ...(settings?.start ?? []),\n  ];\n  const end = [\n    ...(useBuiltIns ? BUILT_IN_OFF_THE_RECORD_END : []),\n    ...(settings?.end ?? []),\n  ];\n  return {\n    start: buildPhraseMatcher(start),\n    end: buildPhraseMatcher(end),\n  };\n}\n\nexport interface OffTheRecordResult {\n  conversation: WearableConversation;\n  droppedSegments: number;\n}\n\n/**\n * Drop segments between a spoken off-the-record marker and the next\n * back-on-the-record marker (or conversation end). The marker segments\n * themselves are kept, with the off-record span replaced by a visible\n * placeholder so the transcript shows that content was elided by\n * request rather than lost.\n */\nexport function applyOffTheRecord(\n  conversation: WearableConversation,\n  markers: CompiledOffTheRecordMarkers = compileOffTheRecordMarkers(),\n): OffTheRecordResult {\n  if (!markers.start) {\n    return { conversation, droppedSegments: 0 };\n  }\n  let offRecord = false;\n  let droppedSegments = 0;\n  const segments = [];\n  for (const segment of conversation.segments) {\n    // Matched folded, stored as written: the transcript keeps the ASR's own\n    // bytes while a decomposed or Turkic-uppercase spelling still reaches\n    // the marker.\n    const probe = foldForMatching(segment.text);\n    if (!offRecord && markers.start.test(probe)) {\n      offRecord = true;\n      segments.push({\n        ...segment,\n        text: \"[off the record — segment elided]\",\n      });\n      continue;\n    }\n    if (offRecord) {\n      if (markers.end?.test(probe)) {\n        offRecord = false;\n        segments.push({\n          ...segment,\n          text: \"[back on the record]\",\n        });\n      } else {\n        droppedSegments += 1;\n      }\n      continue;\n    }\n    segments.push(segment);\n  }\n  return {\n    conversation: { ...conversation, segments },\n    droppedSegments,\n  };\n}\n"],"mappings":"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","names":["escapeRegExp"]}

package/dist/{chunk-YXKVLYXU.js → chunk-HWRD23DW.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-KJTKLXTH.js";
 import {
   StorageManager
-} from "./chunk-WD5B5AIE.js";
+} from "./chunk-6R4G7N4S.js";
 import {
   copyExistingFileToBackup,
   writeFileAtomically
@@ -260,4 +260,4 @@ export {
   backupExistingLedger,
   rebuildMemoryLifecycleLedger
 };
-//# sourceMappingURL=chunk-YXKVLYXU.js.map
+//# sourceMappingURL=chunk-HWRD23DW.js.map

package/dist/{chunk-SOEN6KCF.js → chunk-IBKR2TFR.js}

@@ -1,6 +1,6 @@
 import {
   applyExtractionSourceGrounding
-} from "./chunk-NK5RGJ65.js";
+} from "./chunk-L4DLLKPN.js";
 import {
   CONNECTOR_LABEL_MAX_LENGTH,
   knownConnectorIds
@@ -108,4 +108,4 @@ export {
   renderExtractionConversation,
   applyGroundingWithConnector
 };
-//# sourceMappingURL=chunk-SOEN6KCF.js.map
+//# sourceMappingURL=chunk-IBKR2TFR.js.map

package/dist/{chunk-R3DJVOSM.js → chunk-JDSVLVCG.js}

@@ -13,6 +13,12 @@ function stripAttributesSuffix(content) {
   if (inner.includes("]") || inner.includes("\n")) return content.trim();
   return trimmed.slice(0, markerIndex).trim();
 }
+function storedContentIdentityCandidates(content, stripCitation) {
+  const fullBody = content.trim();
+  const bodyWithoutAttributes = stripAttributesSuffix(fullBody);
+  const rawBody = stripCitation(bodyWithoutAttributes);
+  return [.../* @__PURE__ */ new Set([rawBody, bodyWithoutAttributes, fullBody])];
+}
 function normalizeAttributePairs(pairs) {
   return Object.entries(pairs).map(([k, v]) => [k.trim().toLowerCase(), v.trim()]).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join("; ");
 }
@@ -28,7 +34,8 @@ function assemblePersistedBody(content, structuredAttributes) {
 
 export {
   stripAttributesSuffix,
+  storedContentIdentityCandidates,
   normalizeAttributePairs,
   assemblePersistedBody
 };
-//# sourceMappingURL=chunk-R3DJVOSM.js.map
+//# sourceMappingURL=chunk-JDSVLVCG.js.map

package/dist/chunk-JDSVLVCG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structured-attributes.ts"],"sourcesContent":["/**\n * Shared helpers for the `\\n[Attributes: …]` enrichment suffix that\n * `writeMemory` appends to a stored body when `structuredAttributes` are\n * present.\n *\n * Extracted here (out of `storage.ts`) so every reader — the storage\n * manager, the wearable service, and the coding surfaces — strips the suffix\n * with ONE definition. Previously `coding/architecture-surfaces.ts` carried a\n * weaker local copy that only checked the trailing `]`, which could truncate\n * card markdown that legitimately ends in a `[Attributes: …]` line (cursor\n * review: duplicate attribute suffix stripper).\n *\n * String operations, not regex — CodeQL `js/polynomial-redos` flags\n * suffix-anchored patterns over library-supplied content.\n */\n\nimport { sanitizeMemoryContent } from \"./sanitize.js\";\n\n/**\n * Remove the `[Attributes: …]` suffix `writeMemory` appends to the stored\n * body when structuredAttributes are present, yielding the raw fact/card text\n * for content comparison or client display. Inverse companion of\n * `normalizeAttributePairs` enrichment in `storage.ts`.\n *\n * Returns the stripped (trimmed) body when the marker opens the final\n * non-empty line and its inner payload contains no premature `]` or newline\n * (mirrors the exact shape `normalizeAttributePairs` emits). Otherwise\n * returns the trimmed input unchanged — never truncates legitimate content.\n */\nexport function stripAttributesSuffix(content: string): string {\n  const trimmed = content.trimEnd();\n  if (!trimmed.endsWith(\"]\")) return content.trim();\n  const marker = \"\\n[Attributes: \";\n  const markerIndex = trimmed.lastIndexOf(marker);\n  if (markerIndex === -1) return content.trim();\n  // The block must be the FINAL line and contain no \"]\" before the\n  // closing bracket (mirrors the shape normalizeAttributePairs emits).\n  const inner = trimmed.slice(markerIndex + marker.length, -1);\n  if (inner.includes(\"]\") || inner.includes(\"\\n\")) return content.trim();\n  return trimmed.slice(0, markerIndex).trim();\n}\n\n/** Return stored-body identity forms, from raw semantic content to full body. */\nexport function storedContentIdentityCandidates(\n  content: string,\n  stripCitation: (value: string) => string,\n): string[] {\n  const fullBody = content.trim();\n  const bodyWithoutAttributes = stripAttributesSuffix(fullBody);\n  const rawBody = stripCitation(bodyWithoutAttributes);\n  return [...new Set([rawBody, bodyWithoutAttributes, fullBody])];\n}\n// ---------------------------------------------------------------------------\n// Persisted-body assembly (issue #1989 PR2)\n// ---------------------------------------------------------------------------\n//\n// `writeMemory` historically enriched content with the attribute suffix and\n// then sanitized the COMBINED body inline. That assembly is the persisted\n// form both the file body and write-idempotency fingerprints must agree on\n// (AGENTS.md §13), so it lives here — shared by `StorageManager.writeMemory`\n// and `composeMemoryEnvelope` — instead of existing twice.\n\n/**\n * Canonical `key: value; …` rendering of structured attributes. Keys are\n * trimmed + lowercased, values trimmed, pairs sorted by normalized key.\n * Moved verbatim from `storage.ts` (which re-exports it for API stability);\n * used at the write path, the dedup-lookup path, and envelope assembly.\n */\nexport function normalizeAttributePairs(pairs: Record<string, string>): string {\n  return Object.entries(pairs)\n    .map(([k, v]) => [k.trim().toLowerCase(), v.trim()] as [string, string])\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([k, v]) => `${k}: ${v}`)\n    .join(\"; \");\n}\n\nexport interface AssembledPersistBody {\n  /** The exact body persistence writes: enriched then sanitized. */\n  text: string;\n  /** False when sanitization redacted injection-bearing text. */\n  clean: boolean;\n  /** Matched injection pattern sources (for the storage warn log). */\n  violations: string[];\n}\n\n/**\n * Assemble the persisted body exactly as `writeMemory` does: append the\n * normalized attribute suffix when attributes are present, then sanitize the\n * combined result. ONE definition — byte-identity between the legacy write\n * path and the sealed-envelope path is structural, not tested-by-hope.\n */\nexport function assemblePersistedBody(\n  content: string,\n  structuredAttributes?: Record<string, string>,\n): AssembledPersistBody {\n  let enriched = content;\n  if (structuredAttributes && Object.keys(structuredAttributes).length > 0) {\n    enriched = `${content}\\n[Attributes: ${normalizeAttributePairs(structuredAttributes)}]`;\n  }\n  const sanitized = sanitizeMemoryContent(enriched);\n  return { text: sanitized.text, clean: sanitized.clean, violations: sanitized.violations };\n}\n"],"mappings":";;;;;AA6BO,SAAS,sBAAsB,SAAyB;AAC7D,QAAM,UAAU,QAAQ,QAAQ;AAChC,MAAI,CAAC,QAAQ,SAAS,GAAG,EAAG,QAAO,QAAQ,KAAK;AAChD,QAAM,SAAS;AACf,QAAM,cAAc,QAAQ,YAAY,MAAM;AAC9C,MAAI,gBAAgB,GAAI,QAAO,QAAQ,KAAK;AAG5C,QAAM,QAAQ,QAAQ,MAAM,cAAc,OAAO,QAAQ,EAAE;AAC3D,MAAI,MAAM,SAAS,GAAG,KAAK,MAAM,SAAS,IAAI,EAAG,QAAO,QAAQ,KAAK;AACrE,SAAO,QAAQ,MAAM,GAAG,WAAW,EAAE,KAAK;AAC5C;AAGO,SAAS,gCACd,SACA,eACU;AACV,QAAM,WAAW,QAAQ,KAAK;AAC9B,QAAM,wBAAwB,sBAAsB,QAAQ;AAC5D,QAAM,UAAU,cAAc,qBAAqB;AACnD,SAAO,CAAC,GAAG,oBAAI,IAAI,CAAC,SAAS,uBAAuB,QAAQ,CAAC,CAAC;AAChE;AAiBO,SAAS,wBAAwB,OAAuC;AAC7E,SAAO,OAAO,QAAQ,KAAK,EACxB,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,EAAE,KAAK,CAAC,CAAqB,EACtE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EACrC,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,EAC5B,KAAK,IAAI;AACd;AAiBO,SAAS,sBACd,SACA,sBACsB;AACtB,MAAI,WAAW;AACf,MAAI,wBAAwB,OAAO,KAAK,oBAAoB,EAAE,SAAS,GAAG;AACxE,eAAW,GAAG,OAAO;AAAA,eAAkB,wBAAwB,oBAAoB,CAAC;AAAA,EACtF;AACA,QAAM,YAAY,sBAAsB,QAAQ;AAChD,SAAO,EAAE,MAAM,UAAU,MAAM,OAAO,UAAU,OAAO,YAAY,UAAU,WAAW;AAC1F;","names":[]}

package/dist/{chunk-F4EU6VUC.js → chunk-JDZPNCMA.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-WD5B5AIE.js";
+} from "./chunk-6R4G7N4S.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -958,4 +958,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-F4EU6VUC.js.map
+//# sourceMappingURL=chunk-JDZPNCMA.js.map

package/dist/{chunk-D5YOZ66N.js → chunk-JV5YUBIZ.js}

@@ -54,7 +54,7 @@ import {
 } from "./chunk-IIFFC3RL.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-YXKVLYXU.js";
+} from "./chunk-HWRD23DW.js";
 import {
   rebuildObservations
 } from "./chunk-DQTCGVFK.js";
@@ -80,21 +80,21 @@ import {
 } from "./chunk-6FC3IZ26.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-J272WKX2.js";
+} from "./chunk-6HPHEFXT.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-X57M2Q4I.js";
+} from "./chunk-RDJRFDJY.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-VFSAWRMZ.js";
+} from "./chunk-LJS7KUPV.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-XAPMEU3K.js";
+} from "./chunk-UU7TRFNE.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -127,7 +127,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-X7XEDOSL.js";
+} from "./chunk-4IIFL7GC.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -152,7 +152,7 @@ import {
 } from "./chunk-6GUG4YNM.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-W7Y5JDVB.js";
+} from "./chunk-PDDTI7IC.js";
 import {
   rescoreMemoryImportance
 } from "./chunk-JXS5PDQ7.js";
@@ -169,7 +169,7 @@ import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-5UZ6UCOZ.js";
+} from "./chunk-XUAMCLY4.js";
 import {
   getCueAnchorStoreStatus
 } from "./chunk-ACPCA4NO.js";
@@ -196,11 +196,11 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   parseConfig
-} from "./chunk-O5FFBO2M.js";
+} from "./chunk-47P3RYZP.js";
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-HDIUYMSB.js";
+} from "./chunk-QWGE2PUH.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -213,13 +213,13 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-QINJITDS.js";
+} from "./chunk-PX2LSHYM.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-DJUKBGAD.js";
 import {
   EngramAccessService
-} from "./chunk-BF6SXNQJ.js";
+} from "./chunk-T2JHZWH6.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -239,7 +239,7 @@ import {
 } from "./chunk-QT2FRYI4.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-JSEJH2YQ.js";
+} from "./chunk-CGVHPCP2.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-HTP6XRUI.js";
@@ -248,15 +248,15 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-B6LZ4IBH.js";
+} from "./chunk-6LAPLZOS.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-RANKJI5T.js";
+} from "./chunk-3JLPGJ43.js";
 import {
   resolveNamespaceChildRoot
-} from "./chunk-NOEMGE56.js";
+} from "./chunk-NH5IR2WM.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-AHZOMHWN.js";
@@ -265,7 +265,7 @@ import {
 } from "./chunk-BIJAWZYW.js";
 import {
   meetingIdDate
-} from "./chunk-WD5B5AIE.js";
+} from "./chunk-6R4G7N4S.js";
 import {
   isValidTranscriptDate
 } from "./chunk-UHVXE24Y.js";
@@ -4025,7 +4025,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
         const idArg = typeof args[0] === "string" ? args[0] : "";
         const options = args[1] ?? {};
         const reason = typeof options.reason === "string" && options.reason.trim().length > 0 ? options.reason.trim() : void 0;
-        const { forgetMemory } = await import("./forget-HDS4N6CG.js");
+        const { forgetMemory } = await import("./forget-EHGGJZLX.js");
         try {
           const result = await forgetMemory(orchestrator.storage, {
             id: idArg,
@@ -7230,7 +7230,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           console.error("--verb is required. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context");
           process.exit(1);
         }
-        const { isValidResolutionVerb, executeResolution } = await import("./resolution-MDPNOEG6.js");
+        const { isValidResolutionVerb, executeResolution } = await import("./resolution-MMOD5WC4.js");
         if (!isValidResolutionVerb(verb)) {
           console.error(`Invalid verb: ${verb}. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context`);
           process.exit(1);
@@ -7989,4 +7989,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-D5YOZ66N.js.map
+//# sourceMappingURL=chunk-JV5YUBIZ.js.map

package/dist/{chunk-DLG5V6ND.js → chunk-K4QS7LXU.js}

@@ -9,7 +9,7 @@ import {
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
-} from "./chunk-BQIFZ2MP.js";
+} from "./chunk-CX5SW2EW.js";
 import {
   markProjectedMemoryPathInvalid
 } from "./chunk-3CSX3ETE.js";
@@ -460,7 +460,7 @@ var TombstoneBlockedCaptureIndex = class {
         await index.load();
         const rebuildMarkers = await this.getRebuildMarkers();
         const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
-        let persisted = true;
+        let persisted = !index.requiresFormatMigration;
         try {
           await stat(this.indexPath());
           if (rebuildMarkers.length > 0) persisted = false;
@@ -616,10 +616,7 @@ var TombstoneBlockedCaptureIndex = class {
     if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
     const rebuilt = await this.rebuild(await this.getIndex());
     if (rebuilt) {
-      await this.clearRebuildRequired([
-        ...clearableExistingMarkers,
-        marker
-      ]);
+      await this.clearRebuildRequired([...clearableExistingMarkers, marker]);
     }
     await this.setAuthoritative(rebuilt);
   }
@@ -1377,4 +1374,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-DLG5V6ND.js.map
+//# sourceMappingURL=chunk-K4QS7LXU.js.map