@remnic/core 9.4.0 → 9.4.2

package/src/runtime/better-sqlite.test.ts

@@ -4,6 +4,7 @@ import {
   displayErrorDetail,
   isLikelyBetterSqlite3NativeBindingError,
   openBetterSqlite3,
+  probeBetterSqlite3Driver,
 } from "./better-sqlite.js";
 
 test("isLikelyBetterSqlite3NativeBindingError recognizes missing and mismatched native bindings", () => {
@@ -22,6 +23,50 @@ test("isLikelyBetterSqlite3NativeBindingError recognizes missing and mismatched
   assert.equal(isLikelyBetterSqlite3NativeBindingError(new Error("SQLITE_BUSY: database is locked")), false);
 });
 
+test("isLikelyBetterSqlite3NativeBindingError walks the cause chain of a sanitized wrapper (issue #1848)", () => {
+  // Production path: loadBetterSqlite3() catches the ABI error and re-throws a
+  // sanitized unavailableError WRAPPER whose message drops the ABI markers. The
+  // original error survives only on .cause — the classifier must walk it, or
+  // the startup probe / projection doctor / browse warn all MISS the hint.
+  const abiCause = new Error(
+    "The module was compiled against a different Node.js version using NODE_MODULE_VERSION 127",
+  );
+  const wrapper = new Error(
+    "better-sqlite3 is unavailable. Remnic attempted to load the native SQLite binding and could not.",
+    { cause: abiCause },
+  );
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(wrapper), true);
+
+  // Deeply nested wrapper (wrapper.cause.cause = ABI error) is still found.
+  const deepWrapper = new Error("outer sanitized layer", { cause: wrapper });
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(deepWrapper), true);
+
+  // A wrapper whose cause is NOT a native-binding failure stays negative.
+  const benignWrapper = new Error("better-sqlite3 is unavailable.", {
+    cause: new Error("SQLITE_BUSY: database is locked"),
+  });
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(benignWrapper), false);
+});
+
+test("isLikelyBetterSqlite3NativeBindingError inspects AggregateError.errors siblings", () => {
+  // Module loaders can surface failures as an AggregateError; the ABI mismatch
+  // may live in a sibling rather than the aggregate's own message.
+  const agg = new AggregateError([
+    new Error("some unrelated loader step"),
+    new Error("Could not locate the bindings file. Tried: better_sqlite3.node"),
+  ]);
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(agg), true);
+
+  const benignAgg = new AggregateError([new Error("unrelated"), new Error("SQLITE_BUSY")]);
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(benignAgg), false);
+});
+
+test("isLikelyBetterSqlite3NativeBindingError is cycle-safe on a self-referential cause", () => {
+  const cyclic = new Error("SQLITE_BUSY: database is locked");
+  cyclic.cause = cyclic; // would loop forever without a visited set
+  assert.equal(isLikelyBetterSqlite3NativeBindingError(cyclic), false);
+});
+
 test("displayErrorDetail surfaces only error class + code, never the raw message (CodeQL js/stack-trace-exposure)", () => {
   // MODULE_NOT_FOUND messages embed an absolute "Require stack:" path block.
   const moduleNotFound = Object.assign(
@@ -59,3 +104,12 @@ test("openBetterSqlite3 can open an in-memory database after install verificatio
     db.close();
   }
 });
+
+test("probeBetterSqlite3Driver succeeds (ok=true) under the verified process and warms the ctor cache", () => {
+  const probe = probeBetterSqlite3Driver();
+  assert.equal(probe.ok, true);
+  assert.equal(probe.detail, "");
+  assert.equal(probe.nativeBindingMismatch, false);
+  // A second probe reuses the warmed cache (no re-load); still ok.
+  assert.equal(probeBetterSqlite3Driver().ok, true);
+});

package/src/runtime/better-sqlite.ts

@@ -28,6 +28,35 @@ export function openBetterSqlite3(
   return new Database(file, options);
 }
 
+export interface BetterSqlite3DriverProbe {
+  /** true when the native binding loaded successfully under this process. */
+  ok: boolean;
+  /** Path-free detail string (class + code) from `displayErrorDetail`; "" when ok. */
+  detail: string;
+  /** true when the failure is classified as a native-binding ABI mismatch. */
+  nativeBindingMismatch: boolean;
+}
+
+/**
+ * Attempt to load the better-sqlite3 native driver under the running process
+ * WITHOUT opening a database. Used by the server startup check (issue #1829)
+ * to surface a wrong-ABI build loudly instead of letting each memory browse
+ * silently fall back to a full-corpus scan. Never throws — callers log the
+ * result. A successful probe also warms the ctor cache for later opens.
+ */
+export function probeBetterSqlite3Driver(): BetterSqlite3DriverProbe {
+  try {
+    loadBetterSqlite3();
+    return { ok: true, detail: "", nativeBindingMismatch: false };
+  } catch (error) {
+    return {
+      ok: false,
+      detail: displayErrorDetail(error),
+      nativeBindingMismatch: isLikelyBetterSqlite3NativeBindingError(error),
+    };
+  }
+}
+
 function requireBetterSqlite3Ctor(require: RuntimeRequire): BetterSqlite3Ctor {
   const loaded = require("better-sqlite3") as
     | BetterSqlite3Ctor
@@ -50,9 +79,49 @@ function rawErrorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error ?? "");
 }
 
