@remnic/core 9.53.0 → 9.54.0

package/src/wearables/redaction.test.ts

@@ -3,6 +3,7 @@ import { test } from "node:test";
 
 import {
   applyOffTheRecord,
+  compileOffTheRecordMarkers,
   compileRedactionPatterns,
   redactText,
   REDACTION_PLACEHOLDER,
@@ -92,3 +93,158 @@ test("conversations without the marker pass through untouched", () => {
   );
   assert.equal(result.droppedSegments, 0);
 });
+
+test("built-in markers elide a Japanese off-the-record span", () => {
+  const result = applyOffTheRecord(
+    conversation([
+      "ここからはオフレコでお願いします。",
+      "来週の買収は金曜に完了します。",
+      "オンレコに戻ります。",
+      "昼食はおいしかったです。",
+    ]),
+  );
+  assert.deepEqual(
+    result.conversation.segments.map((segment) => segment.text),
+    [
+      "[off the record — segment elided]",
+      "[back on the record]",
+      "昼食はおいしかったです。",
+    ],
+  );
+  assert.equal(result.droppedSegments, 1);
+});
+
+test("built-in markers elide a Korean span through conversation end", () => {
+  const result = applyOffTheRecord(
+    conversation(["지금부터 오프더레코드입니다", "비밀 계약 조건입니다"]),
+  );
+  assert.equal(result.conversation.segments.length, 1);
+  assert.equal(result.droppedSegments, 1);
+});
+
+test("configured markers extend the built-in phrases", () => {
+  const markers = compileOffTheRecordMarkers({
+    start: ["poza protokołem"],
+    end: ["z powrotem do protokołu"],
+  });
+  const result = applyOffTheRecord(
+    conversation([
+      "To jest poza protokołem.",
+      "Tajna informacja.",
+      "Wracamy z powrotem do protokołu.",
+      "Normalna rozmowa.",
+    ]),
+    markers,
+  );
+  assert.deepEqual(
+    result.conversation.segments.map((segment) => segment.text),
+    [
+      "[off the record — segment elided]",
+      "[back on the record]",
+      "Normalna rozmowa.",
+    ],
+  );
+  assert.equal(result.droppedSegments, 1);
+  // The built-in English phrase still applies alongside the custom set.
+  assert.equal(
+    applyOffTheRecord(conversation(["off the record", "secret"]), markers)
+      .droppedSegments,
+    1,
+  );
+});
+
+test("useBuiltIns false honors only the configured phrases", () => {
+  const markers = compileOffTheRecordMarkers({
+    start: ["poza protokołem"],
+    useBuiltIns: false,
+  });
+  const result = applyOffTheRecord(
+    conversation(["Let me say this off the record.", "The merger closes Friday."]),
+    markers,
+  );
+  assert.equal(result.droppedSegments, 0);
+  assert.equal(result.conversation.segments.length, 2);
+  // Non-vacuous: the configured phrase must still start an elision, so
+  // this cannot pass by discarding `start` along with the built-ins.
+  assert.equal(
+    applyOffTheRecord(conversation(["poza protokołem", "secret"]), markers)
+      .droppedSegments,
+    1,
+  );
+});
+
+test("a Latin marker phrase never matches inside a longer word", () => {
+  const result = applyOffTheRecord(
+    conversation(["We discussed hors microphone placement.", "Normal talk."]),
+  );
+  assert.equal(result.droppedSegments, 0);
+  assert.equal(result.conversation.segments.length, 2);
+});
+
+test("an Arabic marker does not match inside a longer Arabic word", () => {
+  assert.equal(
+    applyOffTheRecord(conversation(["لدينا بدون تسجيلات كثيرة", "كلام عادي"]))
+      .droppedSegments,
+    0,
+  );
+  assert.equal(
+    applyOffTheRecord(conversation(["هذا بدون تسجيل من فضلك", "سر"])).droppedSegments,
+    1,
+  );
+});
+
+test("an Arabic proclitic still reaches the built-in marker", () => {
+  // Arabic writes و/ف/ب attached to the next word, so a leading guard
+  // would silently disable the marker for ordinary phrasing.
+  assert.equal(
+    applyOffTheRecord(conversation(["وبدون تسجيل من فضلك", "سر"])).droppedSegments,
+    1,
+  );
+});
+
+test("a decomposed accent is a word character, not a boundary", () => {
+  const markers = compileOffTheRecordMarkers({
+    start: ["cafe"],
+    useBuiltIns: false,
+  });
+  const decomposed = `cafe\u0301teria is open`;
+  assert.equal(applyOffTheRecord(conversation([decomposed, "x"]), markers).droppedSegments, 0);
+  assert.equal(applyOffTheRecord(conversation(["cafe is open", "x"]), markers).droppedSegments, 1);
+});
+
+test("a decomposed transcript still reaches a composed marker", () => {
+  // Some ASR output is canonically decomposed. Without normalizing the
+  // probe, `nicht fürs protokoll` would never match and the span would be
+  // persisted.
+  const decomposed = "nicht fu\u0308rs protokoll, bitte".normalize("NFD");
+  const result = applyOffTheRecord(conversation([decomposed, "geheim", "wieder fürs protokoll"]));
+  assert.equal(result.droppedSegments, 1);
+  assert.equal(result.conversation.segments[0]?.text, "[off the record — segment elided]");
+  assert.equal(result.conversation.segments[1]?.text, "[back on the record]");
+});
+
+test("a marker never fires at the tail of a longer word", () => {
+  // Korean particles attach at the END, so the leading guard is safe there
+  // while the trailing edge stays open.
+  const korean = compileOffTheRecordMarkers({ start: ["기록"], useBuiltIns: false });
+  assert.equal(applyOffTheRecord(conversation(["신기록 입니다", "x"]), korean).droppedSegments, 0);
+  assert.equal(applyOffTheRecord(conversation(["기록을 멈춰주세요", "비밀"]), korean).droppedSegments, 1);
+
+  // Arabic admits ONE word-initial proclitic and nothing longer.
+  const arabic = compileOffTheRecordMarkers({ start: ["خاص"], useBuiltIns: false });
+  assert.equal(applyOffTheRecord(conversation(["أشخاص كثيرون", "x"]), arabic).droppedSegments, 0);
+  assert.equal(applyOffTheRecord(conversation(["وخاص جدا", "سر"]), arabic).droppedSegments, 1);
+});
+
+test("a Turkish marker matches an uppercase transcript", () => {
+  // JS `/iu` folding is locale-independent: it never equates `ı` with `I`.
+  const markers = compileOffTheRecordMarkers({ start: ["kayıt dışı"], useBuiltIns: false });
+  assert.equal(
+    applyOffTheRecord(conversation(["BU KAYIT DIŞI", "gizli bilgi"]), markers).droppedSegments,
+    1,
+  );
+  assert.equal(
+    applyOffTheRecord(conversation(["bu kayıt dışı", "gizli bilgi"]), markers).droppedSegments,
+    1,
+  );
+});

