@remnic/core 9.52.2 → 9.54.0

package/src/wearables/config.test.ts

@@ -277,3 +277,65 @@ test("fusion knobs reject non-positive integers", () => {
 test("fusion block must be an object when present", () => {
   assert.throws(() => parseWearablesConfig({ fusion: "on" }), /must be an object/);
 });
+
+test("off-the-record marker phrases and filler tokens parse", () => {
+  const parsed = parseWearablesConfig({
+    offTheRecordMarkers: {
+      start: ["  poza protokołem  "],
+      end: ["z powrotem do protokołu"],
+    },
+    fillerTokens: ["bueno", "那个"],
+  });
+  assert.deepEqual(parsed.offTheRecordMarkers.start, ["poza protokołem"]);
+  assert.deepEqual(parsed.offTheRecordMarkers.end, ["z powrotem do protokołu"]);
+  assert.equal(parsed.offTheRecordMarkers.useBuiltIns, true);
+  assert.deepEqual(parsed.fillerTokens, ["bueno", "那个"]);
+});
+
+test("marker and filler lists reject unusable entries loudly", () => {
+  assert.throws(
+    () => parseWearablesConfig({ offTheRecordMarkers: { start: "poza" } }),
+    /offTheRecordMarkers\.start must be an array of strings/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ offTheRecordMarkers: { end: ["  "] } }),
+    /offTheRecordMarkers\.end\[0\] must be a non-empty string/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ fillerTokens: ["a".repeat(65)] }),
+    /fillerTokens\[0\] exceeds 64 characters/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ offTheRecordMarkers: { start: ["a".repeat(129)] } }),
+    /offTheRecordMarkers\.start\[0\] exceeds 128 characters/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ offTheRecordMarkers: [] }),
+    /offTheRecordMarkers must be an object/,
+  );
+});
+
+test("disabling built-in markers without a start phrase is rejected, not silent", () => {
+  assert.throws(
+    () =>
+      parseWearablesConfig({
+        offTheRecordEnabled: true,
+        offTheRecordMarkers: { useBuiltIns: false },
+      }),
+    /useBuiltIns is false but no start phrase is configured/,
+  );
+  // Turning the whole feature off is the documented escape hatch.
+  const parsed = parseWearablesConfig({
+    offTheRecordEnabled: false,
+    offTheRecordMarkers: { useBuiltIns: false },
+  });
+  assert.equal(parsed.offTheRecordEnabled, false);
+  assert.equal(parsed.offTheRecordMarkers.useBuiltIns, false);
+});
+
+test("an unknown off-the-record marker key is rejected, not dropped", () => {
+  assert.throws(
+    () => parseWearablesConfig({ offTheRecordMarkers: { starts: ["private"] } }),
+    /offTheRecordMarkers has unknown key\(s\) starts/,
+  );
+});

package/src/wearables/config.ts

@@ -13,6 +13,7 @@ import type { ImportanceLevel } from "../types.js";
 import { compileCorrectionRules } from "./corrections.js";
 import { compileRedactionPatterns } from "./redaction.js";
 import type {
+  OffTheRecordMarkerSettings,
   WearableCleanupSettings,
   WearableCorrectionRule,
   WearableMemoryMode,
@@ -111,6 +112,8 @@ export function defaultWearablesConfig(): WearablesConfig {
     redactionEnabled: true,
     redactionPatterns: [],
     offTheRecordEnabled: true,
+    offTheRecordMarkers: { start: [], end: [], useBuiltIns: true },
+    fillerTokens: [],
     digestEnabled: true,
     autoSyncEnabled: DEFAULT_AUTO_SYNC_ENABLED,
     autoSyncIntervalMinutes: DEFAULT_AUTO_SYNC_INTERVAL_MINUTES,
@@ -134,6 +137,37 @@ function requireObject(
   return value as Record<string, unknown>;
 }
 
+/** Longest accepted off-the-record marker phrase. */
+const MAX_MARKER_PHRASE_LENGTH = 128;
+/** Longest accepted filler token. */
+const MAX_FILLER_TOKEN_LENGTH = 64;
+
+/**
+ * Parse an optional array of non-empty phrases. Rejects a non-array, a
+ * non-string entry, a blank entry, and an over-long entry — an operator
+ * privacy phrase that is silently discarded is the failure this parser
+ * exists to prevent (issue #2196).
+ */
+function parsePhraseList(
+  value: unknown,
+  keyPath: string,
+  maxLength: number,
+): string[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(`${keyPath} must be an array of strings`);
+  }
+  return value.map((entry, index) => {
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+      throw new Error(`${keyPath}[${index}] must be a non-empty string`);
+    }
+    if (entry.length > maxLength) {
+      throw new Error(`${keyPath}[${index}] exceeds ${maxLength} characters`);
+    }
+    return entry.trim();
+  });
+}
+
 function parseBool(
   value: unknown,
   keyPath: string,
@@ -411,6 +445,68 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
     compileRedactionPatterns(redactionPatterns);
   }
 