-export function isLikelyBetterSqlite3NativeBindingError(error: unknown): boolean {
-  // Classify on the RAW message so redaction can't strip detection markers
-  // (e.g. the path containing "better_sqlite3.node").
+/**
+ * Iterate an error and every node reachable along its `cause` chain and any
+ * `AggregateError.errors` siblings (depth-first), cycle-safe via a visited set.
+ *
+ * Native-binding failures thrown from openBetterSqlite3 /
+ * probeBetterSqlite3Driver are caught and re-thrown as a sanitized
+ * `unavailableError` WRAPPER: the wrapper's message drops the ABI markers
+ * (NODE_MODULE_VERSION, better_sqlite3.node, …) that live on the ORIGINAL
+ * error. So classification must walk `.cause` (and aggregate siblings) instead
+ * of inspecting only the top wrapper's message — otherwise startup logs, browse
+ * warnings, and the memory_projection doctor check all MISS the native-binding
+ * hint (issue #1848).
+ */
+function* errorChain(error: unknown): Generator<unknown> {
+  const seen = new Set<unknown>();
+  const stack: unknown[] = [error];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || node === undefined) continue;
+    if (typeof node !== "object") continue;
+    if (seen.has(node)) continue;
+    seen.add(node);
+    yield node;
+    // Narrow with `in` (not a cast) so the property access is compiler-checked.
+    if ("cause" in node) {
+      const cause = node.cause;
+      if (cause !== null && cause !== undefined) stack.push(cause);
+    }
+    if ("errors" in node) {
+      const errors = node.errors;
+      if (Array.isArray(errors)) {
+        for (const member of errors) {
+          if (member !== null && member !== undefined) stack.push(member);
+        }
+      }
+    }
+  }
+}
+
+// True when a single error's RAW message carries a native-binding ABI marker.
+// Raw (not displayErrorDetail) so redaction can't strip detection markers
+// (e.g. the loader path containing "better_sqlite3.node").
+function messageHasNativeBindingMarker(error: unknown): boolean {
   const detail = rawErrorMessage(error);
   return (
     detail.includes("Could not locate the bindings file") ||
@@ -63,6 +132,17 @@ export function isLikelyBetterSqlite3NativeBindingError(error: unknown): boolean
   );
 }
 