package/src/wearables/redaction.ts

@@ -12,7 +12,11 @@
  * to stay safely outside polynomial-ReDoS territory.
  */
 
-import type { WearableConversation } from "./types.js";
+import { buildPhraseMatcher, foldForMatching } from "./text-language.js";
+import type {
+  OffTheRecordMarkerSettings,
+  WearableConversation,
+} from "./types.js";
 
 export const REDACTION_PLACEHOLDER = "[redacted]";
 
@@ -105,8 +109,88 @@ export function compileRedactionPatterns(patterns: string[]): RegExp[] {
   });
 }
 
-const OFF_THE_RECORD = /\boff\s+the\s+record\b/i;
-const BACK_ON_THE_RECORD = /\b(?:back\s+)?on\s+the\s+record\b/i;
+/**
+ * Built-in phrases that BEGIN an off-the-record span.
+ *
+ * Conservative by design: a false positive elides real transcript
+ * content. Every phrase is a fixed multi-word expression, or a loanword
+ * that only means "off the record" (issue #2196). Operators extend this
+ * list through `wearables.offTheRecordMarkers.start`.
+ */
+export const BUILT_IN_OFF_THE_RECORD_START: readonly string[] = [
+  "off the record",
+  "fuera de registro",
+  "extraoficialmente",
+  "fora de registro",
+  "fora do registro",
+  "hors micro",
+  "nicht fürs protokoll",
+  "nicht für das protokoll",
+  "fuori registro",
+  "オフレコ",
+  "오프더레코드",
+  "不要记录",
+  "не для протокола",
+  "بدون تسجيل",
+];
+
+/**
+ * Built-in phrases that END an off-the-record span.
+ *
+ * Shorter than the start list on purpose. A start phrase with no
+ * matching end phrase elides through the end of the conversation, which
+ * is the fail-closed direction; an over-eager end phrase would leak. So
+ * a language only appears here when the phrase is unambiguous.
+ */
+export const BUILT_IN_OFF_THE_RECORD_END: readonly string[] = [
+  "back on the record",
+  "on the record",
+  "de nuevo en registro",
+  "de volta ao registro",
+  "wieder fürs protokoll",
+  "wieder für das protokoll",
+  "オンレコ",
+  "온더레코드",
+];
+
+/**
+ * Loose form of the parsed `OffTheRecordMarkerSettings`: callers that
+ * only override one field pass a partial, so every property is
+ * optional and read-only here.
+ */
+export type OffTheRecordMarkerInput = {
+  readonly [K in keyof OffTheRecordMarkerSettings]?: K extends "useBuiltIns"
+    ? boolean
+    : readonly string[];
+};
+
+export interface CompiledOffTheRecordMarkers {
+  start: RegExp | null;
+  end: RegExp | null;
+}
+
+/**
+ * Compile marker settings into matchers. Omitting `settings` yields the
+ * built-in lists, so callers that never configured markers keep the
+ * previous behavior plus the new languages.
+ */
+export function compileOffTheRecordMarkers(
+  settings?: OffTheRecordMarkerInput,
+): CompiledOffTheRecordMarkers {
+  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),
+  };
+}
 
 export interface OffTheRecordResult {
   conversation: WearableConversation;
@@ -114,20 +198,28 @@ export interface OffTheRecordResult {
 }
 
 /**
- * Drop segments between a spoken "off the record" marker and the next
- * "(back) on the record" marker (or conversation end). The marker
- * segments themselves are kept, with the off-record span replaced by a
- * visible placeholder so the transcript shows that content was elided
- * by request rather than lost.
+ * Drop segments between a spoken off-the-record marker and the next
+ * back-on-the-record marker (or conversation end). The marker segments
+ * themselves are kept, with the off-record span replaced by a visible
+ * placeholder so the transcript shows that content was elided by
+ * request rather than lost.
  */
 export function applyOffTheRecord(
   conversation: WearableConversation,
+  markers: CompiledOffTheRecordMarkers = compileOffTheRecordMarkers(),
 ): OffTheRecordResult {
+  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)) {
+    // Matched folded, stored as written: the transcript keeps the ASR's own
+    // bytes while a decomposed or Turkic-uppercase spelling still reaches
+    // the marker.
+    const probe = foldForMatching(segment.text);
+    if (!offRecord && markers.start.test(probe)) {
       offRecord = true;
       segments.push({
         ...segment,
@@ -136,7 +228,7 @@ export function applyOffTheRecord(
       continue;
     }
     if (offRecord) {
-      if (BACK_ON_THE_RECORD.test(segment.text)) {
+      if (markers.end?.test(probe)) {
         offRecord = false;
         segments.push({
           ...segment,

package/src/wearables/text-language.ts

@@ -0,0 +1,146 @@
+/**
+ * Script-aware text helpers shared by wearable cleanup and redaction.
+ *
+ * Both features were written for space-delimited English. A spoken
+ * marker phrase or a filler token in Japanese, Korean, Chinese, Arabic,
+ * or Russian never matched, so a privacy feature silently did nothing
+ * (issue #2196). These helpers make phrase matching correct for scripts
+ * that do not separate words with spaces.
+ */
+
+/** Coarse script class used to select built-in token sets. */
+export type ScriptHint =
+  | "latin"
+  | "japanese"
+  | "han"
+  | "korean"
+  | "arabic"
+  | "cyrillic";
+
+/**
+ * Whether a phrase edge needs a word boundary is decided per EDGE and per
+ * script, because scripts attach material at different ends.
+ *
+ * Leading edge: guarded for every script that spaces its words, so a
+ * marker cannot match at the tail of a longer word — Korean `기록` must
+ * not fire inside `신기록`, Arabic `خاص` must not fire inside `أشخاص`.
+ * Arabic and Hebrew additionally write single-letter proclitics (`و`,
+ * `ف`, `ב`, `ל`) with no space, so their guard admits ONE such letter
+ * when that letter itself starts a word: `وبدون تسجيل` still reaches the
+ * built-in `بدون تسجيل`.
+ *
+ * Trailing edge: guarded for the space-delimited scripts, so `بدون تسجيل`
+ * does not match inside `بدون تسجيلات`. Hangul is excluded — Korean
+ * particles attach to the END of a word, and guarding there would stop
+ * `기록을` from matching `기록`.
+ *
+ * Han and Kana running text has no boundary at either end: requiring one
+ * is the bug that made every non-Latin marker unreachable.
+ */
+const PREFIXABLE_EDGE_CHAR =
+  /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Hangul}\p{N}]/u;
+const SUFFIXABLE_EDGE_CHAR =
+  /[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Script=Arabic}\p{Script=Hebrew}\p{N}\p{M}]/u;
+const PROCLITIC_EDGE_CHAR = /[\p{Script=Arabic}\p{Script=Hebrew}]/u;
+
+/**
+ * Single-letter proclitics that attach to the following word in Arabic
+ * and Hebrew. Kept to the unambiguous conjunctions and prepositions;
+ * a longer prefix is a different word, not a clitic.
+ */
+const PROCLITIC_LETTERS = "وفبكلسהוכלמשב";
+
+/**
+ * Combining marks count as word characters. Without `\p{M}` a decomposed
+ * `café` (base `e` plus U+0301) would let the phrase `cafe` match its
+ * prefix and elide a span nobody marked.
+ */
+const BOUNDARY_LOOKBEHIND = "(?<![\\p{L}\\p{M}\\p{N}])";
+const BOUNDARY_LOOKAHEAD = "(?![\\p{L}\\p{M}\\p{N}])";
+/** Word start, or exactly one word-initial proclitic before the phrase. */
+const PROCLITIC_LOOKBEHIND = `(?:${BOUNDARY_LOOKBEHIND}|(?<=${BOUNDARY_LOOKBEHIND}[${PROCLITIC_LETTERS}]))`;
+
+const HAS_KANA = /[\p{Script=Hiragana}\p{Script=Katakana}]/u;
+const HAS_HAN = /\p{Script=Han}/u;
+const HAS_HANGUL = /\p{Script=Hangul}/u;
+const HAS_ARABIC = /\p{Script=Arabic}/u;
+const HAS_CYRILLIC = /\p{Script=Cyrillic}/u;
+
+/**
+ * Normalize text for phrase matching: NFC, then fold the Turkic dotted and
+ * dotless I onto plain `i`.
+ *
+ * JavaScript's `/iu` folding is locale-independent, so it equates `i` with
+ * `I` but never `ı` with `I` or `i` with `İ`. A Turkish marker such as
+ * `kayıt dışı` would therefore miss an uppercase `KAYIT DIŞI` transcript and
+ * leave the span on the record. Both sides of the comparison run through
+ * this, so the fold cannot make one side drift from the other.
+ */
+export function foldForMatching(text: string): string {
+  return text.normalize("NFC").replace(/[\u0131\u0130I]/g, "i");
+}
+
+/**
+ * Report which script-specific token sets apply to `text`.
+ *
+ * `latin` is always present: transcripts mix scripts freely, and the
+ * Latin filler tokens are whole-token matches that cannot fire inside
+ * non-Latin text. Japanese wins over Han when kana are present, because
+ * Japanese text also contains Han characters.
+ */
+export function detectScriptHints(text: string): ScriptHint[] {
+  const hints: ScriptHint[] = ["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 escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Compile `phrases` into one case-insensitive matcher, or `null` when
+ * no usable phrase remains.
+ *
+ * Internal whitespace matches any whitespace run, so a transcript that
+ * breaks a phrase across a line still matches. Letter boundaries are
+ * added per edge, and only when that edge is a space-delimited script.
+ */
+export function buildPhraseMatcher(
+  phrases: readonly string[],
+): RegExp | null {
+  const parts: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of phrases) {
+    if (typeof raw !== "string") continue;
+    // Folded on both sides (the tester folds its input too): an ASR that
+    // emits decomposed or Turkic-uppercase text would otherwise never match
+    // its marker, and the span would be persisted (issue #2196).
+    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) => escapeRegExp(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");
+}

package/src/wearables/types.ts

@@ -241,6 +241,20 @@ export interface WearableCorrectionRule {
   sources?: string[];
 }
 
+/**
+ * Off-the-record marker configuration (issue #2196). Matching is
+ * case-insensitive and phrase-level. Built-in phrases stay active
+ * unless `useBuiltIns` is false.
+ */
+export interface OffTheRecordMarkerSettings {
+  /** Extra phrases that begin an off-the-record span. */
+  start: string[];
+  /** Extra phrases that end an off-the-record span. */
+  end: string[];
+  /** Include the built-in phrase lists. Default true. */
+  useBuiltIns: boolean;
+}
+
 /** Top-level wearables configuration (parsed). */
 export interface WearablesConfig {
   /** Master gate for the whole subsystem. Default false. */
@@ -259,6 +273,18 @@ export interface WearablesConfig {
    * "back on the record" (or conversation end). Default false.
    */
   offTheRecordEnabled: boolean;
+  /**
+   * Off-the-record marker phrases (issue #2196). Built-in phrases cover
+   * a documented set of languages; `start`/`end` add more, and
+   * `useBuiltIns: false` uses only the configured phrases.
+   */
+  offTheRecordMarkers: OffTheRecordMarkerSettings;
+  /**
+   * Extra filler tokens removed when a source enables
+   * `cleanup.stripFillers`. Built-in tokens are selected per script; a
+   * language outside that set is configured here.
+   */
+  fillerTokens: string[];
   /**
    * Write one compact daily-digest memory per synced source/day.
    * Default false.

package/dist/chunk-NDAH7BJ5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/wearables/corrections.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 * 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 type { WearableConversation } 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\nconst OFF_THE_RECORD = /\\boff\\s+the\\s+record\\b/i;\nconst BACK_ON_THE_RECORD = /\\b(?:back\\s+)?on\\s+the\\s+record\\b/i;\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\n * segments themselves are kept, with the off-record span replaced by a\n * visible placeholder so the transcript shows that content was elided\n * by request rather than lost.\n */\nexport function applyOffTheRecord(\n  conversation: WearableConversation,\n): OffTheRecordResult {\n  let offRecord = false;\n  let droppedSegments = 0;\n  const segments = [];\n  for (const segment of conversation.segments) {\n    if (!offRecord && OFF_THE_RECORD.test(segment.text)) {\n      offRecord = true;\n      segments.push({\n        ...segment,\n        text: \"[off the record — segment elided]\",\n      });\n      continue;\n    }\n    if (offRecord) {\n      if (BACK_ON_THE_RECORD.test(segment.text)) {\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":[]}