+  const offTheRecordEnabled = parseBool(
+    raw.offTheRecordEnabled,
+    "wearables.offTheRecordEnabled",
+    defaults.offTheRecordEnabled,
+  );
+  const rawMarkers =
+    raw.offTheRecordMarkers === undefined
+      ? {}
+      : requireObject(raw.offTheRecordMarkers, "wearables.offTheRecordMarkers");
+  // A typo such as `starts:` would otherwise be dropped without a word,
+  // and the operator would believe a private span is protected. Core and
+  // standalone callers never see OpenClaw's JSON schema, so the check
+  // belongs here. Keys are compared literally so the config-contract
+  // extractor can still enumerate this parser's surface.
+  const {
+    start: rawMarkerStart,
+    end: rawMarkerEnd,
+    useBuiltIns: rawMarkerUseBuiltIns,
+    ...unknownMarkerKeys
+  } = rawMarkers;
+  const unknownMarkerNames = Object.keys(unknownMarkerKeys);
+  if (unknownMarkerNames.length > 0) {
+    throw new Error(
+      `wearables.offTheRecordMarkers has unknown key(s) ${unknownMarkerNames.sort().join(", ")} — valid keys are start, end, useBuiltIns`,
+    );
+  }
+  const offTheRecordMarkers: OffTheRecordMarkerSettings = {
+    start: parsePhraseList(
+      rawMarkerStart,
+      "wearables.offTheRecordMarkers.start",
+      MAX_MARKER_PHRASE_LENGTH,
+    ),
+    end: parsePhraseList(
+      rawMarkerEnd,
+      "wearables.offTheRecordMarkers.end",
+      MAX_MARKER_PHRASE_LENGTH,
+    ),
+    useBuiltIns: parseBool(
+      rawMarkerUseBuiltIns,
+      "wearables.offTheRecordMarkers.useBuiltIns",
+      defaults.offTheRecordMarkers.useBuiltIns,
+    ),
+  };
+  // A silent no-op is the exact failure this feature exists to remove
+  // (issue #2196): turning the built-ins off without supplying a start
+  // phrase would leave the gate on and matching nothing.
+  if (
+    offTheRecordEnabled &&
+    !offTheRecordMarkers.useBuiltIns &&
+    offTheRecordMarkers.start.length === 0
+  ) {
+    throw new Error(
+      "wearables.offTheRecordMarkers.useBuiltIns is false but no start phrase is configured — add wearables.offTheRecordMarkers.start, or set wearables.offTheRecordEnabled to false",
+    );
+  }
+
+  const fillerTokens = parsePhraseList(
+    raw.fillerTokens,
+    "wearables.fillerTokens",
+    MAX_FILLER_TOKEN_LENGTH,
+  );
+
   const parseBoundedInt = (
     value: unknown,
     name: string,
@@ -488,11 +584,9 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
       defaults.redactionEnabled,
     ),
     redactionPatterns,
