@remnic/core 9.3.624 → 9.3.626

package/src/cli.ts

@@ -5,6 +5,7 @@ import { createHash } from "node:crypto";
 import type { Readable, Writable } from "node:stream";
 import type { Orchestrator } from "./orchestrator.js";
 import { ThreadingManager } from "./threading.js";
+import { runWearablesCliCommand } from "./wearables/cli.js";
 import type {
   BehaviorSignalEvent,
   ContinuityIncidentRecord,
@@ -5017,6 +5018,192 @@ export function registerCli(
           }
         });
 
+      // Wearable transcript sources (Limitless / Bee / Omi). Every
+      // subcommand forwards to the shared runner in wearables/cli.ts so
+      // this host CLI and the standalone `remnic` CLI never fork
+      // behavior or formatting.
+      {
+        const wearablesCmd = cmd
+          .command("wearables")
+          .description(
+            "Wearable transcript sources (Limitless / Bee / Omi): sync, transcripts, search, speakers, corrections",
+          );
+        const forwardWearables = async (argv: string[]): Promise<void> => {
+          const code = await runWearablesCliCommand(
+            orchestrator.getWearablesService(),
+            argv,
+            { stdout: process.stdout, stderr: process.stderr },
+          );
+          if (code !== 0) process.exitCode = code;
+        };
+        const stringOpt = (options: Record<string, unknown>, key: string, flag: string): string[] =>
+          typeof options[key] === "string" && (options[key] as string).length > 0
+            ? [flag, options[key] as string]
+            : [];
+
+        wearablesCmd
+          .command("status")
+          .description("Show configured sources, connector availability, and last sync")
+          .option("--json", "JSON output")
+          .action(async (...args: unknown[]) => {
+            const options = (args[0] ?? {}) as Record<string, unknown>;
+            await forwardWearables(["status", ...(options.json === true ? ["--json"] : [])]);
+          });
+
+        wearablesCmd
+          .command("check <source>")
+          .description("Verify credentials/connectivity for a source")
+          .action(async (...args: unknown[]) => {
+            await forwardWearables(["check", String(args[0] ?? "")]);
+          });
+
+        wearablesCmd
+          .command("sync")
+          .description("Pull, clean, and store wearable transcripts (and trust-gated memories)")
+          .option("--source <id>", "Only this source (default: all enabled)")
+          .option("--date <date>", "Sync exactly this day (YYYY-MM-DD)")
+          .option("--days <n>", "Lookback window in days ending today (default 2)")
+          .option("--force-memories", "Re-run memory extraction for unchanged days")
+          .option("--json", "JSON output")
+          .action(async (...args: unknown[]) => {
+            const options = (args[0] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "sync",
+              ...stringOpt(options, "source", "--source"),
+              ...stringOpt(options, "date", "--date"),
+              ...stringOpt(options, "days", "--days"),
+              ...(options.forceMemories === true ? ["--force-memories"] : []),
+              ...(options.json === true ? ["--json"] : []),
+            ]);
+          });
+
+        wearablesCmd
+          .command("transcript")
+          .description("Print the stored transcript(s) for a day")
+          .requiredOption("--date <date>", "Day to read (YYYY-MM-DD)")
+          .option("--source <id>", "Scope to one source")
+          .action(async (...args: unknown[]) => {
+            const options = (args[0] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "transcript",
+              ...stringOpt(options, "date", "--date"),
+              ...stringOpt(options, "source", "--source"),
+            ]);
+          });
+
+        wearablesCmd
+          .command("search <query>")
+          .description("Search stored wearable transcripts")
+          .option("--source <id>", "Source id filter")
+          .option("--from <date>", "Inclusive start date (YYYY-MM-DD)")
+          .option("--to <date>", "Inclusive end date (YYYY-MM-DD)")
+          .option("--limit <n>", "Maximum results (default 10)")
+          .option("--json", "JSON output")
+          .action(async (...args: unknown[]) => {
+            const query = typeof args[0] === "string" ? args[0] : "";
+            const options = (args[1] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "search",
+              query,
+              ...stringOpt(options, "source", "--source"),
+              ...stringOpt(options, "from", "--from"),
+              ...stringOpt(options, "to", "--to"),
+              ...stringOpt(options, "limit", "--limit"),
+              ...(options.json === true ? ["--json"] : []),
+            ]);
+          });
+
+        wearablesCmd
+          .command("memories")
+          .description("List memories created from wearable transcripts")
+          .option("--source <id>", "Source id filter")
+          .option("--date <date>", "Transcript day filter (YYYY-MM-DD)")
+          .option("--limit <n>", "Maximum results (default 50)")
+          .option("--json", "JSON output")
+          .action(async (...args: unknown[]) => {
+            const options = (args[0] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "memories",
+              ...stringOpt(options, "source", "--source"),
+              ...stringOpt(options, "date", "--date"),
+              ...stringOpt(options, "limit", "--limit"),
+              ...(options.json === true ? ["--json"] : []),
+            ]);
+          });
+
+        const speakersCmd = wearablesCmd
+          .command("speakers")
+          .description("Manage the speaker registry");
+        speakersCmd
+          .command("list")
+          .description("Show stored speaker mappings")
+          .action(async () => forwardWearables(["speakers", "list"]));
+        speakersCmd
+          .command("self <name>")
+          .description("Set the wearer's display name")
+          .action(async (...args: unknown[]) =>
+            forwardWearables(["speakers", "self", String(args[0] ?? "")]),
+          );
+        speakersCmd
+          .command("set <source> <speakerKey> <name>")
+          .description("Map a provider speaker label to a display name")
+          .option("--self", "Mark this speaker as the wearer")
+          .action(async (...args: unknown[]) => {
+            const options = (args[3] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "speakers",
+              "set",
+              String(args[0] ?? ""),
+              String(args[1] ?? ""),
+              String(args[2] ?? ""),
+              ...(options.self === true ? ["--self"] : []),
+            ]);
+          });
+        speakersCmd
+          .command("remove <source> <speakerKey>")
+          .description("Remove a speaker mapping")
+          .action(async (...args: unknown[]) =>
+            forwardWearables([
+              "speakers",
+              "remove",
+              String(args[0] ?? ""),
+              String(args[1] ?? ""),
+            ]),
+          );
+
+        const correctionsCmd = wearablesCmd
+          .command("corrections")
+          .description("Manage user-specific transcript correction rules");
+        correctionsCmd
+          .command("list")
+          .description("Show correction rules from config and state")
+          .action(async () => forwardWearables(["corrections", "list"]));
+        correctionsCmd
+          .command("add <match> <replace>")
+          .description("Add a correction rule (quote multi-word values)")
+          .option("--regex", "Treat <match> as a regular expression")
+          .option("--case-sensitive", "Match case-sensitively")
+          .option("--source <id>", "Restrict the rule to one source")
+          .action(async (...args: unknown[]) => {
+            const options = (args[2] ?? {}) as Record<string, unknown>;
+            await forwardWearables([
+              "corrections",
+              "add",
+              String(args[0] ?? ""),
+              String(args[1] ?? ""),
+              ...(options.regex === true ? ["--regex"] : []),
+              ...(options.caseSensitive === true ? ["--case-sensitive"] : []),
+              ...stringOpt(options, "source", "--source"),
+            ]);
+          });
+        correctionsCmd
+          .command("remove <index>")
+          .description("Remove a state correction rule by index")
+          .action(async (...args: unknown[]) =>
+            forwardWearables(["corrections", "remove", String(args[0] ?? "")]),
+          );
+      }
+
       cmd
         .command("benchmark-status")
         .description("Show benchmark/evaluation harness status, benchmark packs, and latest run summary")