+export function isLikelyBetterSqlite3NativeBindingError(error: unknown): boolean {
+  // Walk the full cause / aggregate chain so a SANITIZED wrapper
+  // (unavailableError) — whose message drops the ABI markers that live on the
+  // original error — is still classified. Inspecting only the top-level message
+  // misses the real mismatch when the failure was wrapped (issue #1848).
+  for (const node of errorChain(error)) {
+    if (messageHasNativeBindingMarker(node)) return true;
+  }
+  return false;
+}
+
 function unavailableError(error: unknown): Error {
   const detail = displayErrorDetail(error);
   const nativeBindingHint = isLikelyBetterSqlite3NativeBindingError(error)

package/src/wearables/cleanup.test.ts

@@ -132,3 +132,59 @@ test("input conversation is not mutated", () => {
   cleanConversation(input, ALL_ON);
   assert.equal(JSON.stringify(input), before);
 });
+
+
+test("merges consecutive same-speaker runs across diarized speakers", () => {
+  const result = cleanConversation(
+    conversation([
+      { speakerKey: "0", text: "Hello there.", startIso: "2026-06-10T10:00:00Z", endIso: "2026-06-10T10:00:03Z" },
+      { speakerKey: "0", text: "How are you?", startIso: "2026-06-10T10:00:04Z", endIso: "2026-06-10T10:00:07Z" },
+      { speakerKey: "1", text: "Good, thanks.", startIso: "2026-06-10T10:00:08Z", endIso: "2026-06-10T10:00:11Z" },
+      { speakerKey: "1", text: "And you?", startIso: "2026-06-10T10:00:12Z", endIso: "2026-06-10T10:00:14Z" },
+      { speakerKey: "0", text: "Busy day.", startIso: "2026-06-10T10:00:15Z", endIso: "2026-06-10T10:00:18Z" },
+    ]),
+    ALL_ON,
+  );
+  // Three runs: 0+0, 1+1, 0. Generic-label protection is off here, so
+  // diarized same-speaker adjacency merges within the gap.
+  assert.equal(result.conversation.segments.length, 3);
+  assert.equal(result.conversation.segments[0].text, "Hello there. How are you?");
+  assert.equal(result.conversation.segments[1].text, "Good, thanks. And you?");
+  assert.equal(result.conversation.segments[2].text, "Busy day.");
+  assert.equal(result.mergedSegments, 2);
+});
+
+test("preserveUtteranceBoundaries keeps generic-labeled utterances distinct (#1811)", () => {
+  const settings: WearableCleanupSettings = { ...ALL_ON, preserveUtteranceBoundaries: true };
+  const result = cleanConversation(
+    conversation([
+      { speakerKey: "unknown", text: "First.", startIso: "2026-06-10T10:00:00Z", endIso: "2026-06-10T10:00:02Z" },
+      { speakerKey: "unknown", text: "Second.", startIso: "2026-06-10T10:00:03Z", endIso: "2026-06-10T10:00:05Z" },
+      { speakerKey: "Unknown", text: "Third.", startIso: "2026-06-10T10:00:06Z", endIso: "2026-06-10T10:00:08Z" },
+      { speakerKey: "0", text: "Diarized A.", startIso: "2026-06-10T10:00:09Z", endIso: "2026-06-10T10:00:11Z" },
+      { speakerKey: "0", text: "Diarized B.", startIso: "2026-06-10T10:00:12Z", endIso: "2026-06-10T10:00:14Z" },
+    ]),
+    settings,
+  );
+  // Generic "unknown"/"Unknown" utterances are NOT merged into one block.
+  assert.equal(result.conversation.segments.length, 4);
+  assert.deepEqual(
+    result.conversation.segments.map((segment) => segment.text),
+    ["First.", "Second.", "Third.", "Diarized A. Diarized B."],
+  );
+  assert.equal(result.mergedSegments, 1);
+});
+
+test("preserveUtteranceBoundaries default (off) still collapses generic labels", () => {
+  // The flag is opt-in: without it the legacy merge-everything behavior
+  // is unchanged for sources that never set it.
+  const result = cleanConversation(
+    conversation([
+      { speakerKey: "unknown", text: "First.", startIso: "2026-06-10T10:00:00Z", endIso: "2026-06-10T10:00:02Z" },
+      { speakerKey: "unknown", text: "Second.", startIso: "2026-06-10T10:00:03Z", endIso: "2026-06-10T10:00:05Z" },
+    ]),
+    ALL_ON,
+  );
+  assert.equal(result.conversation.segments.length, 1);
+  assert.equal(result.conversation.segments[0].text, "First. Second.");
+});

package/src/wearables/cleanup.ts

@@ -24,6 +24,14 @@ export interface CleanupResult {
 /** Merge consecutive same-speaker segments when gaps are below this. */
 const MERGE_GAP_MS = 30_000;
 
+/**
+ * Speaker labels that carry no real diarization signal. Bee (and other
+ * providers that fall back to a placeholder) emit "Unknown"/"unknown"
+ * or an empty string when diarization is unavailable; merging on such a
+ * label would collapse an entire conversation into one segment (issue #1811).
+ */
+const GENERIC_SPEAKER_PATTERN = /^unknown$/i;
+
 /**
  * Standalone filler tokens stripped when `stripFillers` is on. Matched
  * case-insensitively on word boundaries, only as whole tokens — "um"
@@ -47,6 +55,9 @@ export function cleanConversation(
   let segments = conversation.segments.map((segment) => ({ ...segment }));
   let droppedSegments = 0;
   let mergedSegments = 0;
+  // Optional on the type so other connectors keep the legacy no-op
+  // default; absent means "off" (unchanged merge behavior).
+  const preserveBoundaries = settings.preserveUtteranceBoundaries === true;
 
   if (settings.stripFillers) {
     for (const segment of segments) {
@@ -86,7 +97,7 @@ export function cleanConversation(
     const merged: WearableTranscriptSegment[] = [];
     for (const segment of segments) {
       const previous = merged[merged.length - 1];
-      if (previous && canMerge(previous, segment)) {
+      if (previous && canMerge(previous, segment, preserveBoundaries)) {
         previous.text = `${previous.text} ${segment.text}`.trim();
         if (segment.endIso) previous.endIso = segment.endIso;
         mergedSegments += 1;
@@ -107,8 +118,18 @@ export function cleanConversation(
 function canMerge(
   previous: WearableTranscriptSegment,
   next: WearableTranscriptSegment,
+  preserveUtteranceBoundaries: boolean,
 ): boolean {
   if (previous.speakerKey !== next.speakerKey) return false;
+  // A generic/low-confidence speaker label ("Unknown", empty) carries no
+  // real diarization: merging on it collapses unrelated utterances. When
+  // the source opts into boundary preservation, refuse to merge across
+  // such a label (issue #1811). The keys are equal here, so checking one
+  // suffices; diarized labels still merge normally.
+  if (preserveUtteranceBoundaries) {
+    const label = previous.speakerKey.trim();
+    if (label.length === 0 || GENERIC_SPEAKER_PATTERN.test(label)) return false;
+  }
   const previousEnd = previous.endIso ? Date.parse(previous.endIso) : NaN;
   const nextStart = next.startIso ? Date.parse(next.startIso) : NaN;
   // Without timestamps, adjacency is the only signal — still merge.

package/src/wearables/config.test.ts

@@ -44,9 +44,34 @@ test("source settings default to the fully-automated smart pipeline", () => {
     stripFillers: true,
     collapseRepeats: true,
     dropLowQuality: true,
+    // Opt-in for Bee only; limitless keeps the legacy default (issue #1811).
+    preserveUtteranceBoundaries: false,
   });
 });
 
+test("bee source defaults to preserving utterance boundaries (#1811)", () => {
+  const parsed = parseWearablesConfig({
+    enabled: true,
+    sources: { bee: { enabled: true } },
+  });
+  assert.equal(parsed.sources.bee.cleanup.preserveUtteranceBoundaries, true);
+});
+
+test("cleanup.preserveUtteranceBoundaries is parsed and overrides the source default", () => {
+  const parsed = parseWearablesConfig({
+    enabled: true,
+    sources: { bee: { enabled: true, cleanup: { preserveUtteranceBoundaries: false } } },
+  });
+  assert.equal(parsed.sources.bee.cleanup.preserveUtteranceBoundaries, false);
+  assert.throws(
+    () =>
+      parseWearablesConfig({
+        sources: { bee: { cleanup: { preserveUtteranceBoundaries: "maybe" } } },
+      }),
+    /cleanup.preserveUtteranceBoundaries/,
+  );
+});
+
 test("top-level defaults are full-featured: digest and off-the-record on", () => {
   const parsed = parseWearablesConfig({});
   assert.equal(parsed.digestEnabled, true);

package/src/wearables/config.ts

@@ -48,16 +48,35 @@ const DEFAULT_SOURCE_TRUST = 0.8;
 const DEFAULT_AUTO_APPROVE_TRUST = 0.7;
 const DEFAULT_REVIEW_TRUST = 0.45;
 
-export function defaultWearableCleanupSettings(): WearableCleanupSettings {
+// Sources whose provider emits per-utterance text but unreliable
+// speaker labels (Bee falls back to a generic "unknown" label when
+// diarization is unavailable). For those, the cleanup default keeps
+// utterance-level boundaries so a whole conversation does not collapse
+// into one mega-segment (issue #1811). Other sources keep the legacy
+// merge-everything default unless explicitly configured.
+const BOUNDARY_PRESERVING_SOURCE_IDS = new Set<string>(["bee"]);
+
+/**
+ * Default cleanup settings. `sourceId` (the connector id this block
+ * belongs to) only adjusts the `preserveUtteranceBoundaries` default —
+ * every other toggle is identical across sources.
+ */
+export function defaultWearableCleanupSettings(
+  sourceId?: string,
+): WearableCleanupSettings {
   return {
     mergeSameSpeaker: true,
     stripFillers: true,
     collapseRepeats: true,
     dropLowQuality: true,
+    preserveUtteranceBoundaries:
+      sourceId !== undefined && BOUNDARY_PRESERVING_SOURCE_IDS.has(sourceId),
   };
 }
 
-export function defaultWearableSourceSettings(): WearableSourceSettings {
+export function defaultWearableSourceSettings(
+  sourceId?: string,
+): WearableSourceSettings {
   return {
     enabled: false,
     memoryMode: "smart",
@@ -68,7 +87,7 @@ export function defaultWearableSourceSettings(): WearableSourceSettings {
     minImportance: DEFAULT_MIN_IMPORTANCE,
     maxMemoriesPerDay: DEFAULT_MAX_MEMORIES_PER_DAY,
     importNativeMemories: "smart",
-    cleanup: defaultWearableCleanupSettings(),
+    cleanup: defaultWearableCleanupSettings(sourceId),
   };
 }
 
@@ -184,9 +203,10 @@ function parseCorrectionRules(
 function parseSourceSettings(
   value: unknown,
   keyPath: string,
+  sourceId: string,
 ): WearableSourceSettings {
   const raw = requireObject(value, keyPath);
-  const defaults = defaultWearableSourceSettings();
+  const defaults = defaultWearableSourceSettings(sourceId);
 
   const minConfidenceRaw = coerceNumber(raw.minConfidence);
   // Out-of-range values reject loudly instead of clamping — silently
@@ -266,6 +286,12 @@ function parseSourceSettings(
       `${keyPath}.cleanup.dropLowQuality`,
       defaults.cleanup.dropLowQuality,
     ),
+    preserveUtteranceBoundaries: parseBool(
+      rawCleanup.preserveUtteranceBoundaries,
+      `${keyPath}.cleanup.preserveUtteranceBoundaries`,
+      // Optional on the type; the per-source default is always concrete.
+      defaults.cleanup.preserveUtteranceBoundaries ?? false,
+    ),
   };
 
   return {
@@ -397,6 +423,7 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
       sources[sourceId] = parseSourceSettings(
         sourceValue,
         `wearables.sources.${sourceId}`,
+        sourceId,
       );
     }
   }

package/src/wearables/types.ts

@@ -210,6 +210,18 @@ export interface WearableCleanupSettings {
    * sync summary and excluded from memory extraction.
    */
   dropLowQuality: boolean;
+  /**
+   * Keep utterance-level boundaries for segments whose speaker label
+   * carries no real diarization signal (generic labels like "Unknown"
+   * or empty). When `mergeSameSpeaker` is also on, such segments are
+   * left distinct instead of collapsing into one block — a whole
+   * conversation of per-utterance text under a single generic label
+   * otherwise merges into one mega-segment (issue #1811). Sources whose
+   * provider emits reliable per-utterance text but unreliable speaker
+   * labels (Bee) default this on; others default off so existing merge
+   * behavior is unchanged unless explicitly configured.
+   */
+  preserveUtteranceBoundaries?: boolean;
 }
 
 /** A single user-specific transcript correction rule. */
@@ -337,4 +349,3 @@ export interface WearableSourceStatus {
   lastDateSynced: string | null;
   transcriptDays: number;
 }
-