-    offTheRecordEnabled: parseBool(
-      raw.offTheRecordEnabled,
-      "wearables.offTheRecordEnabled",
-      defaults.offTheRecordEnabled,
-    ),
+    offTheRecordEnabled,
+    offTheRecordMarkers,
+    fillerTokens,
     digestEnabled: parseBool(
       raw.digestEnabled,
       "wearables.digestEnabled",

package/src/wearables/index.ts

@@ -35,10 +35,20 @@ export {
 } from "./cleanup.js";
 export {
   applyOffTheRecord,
+  BUILT_IN_OFF_THE_RECORD_END,
+  BUILT_IN_OFF_THE_RECORD_START,
+  compileOffTheRecordMarkers,
   compileRedactionPatterns,
   redactText,
   REDACTION_PLACEHOLDER,
+  type CompiledOffTheRecordMarkers,
+  type OffTheRecordMarkerInput,
 } from "./redaction.js";
+export {
+  buildPhraseMatcher,
+  detectScriptHints,
+  type ScriptHint,
+} from "./text-language.js";
 export {
   applyCorrections,
   compileCorrectionRule,

package/src/wearables/pipeline.test.ts

@@ -1039,3 +1039,39 @@ test("a transcript write failure prevents the sync watermark from advancing", as
     rmSync(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("configured non-English off-the-record markers elide a span end to end", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-pipeline-otr-"));
+  try {
+    const byDate = {
+      "2026-06-11": [
+        makeConversation("c1", "2026-06-11", [
+          { speaker: "user", isWearer: true, text: "えーと、ここからはオフレコでお願いします。" },
+          { speaker: "Speaker 2", text: "買収の金額は非公開です。" },
+          { speaker: "user", isWearer: true, text: "オンレコに戻ります。" },
+          { speaker: "Speaker 2", text: "bueno, 天気の話をしましょう。" },
+        ]),
+      ],
+    };
+    const { deps, written } = makeDeps(memoryDir);
+    const summary = await syncWearableSource(
+      fakeConnector(byDate),
+      settings({ memoryMode: "off" }),
+      config({ offTheRecordEnabled: true, fillerTokens: ["bueno"] }),
+      { days: 1 },
+      deps,
+    );
+
+    assert.equal(summary.transcriptsWritten.length, 1);
+    const body = written[0]?.serialized ?? "";
+    assert.ok(!body.includes("買収の金額は非公開です"), "off-record segment must not be stored");
+    assert.ok(body.includes("[off the record"), "elision placeholder is visible");
+    assert.ok(body.includes("[back on the record]"), "span closes on the Japanese end marker");
+    assert.ok(body.includes("天気の話をしましょう"), "on-record speech survives");
+    assert.ok(!body.includes("えーと"), "Japanese filler is stripped");
+    assert.ok(!body.includes("bueno"), "configured filler token is stripped");
+    assert.equal(summary.segmentsDropped, 1);
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/wearables/pipeline.ts

@@ -37,7 +37,13 @@ import {
   type WearableMemoryGenDeps,
 } from "./memory-gen.js";
 import { tokenizeDayBody, type CorroborationContext } from "./trust.js";
-import { applyOffTheRecord, compileRedactionPatterns, redactText } from "./redaction.js";
+import {
+  applyOffTheRecord,
+  compileOffTheRecordMarkers,
+  compileRedactionPatterns,
+  redactText,
+  type CompiledOffTheRecordMarkers,
+} from "./redaction.js";
 import { loadSpeakerRegistry } from "./speakers.js";
 import {
   loadSyncState,
@@ -259,6 +265,7 @@ function cleanDay(
   config: WearablesConfig,
   userRedaction: RegExp[],
   correctionRules: CompiledCorrectionRule[],
+  offTheRecordMarkers: CompiledOffTheRecordMarkers,
 ): CleanedDay {
   const { offTheRecordEnabled, redactionEnabled } = config;
   const out: CleanedDay = {
@@ -271,11 +278,15 @@ function cleanDay(
   for (const conversation of raw) {
     let current = conversation;
     if (offTheRecordEnabled) {
-      const otr = applyOffTheRecord(current);
+      const otr = applyOffTheRecord(current, offTheRecordMarkers);
       current = otr.conversation;
       out.segmentsDropped += otr.droppedSegments;
     }
-    const cleaned = cleanConversation(current, settings.cleanup);
+    const cleaned = cleanConversation(
+      current,
+      settings.cleanup,
+      config.fillerTokens,
+    );
     current = cleaned.conversation;
     out.segmentsDropped += cleaned.droppedSegments;
 
@@ -337,6 +348,9 @@ export async function syncWearableSource(
     ...compileCorrectionRules(stateRules, "state corrections"),
   ];
   const userRedaction = compileRedactionPatterns(config.redactionPatterns);
+  const offTheRecordMarkers = compileOffTheRecordMarkers(
+    config.offTheRecordMarkers,
+  );
 
   let syncState = await loadSyncState(deps.memoryDir);
   const previousState = syncState.sources[connector.id];
@@ -360,6 +374,7 @@ export async function syncWearableSource(
       config,
       userRedaction,
       correctionRules,
+      offTheRecordMarkers,
     );
     summary.conversations += cleaned.conversations.length;
     summary.segmentsKept += cleaned.segmentsKept;

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,