package/src/config.ts

@@ -35,6 +35,7 @@ import { expandTildePath } from "./utils/path.js";
 // lives in connectors/coerce.ts (a tiny, dependency-free module) so neither
 // config.ts → connectors/index.ts nor the reverse circular import arises.
 import { coerceBool, coerceInstallExtension, coerceNumber } from "./connectors/coerce.js";
+import { parseWearablesConfig } from "./wearables/config.js";
 
 const DEFAULT_MEMORY_DIR = path.join(
   resolveHomeDir(),
@@ -1142,6 +1143,11 @@ export function parseConfig(raw: unknown): PluginConfig {
     recallMaxProcedures,
   };
 
+  // Wearable transcript ingestion (Limitless / Bee / Omi). Parsing is
+  // delegated to the wearables module; it follows the same loud-reject
+  // conventions as the `procedural` block above.
+  const wearables = parseWearablesConfig(cfg.wearables);
+
   // Coding-agent project/branch scoping (issue #569)
   const rawCodingMode =
     cfg.codingMode && typeof cfg.codingMode === "object" && !Array.isArray(cfg.codingMode)
@@ -2018,6 +2024,7 @@ export function parseConfig(raw: unknown): PluginConfig {
     dreaming,
     dreamsPhases,
     procedural,
+    wearables,
     // At-rest encryption (issue #690 PR 3/4)
     // coerceBool handles CLI string inputs: `--config secureStoreEnabled=true`
     // arrives as the string "true" which `=== true` would reject (CLAUDE.md #36).

package/src/index.ts

@@ -1038,6 +1038,13 @@ export {
   type BulkImportCliCommandOptions,
 } from "./cli.js";
 
+// ---------------------------------------------------------------------------
+// Wearable transcript subsystem (Limitless / Bee / Omi connectors).
+// Connector packages import the registry + types from here.
+// ---------------------------------------------------------------------------
+
+export * from "./wearables/index.js";
+
 // ---------------------------------------------------------------------------
 // Shared importer base (issue #568)
 // ---------------------------------------------------------------------------

package/src/orchestrator.ts

@@ -262,6 +262,7 @@ import {
 } from "./native-knowledge.js";
 import { normalizeReplaySessionKey, type ReplayTurn } from "./replay/types.js";
 import type { ImportTurn } from "./bulk-import/types.js";
+import { WearablesService } from "./wearables/service.js";
 import {
   type AgentPersonaModelConfig,
   confidenceTier,
@@ -1694,6 +1695,7 @@ export class Orchestrator {
     (observation: ConsolidationObservation) => Promise<void> | void
   >();
   private qmdMaintenanceTimer: NodeJS.Timeout | null = null;
+  private wearablesServiceInstance: WearablesService | null = null;
   private qmdMaintenancePending = false;
   private qmdMaintenanceInFlight = false;
   private lastQmdEmbedAtMs = 0;
@@ -10765,6 +10767,46 @@ export class Orchestrator {
     return this.config.defaultNamespace;
   }
 
+  /**
+   * Lazily-constructed wearables service (Limitless / Bee / Omi
+   * transcript ingestion). All wearables surfaces — CLI, MCP tools,
+   * HTTP routes — share this one instance so sync state, search, and
+   * memory writes stay consistent. Writes are pinned to the same
+   * deterministic namespace bulk-import uses.
+   */
+  getWearablesService(): WearablesService {
+    if (!this.wearablesServiceInstance) {
+      this.wearablesServiceInstance = new WearablesService({
+        config: this.config.wearables,
+        getStorage: async () =>
+          await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
+        extract: (turns) => this.extraction.extract(turns),
+        searchBackend: {
+          search: async (query, maxResults) => {
+            if (!this.qmd.isAvailable()) return null;
+            try {
+              const results = await this.qmd.search(query, undefined, maxResults);
+              return results.map((result) => ({
+                path: result.path,
+                score: result.score,
+                preview: result.snippet,
+              }));
+            } catch {
+              // Backend hiccup → tell the service "unavailable" so it
+              // runs its bounded scan fallback instead of returning a
+              // silent empty result (CLAUDE.md rule 34).
+              return null;
+            }
+          },
+        },
+        reindexSearch: async () => {
+          await this.qmd.update();
+        },
+      });
+    }
+    return this.wearablesServiceInstance;
+  }
+
   /**
    * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
    * normalizes user/assistant turns into the extraction buffer and awaits

package/src/storage.ts

@@ -8,6 +8,7 @@ import { getCachedEntities, invalidateCachedEntities, setCachedEntities } from "
 import { rotateMarkdownFileToArchive } from "./hygiene.js";
 import { sanitizeMemoryContent } from "./sanitize.js";
 import { createVersion as createPageVersion, type VersioningConfig, type VersionTrigger } from "./page-versioning.js";
+import { isValidTranscriptDate, WEARABLES_DIR_NAME } from "./wearables/day-store.js";
 import {
   SecureStoreLockedError,
   MAGIC_HEADER_SIZE,
@@ -2490,6 +2491,111 @@ export class StorageManager {
     return this.readSharedVersion("artifact-write", StorageManager.artifactWriteVersionByDir);
   }
 
+  // -------------------------------------------------------------------------
+  // Wearable day transcripts
+  //
+  // Stored under `<baseDir>/wearables/<source>/<YYYY-MM-DD>.md` — outside
+  // the memory scan roots (never surfaces as a memory) but inside the QMD
+  // collection root (full-text searchable). IO lives here so transcripts
+  // inherit the same encrypted-at-rest + atomic-write semantics as
+  // memories.
+  // -------------------------------------------------------------------------
+
+  private get wearablesDir(): string {
+    return path.join(this.baseDir, WEARABLES_DIR_NAME);
+  }
+
+  /**
+   * Resolve the on-disk path for a source/day transcript. Throws on
+   * malformed inputs — source ids and dates reach this from CLI/MCP/HTTP
+   * surfaces and must never become path traversal.
+   */
+  wearableTranscriptPath(sourceId: string, date: string): string {
+    if (typeof sourceId !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(sourceId)) {
+      throw new Error(
+        `invalid wearable source id '${String(sourceId)}' — expected lowercase letters, digits, and dashes`,
+      );
+    }
+    if (!isValidTranscriptDate(date)) {
+      throw new Error(
+        `invalid wearable transcript date '${String(date)}' — expected YYYY-MM-DD`,
+      );
+    }
+    return path.join(this.wearablesDir, sourceId, `${date}.md`);
+  }
+
+  async writeWearableDayTranscript(
+    sourceId: string,
+    date: string,
+    serialized: string,
+  ): Promise<void> {
+    const targetPath = this.wearableTranscriptPath(sourceId, date);
+    // writeMaybeEncryptedFile handles mkdir + atomic temp→rename.
+    await writeMaybeEncryptedFile(targetPath, serialized, this.resolveWriteKey(), {}, this.baseDir);
+  }
+
+  /** Read a stored day transcript; null when the day has no file. */
+  async readWearableDayTranscript(
+    sourceId: string,
+    date: string,
+  ): Promise<string | null> {
+    const targetPath = this.wearableTranscriptPath(sourceId, date);
+    try {
+      return await readMaybeEncryptedFile(targetPath, this._secureStoreKey, this.baseDir);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+      throw err;
+    }
+  }
+
+  /**
+   * List stored transcript days, newest first, optionally scoped to one
+   * source. Non-transcript files in the tree are ignored.
+   */
+  async listWearableTranscriptDays(
+    sourceId?: string,
+  ): Promise<Array<{ source: string; date: string }>> {
+    const days: Array<{ source: string; date: string }> = [];
+    let sources: string[];
+    if (sourceId !== undefined) {
+      sources = [sourceId];
+    } else {
+      try {
+        const entries = await readdir(this.wearablesDir, { withFileTypes: true });
+        sources = entries
+          .filter((entry) => entry.isDirectory())
+          .map((entry) => entry.name);
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+        throw err;
+      }
+    }
+    for (const source of sources) {
+      if (!/^[a-z][a-z0-9-]{0,63}$/.test(source)) continue;
+      let entries: string[];
+      try {
+        entries = await readdir(path.join(this.wearablesDir, source));
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === "ENOENT") continue;
+        throw err;
+      }
+      for (const entry of entries) {
+        if (!entry.endsWith(".md")) continue;
+        const date = entry.slice(0, -3);
+        if (!isValidTranscriptDate(date)) continue;
+        days.push({ source, date });
+      }
+    }
+    days.sort((a, b) => {
+      if (a.date > b.date) return -1;
+      if (a.date < b.date) return 1;
+      if (a.source < b.source) return -1;
+      if (a.source > b.source) return 1;
+      return 0;
+    });
+    return days;
+  }
+
   private get factsDir(): string {
     return path.join(this.baseDir, "facts");
   }

package/src/types.ts

@@ -871,6 +871,11 @@ export interface PluginConfig {
    */
   dreamsPhases: DreamsPhasesConfig;
   procedural: ProceduralConfig;
+  /**
+   * Wearable transcript ingestion (Limitless / Bee / Omi connectors).
+   * Disabled by default; see docs/wearables.md.
+   */
+  wearables: import("./wearables/types.js").WearablesConfig;
   /**
    * At-rest encryption configuration (issue #690 PR 3/4).
    *

package/src/wearables/cleanup.test.ts

@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  cleanConversation,
+  collapseImmediateRepeats,
+  isLowQualitySegment,
+  stripFillerTokens,
+} from "./cleanup.js";
+import type { WearableCleanupSettings, WearableConversation } from "./types.js";
+
+const ALL_ON: WearableCleanupSettings = {
+  mergeSameSpeaker: true,
+  stripFillers: true,
+  collapseRepeats: true,
+  dropLowQuality: true,
+};
+
+function conversation(
+  segments: Array<{ speakerKey: string; text: string; startIso?: string; endIso?: string }>,
+): WearableConversation {
+  return {
+    id: "c1",
+    source: "testsource",
+    startIso: "2026-06-10T10:00:00Z",
+    segments,
+  };
+}
+
+test("stripFillerTokens removes standalone fillers but not words containing them", () => {
+  assert.equal(stripFillerTokens("Um, so we should ship it"), "so we should ship it");
+  assert.equal(stripFillerTokens("Grab the umbrella, uh, before noon"), "Grab the umbrella, before noon");
+  assert.equal(stripFillerTokens("hmm"), "");
+});
+
+test("collapseImmediateRepeats collapses word and phrase stutters fully", () => {
+  assert.equal(collapseImmediateRepeats("I I I think so"), "I think so");
+  assert.equal(collapseImmediateRepeats("we should we should go"), "we should go");
+  assert.equal(collapseImmediateRepeats("that's a really really really good point"), "that's a really good point");
+});
+
+test("collapseImmediateRepeats never collapses pure digit sequences", () => {
+  assert.equal(collapseImmediateRepeats("call 555 555 1234 now"), "call 555 555 1234 now");
+});
+
+test("isLowQualitySegment flags garbage and keeps real speech", () => {
+  assert.equal(isLowQualitySegment("aaaaaaaaaa"), true);
+  assert.equal(isLowQualitySegment("%$#@! ---- ////"), true);
+  assert.equal(isLowQualitySegment("yeah yeah yeah yeah yeah"), true);
+  assert.equal(isLowQualitySegment("Let's review the budget tomorrow."), false);
+  assert.equal(isLowQualitySegment("ok"), false);
+});
+
+test("merges consecutive same-speaker segments within the gap", () => {
+  const result = cleanConversation(
+    conversation([
+      {
+        speakerKey: "a",
+        text: "First part.",
+        startIso: "2026-06-10T10:00:00Z",
+        endIso: "2026-06-10T10:00:05Z",
+      },
+      {
+        speakerKey: "a",
+        text: "Second part.",
+        startIso: "2026-06-10T10:00:10Z",
+        endIso: "2026-06-10T10:00:15Z",
+      },
+      { speakerKey: "b", text: "Reply.", startIso: "2026-06-10T10:00:20Z" },
+    ]),
+    ALL_ON,
+  );
+  assert.equal(result.conversation.segments.length, 2);
+  assert.equal(result.conversation.segments[0].text, "First part. Second part.");
+  assert.equal(result.conversation.segments[0].endIso, "2026-06-10T10:00:15Z");
+  assert.equal(result.mergedSegments, 1);
+});
+
+test("does not merge across a long silence gap", () => {
+  const result = cleanConversation(
+    conversation([
+      {
+        speakerKey: "a",
+        text: "Before lunch.",
+        startIso: "2026-06-10T10:00:00Z",
+        endIso: "2026-06-10T10:00:05Z",
+      },
+      {
+        speakerKey: "a",
+        text: "After lunch.",
+        startIso: "2026-06-10T11:30:00Z",
+        endIso: "2026-06-10T11:30:05Z",
+      },
+    ]),
+    ALL_ON,
+  );
+  assert.equal(result.conversation.segments.length, 2);
+});
+
+test("drops low-quality segments and counts them", () => {
+  const result = cleanConversation(
+    conversation([
+      { speakerKey: "a", text: "Real sentence about plans." },
+      { speakerKey: "a", text: "zzzzzzzzz" },
+    ]),
+    { ...ALL_ON, mergeSameSpeaker: false },
+  );
+  assert.equal(result.conversation.segments.length, 1);
+  assert.equal(result.droppedSegments, 1);
+});
+
+test("respects disabled passes", () => {
+  const result = cleanConversation(
+    conversation([
+      { speakerKey: "a", text: "Um, well well well" },
+      { speakerKey: "a", text: "Um, again" },
+    ]),
+    {
+      mergeSameSpeaker: false,
+      stripFillers: false,
+      collapseRepeats: false,
+      dropLowQuality: false,
+    },
+  );
+  assert.equal(result.conversation.segments.length, 2);
+  assert.equal(result.conversation.segments[0].text, "Um, well well well");
+});
+
+test("input conversation is not mutated", () => {
+  const input = conversation([{ speakerKey: "a", text: "Um, hello there" }]);
+  const before = JSON.stringify(input);
+  cleanConversation(input, ALL_ON);
+  assert.equal(JSON.stringify(input), before);
+});