@remnic/core 9.69.56 → 9.69.57

package/dist/utils/serialize-mutations.d.ts

@@ -8,7 +8,7 @@
  * {@link serializeMutations} export delegates to a single shared default
  * instance for callers that want process-wide serialization.
  */
-declare class MutationSerializer {
+export declare class MutationSerializer {
     private readonly chains;
     /**
      * Run `task` strictly after every other task already queued under `key` on
@@ -37,9 +37,9 @@ declare class MutationSerializer {
  * default {@link MutationSerializer}. For isolated/testable serialization,
  * construct a `MutationSerializer` directly.
  */
-declare function serializeMutations<T>(key: string, task: () => Promise<T>): Promise<T>;
+export declare function serializeMutations<T>(key: string, task: () => Promise<T>): Promise<T>;
 /** Options for {@link withHeldFileLock}. */
-interface HeldFileLockOptions {
+export interface HeldFileLockOptions {
     /**
      * A lock whose mtime is older than this (in ms) is treated as a crashed
      * holder and broken. Required — there is no safe default, since the right
@@ -98,7 +98,7 @@ interface HeldFileLockOptions {
  * Control surface handed to a held-lock task so a long, CPU-bound critical
  * section can re-assert ownership immediately before its destructive write.
  */
-interface HeldFileLockController {
+export interface HeldFileLockController {
     /**
      * Re-verify THIS acquirer still owns the lock and, when it does, refresh the
      * lock's mtime. Returns `true` only while we still hold it.
@@ -150,6 +150,5 @@ interface HeldFileLockController {
  * long scan — a scan-length lock makes concurrent writers time out and
  * silently drop work (catalog round 5, codex/cursor P2).
  */
-declare function withHeldFileLock<T>(lockPath: string, opts: HeldFileLockOptions, task: (acquired: boolean, lock: HeldFileLockController) => Promise<T>): Promise<T>;
-
-export { type HeldFileLockController, type HeldFileLockOptions, MutationSerializer, serializeMutations, withHeldFileLock };
+export declare function withHeldFileLock<T>(lockPath: string, opts: HeldFileLockOptions, task: (acquired: boolean, lock: HeldFileLockController) => Promise<T>): Promise<T>;
+//# sourceMappingURL=serialize-mutations.d.ts.map

package/dist/utils/serialize-mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-mutations.d.ts","sourceRoot":"","sources":["../../src/utils/serialize-mutations.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;GASG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAEhE;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAiD7D;;;OAGG;IACH,kBAAkB,IAAI,MAAM;CAG7B;AAmBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGrF;AAMD,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,+BAA+B,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtE;;;;;OAKG;IACH,QAAQ,CAAC,2BAA2B,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClE;;;;;;OAMG;IACH,QAAQ,CAAC,4BAA4B,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACnE;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CAClE;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;;;;;OAaG;IACH,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;CACxC;AAqBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,sBAAsB,KAAK,OAAO,CAAC,CAAC,CAAC,GACpE,OAAO,CAAC,CAAC,CAAC,CAgGZ"}

package/dist/utils/yaml-scalar.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Decode a YAML double-quoted scalar: strip surrounding quotes and decode
+ * JSON escape sequences. Used for fields that may be quoted at serialization
+ * time to prevent frontmatter injection (e.g. sourceConnector).
+ * Only double-quoted (JSON-compatible) values are decoded — the serializer
+ * never emits single-quoted scalars.
+ */
+export declare function decodeYamlScalar(value: string): string;
+//# sourceMappingURL=yaml-scalar.d.ts.map

package/dist/utils/yaml-scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-scalar.d.ts","sourceRoot":"","sources":["../../src/utils/yaml-scalar.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYtD"}

package/dist/verified-recall.d.ts

@@ -1,14 +1,13 @@
-import { BoxFrontmatter } from './boxes.js';
-
-interface VerifiedEpisodeResult {
+import { type BoxFrontmatter } from "./boxes.js";
+export interface VerifiedEpisodeResult {
     box: BoxFrontmatter;
     score: number;
     verifiedEpisodeCount: number;
     verifiedMemoryIds: string[];
     matchedFields: string[];
 }
-declare function compareVerifiedEpisodeResults(left: VerifiedEpisodeResult, right: VerifiedEpisodeResult): number;
-declare function searchVerifiedEpisodes(options: {
+export declare function compareVerifiedEpisodeResults(left: VerifiedEpisodeResult, right: VerifiedEpisodeResult): number;
+export declare function searchVerifiedEpisodes(options: {
     memoryDir: string;
     query: string;
     maxResults: number;
@@ -18,5 +17,4 @@ declare function searchVerifiedEpisodes(options: {
      *  honors the owning daemon's config instead of the process-wide default. */
     hotMemoriesCacheEnabled?: boolean;
 }): Promise<VerifiedEpisodeResult[]>;
-
-export { type VerifiedEpisodeResult, compareVerifiedEpisodeResults, searchVerifiedEpisodes };
+//# sourceMappingURL=verified-recall.d.ts.map

package/dist/verified-recall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verified-recall.d.ts","sourceRoot":"","sources":["../src/verified-recall.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAM7D,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,cAAc,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AA0ED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,qBAAqB,EAAE,KAAK,EAAE,qBAAqB,GAAG,MAAM,CAO/G;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;iFAE6E;IAC7E,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAmDnC"}

package/dist/verified-recall.js

@@ -1,20 +1,20 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-SZ7IVZGD.js";
+} from "./chunk-NVCWA4QC.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-QWQB7TOB.js";
-import "./chunk-UHVXE24Y.js";
+import "./chunk-S2OBXHMN.js";
 import "./chunk-46WM6JX2.js";
+import "./chunk-UHVXE24Y.js";
 import "./chunk-D5F7TKMH.js";
-import "./chunk-AIVRD66I.js";
-import "./chunk-PLJ2MQFT.js";
-import "./chunk-KVO2BTA4.js";
-import "./chunk-CYEPCZN5.js";
-import "./chunk-G6NQ3L4T.js";
+import "./chunk-W6YK672C.js";
+import "./chunk-IAZPYX6W.js";
 import "./chunk-WPGR3RW4.js";
 import "./chunk-6KTXE6A3.js";
 import "./chunk-D7MAYFQP.js";
+import "./chunk-KVO2BTA4.js";
+import "./chunk-CYEPCZN5.js";
+import "./chunk-G6NQ3L4T.js";
 import "./chunk-4O6WRBGE.js";
 import "./chunk-GUMZC2BO.js";
 import "./chunk-TFA6HPOA.js";
@@ -22,20 +22,19 @@ import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-4UVJ6EIT.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
-import "./chunk-S45INSV3.js";
+import "./chunk-FF6N7BXC.js";
 import "./chunk-J3IWHCMF.js";
 import "./chunk-AAD2ZS6P.js";
 import "./chunk-DUJYRVUD.js";
+import "./chunk-YXZG5TVN.js";
 import "./chunk-ZIKENA2C.js";
 import "./chunk-PCEYGOSL.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-3ONXXHQO.js";
-import "./chunk-YXZG5TVN.js";
 import "./chunk-5GINB5LC.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-G7D6GZ5J.js";
@@ -59,12 +58,11 @@ import "./chunk-45GF7Y3V.js";
 import "./chunk-EP6BA7VV.js";
 import "./chunk-E2AWJ7KQ.js";
 import "./chunk-YCVB7X56.js";
+import "./chunk-PQVCH2AE.js";
 import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
 import "./chunk-Z7L72ZHL.js";
 import "./chunk-4O4TKIXQ.js";
-import "./chunk-RGMVMVMF.js";
-import "./chunk-PQVCH2AE.js";
 import "./chunk-GDYU6VF4.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-VYCOJKSX.js";
@@ -77,11 +75,13 @@ import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
-import "./chunk-PWPIERBM.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-NB3LRY4T.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-FFAZ2XFU.js";
+import "./chunk-FNQEXI3D.js";
+import "./chunk-RGMVMVMF.js";
+import "./chunk-PWPIERBM.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";

package/dist/version-utils.d.ts

@@ -1,4 +1,3 @@
-type VersionTriple = readonly [number, number, number];
-declare function compareVersions(a: VersionTriple, b: VersionTriple): number;
-
-export { type VersionTriple, compareVersions };
+export type VersionTriple = readonly [number, number, number];
+export declare function compareVersions(a: VersionTriple, b: VersionTriple): number;
+//# sourceMappingURL=version-utils.d.ts.map

package/dist/version-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-utils.d.ts","sourceRoot":"","sources":["../src/version-utils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9D,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,GAAG,MAAM,CAM1E"}

package/dist/wearables/auto-sync.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Wearables auto-sync — in-process periodic transcript refresh.
+ *
+ * Every tick re-syncs a short rolling window ending today for ALL
+ * enabled sources, so the current day's transcript keeps growing while
+ * the wearable records and provider-side revisions of recent days flow
+ * in without operator action. Once per local day the window deepens to
+ * `autoSyncDeepDays` to pick up late uploads and provider reprocessing
+ * further back (phones syncing hours later, re-diarized transcripts).
+ *
+ * Day fetches are unconditional within the window — existing day files
+ * are always re-fetched and re-composed; the content-hash skip in the
+ * pipeline keeps unchanged days write-free, so a tick on a quiet day
+ * is read-only. The timer is unref'd: it never keeps a one-shot CLI
+ * process alive, and long-lived hosts stop it via the returned handle.
+ */
+export interface WearablesAutoSyncSettings {
+    /** Minutes between ticks. */
+    intervalMinutes: number;
+    /** Rolling window (days ending today) refreshed on a normal tick. */
+    days: number;
+    /**
+     * Window for the once-per-local-day deep pass. 0 disables the deep
+     * pass; otherwise must be >= `days` (validated at config parse).
+     */
+    deepDays: number;
+    /** IANA timezone used to detect the local-day rollover. */
+    timezone?: string;
+}
+export interface WearablesAutoSyncDeps {
+    /** Run a sync across all enabled sources (WearablesService.sync). */
+    sync(options: {
+        days: number;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+    log: {
+        info(message: string): void;
+        warn(message: string): void;
+    };
+    /** Clock injection for tests. */
+    now?: () => Date;
+}
+export interface WearablesAutoSyncHandle {
+    /** Run one scheduler tick now (first-run hook and test seam). */
+    tick(): Promise<void>;
+    /**
+     * Stop the scheduler: clears the timer, aborts the in-flight sync's
+     * provider fetches via AbortSignal, and resolves once the in-flight
+     * tick has fully settled — after `await stop()` nothing is writing
+     * or reindexing anymore. The handle is single-use; a restarted host
+     * starts a fresh one.
+     */
+    stop(): Promise<void>;
+}
+/**
+ * Start the periodic refresh. The first tick fires after one full
+ * interval rather than at start — gateways on low-power hardware can
+ * restart-loop during setup (issue #462), and an immediate fetch on
+ * every restart would hammer provider APIs. Operators who want an
+ * instant refresh run `wearables sync` (or call `tick()`).
+ */
+export declare function startWearablesAutoSync(settings: WearablesAutoSyncSettings, deps: WearablesAutoSyncDeps): WearablesAutoSyncHandle;
+//# sourceMappingURL=auto-sync.d.ts.map

package/dist/wearables/auto-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-sync.d.ts","sourceRoot":"","sources":["../../src/wearables/auto-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,MAAM,WAAW,yBAAyB;IACxC,6BAA6B;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,qEAAqE;IACrE,IAAI,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxE,GAAG,EAAE;QAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAClE,iCAAiC;IACjC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,iEAAiE;IACjE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB;;;;;;OAMG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,yBAAyB,EACnC,IAAI,EAAE,qBAAqB,GAC1B,uBAAuB,CA+DzB"}

package/dist/wearables/cleanup.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Wearable transcript cleanup — deterministic, zero-LLM normalization.
+ *
+ * ASR output from always-on wearables is noisy: fragmented utterances,
+ * filler tokens, stuttered repeats, and occasional pure garbage. This
+ * module cleans a conversation in place-order without changing meaning:
+ * everything here is conservative and reversible by re-syncing.
+ */
+import type { WearableCleanupSettings, WearableConversation } from "./types.js";
+export interface CleanupResult {
+    conversation: WearableConversation;
+    /** Segments removed by the low-quality heuristic. */
+    droppedSegments: number;
+    /** Segments merged into a predecessor. */
+    mergedSegments: number;
+}
+/** Apply configured cleanup passes to one conversation. */
+export declare function cleanConversation(conversation: WearableConversation, settings: WearableCleanupSettings, extraFillerTokens?: readonly string[]): CleanupResult;
+/**
+ * Remove filler tokens from `text`. The built-in token set is chosen
+ * from the scripts present in the text, so a Japanese or Korean segment
+ * is cleaned by its own list instead of silently keeping every filler
+ * (issue #2196). Operator tokens apply to every script.
+ */
+export declare function stripFillerTokens(text: string, extraTokens?: readonly string[]): string;
+/**
+ * Collapse immediate word/phrase stutters: "I I I think" -> "I think",
+ * "we should we should go" -> "we should go". Only collapses *adjacent*
+ * repeats (up to 4-word phrases) so intentional repetition across a
+ * sentence is preserved.
+ */
+export declare function collapseImmediateRepeats(text: string): string;
+/**
+ * Heuristic ASR-garbage detector. Intentionally conservative: it only
+ * drops segments that carry no plausible information.
+ */
+export declare function isLowQualitySegment(text: string): boolean;
+export declare function normalizeWhitespace(text: string): string;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/wearables/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/wearables/cleanup.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,oBAAoB,CAAC;IACnC,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,cAAc,EAAE,MAAM,CAAC;CACxB;AA8JD,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,oBAAoB,EAClC,QAAQ,EAAE,uBAAuB,EACjC,iBAAiB,GAAE,SAAS,MAAM,EAAO,GACxC,aAAa,CA8Df;AA0BD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,MAAM,CAMR;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA8B7D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAmBzD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/wearables/cli.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Wearables CLI runner — one implementation shared by every CLI host
+ * (`remnic wearables ...` and `openclaw engram wearables ...`), so the
+ * surfaces never fork (same rule as the recall-explain renderers).
+ *
+ * Flag validation is strict: every value-taking flag requires a value,
+ * unknown flags error with the valid list, and invalid values reject
+ * loudly (CLAUDE.md rules 14 + 51).
+ */
+import type { WearablesService } from "./service.js";
+export interface WearablesCliIo {
+    stdout: {
+        write(chunk: string): unknown;
+    };
+    stderr: {
+        write(chunk: string): unknown;
+    };
+}
+/**
+ * Run a wearables CLI command. Returns a process exit code; all output
+ * goes through `io`.
+ */
+export declare function runWearablesCliCommand(service: WearablesService, args: string[], io: WearablesCliIo): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/wearables/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/wearables/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CAC3C;AAkID;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,EAAE,cAAc,GACjB,OAAO,CAAC,MAAM,CAAC,CAuVjB"}

package/dist/wearables/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wearables config parsing — strict, loud, and default-safe.
+ *
+ * Mirrors the `procedural` block conventions in config.ts: shape
+ * violations and unparseable values throw with actionable messages
+ * (CLAUDE.md rule 51); boolean-ish strings coerce via the shared
+ * helpers (rule 36); every numeric knob is bounds-checked; the
+ * memory-creation default is the least-privileged mode (rule 48).
+ */
+import type { WearableCleanupSettings, WearableFusionConfig, WearableSourceSettings, WearablesConfig } from "./types.js";
+export declare const KNOWN_WEARABLE_SOURCE_IDS: readonly ["limitless", "bee", "omi"];
+/**
+ * Default cleanup settings. `sourceId` (the connector id this block
+ * belongs to) only adjusts the `preserveUtteranceBoundaries` default —
+ * every other toggle is identical across sources.
+ */
+export declare function defaultWearableCleanupSettings(sourceId?: string): WearableCleanupSettings;
+export declare function defaultWearableSourceSettings(sourceId?: string): WearableSourceSettings;
+export declare function defaultWearableFusionConfig(): WearableFusionConfig;
+export declare function defaultWearablesConfig(): WearablesConfig;
+export declare function parseWearablesConfig(value: unknown): WearablesConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/wearables/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/wearables/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAEV,uBAAuB,EAGvB,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,yBAAyB,sCAAuC,CAAC;AAyC9E;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,CAAC,EAAE,MAAM,GAChB,uBAAuB,CASzB;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,CAAC,EAAE,MAAM,GAChB,sBAAsB,CAaxB;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,CAMlE;AAED,wBAAgB,sBAAsB,IAAI,eAAe,CAiBxD;AAqSD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CA4LpE"}

package/dist/wearables/corrections.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Wearable transcript corrections — user-specific replacement rules.
+ *
+ * ASR engines consistently mishear the same proper nouns for the same
+ * person ("remnick" for "Remnic", a colleague's name, product jargon).
+ * Rules come from two places, merged at sync time:
+ *
+ *  1. `wearables.corrections` in plugin config (declarative, versioned
+ *     with the operator's config).
+ *  2. A CLI-managed rules file at `state/wearables/corrections.json`
+ *     (added interactively via `remnic wearables corrections add`).
+ *
+ * Literal rules are regex-escaped before compilation and replacements
+ * are applied via a function (never a replacement string) so `$` in
+ * either side can't corrupt output.
+ */
+import type { WearableCorrectionRule } from "./types.js";
+export interface CompiledCorrectionRule {
+    rule: WearableCorrectionRule;
+    pattern: RegExp;
+}
+export interface CorrectionApplication {
+    text: string;
+    applied: number;
+}
+/**
+ * Validate and compile a correction rule. Throws a descriptive error on
+ * invalid input (empty match, regex that doesn't compile, regex that
+ * matches the empty string) — callers surface this at config parse or
+ * CLI time rather than skipping the rule silently.
+ */
+export declare function compileCorrectionRule(rule: WearableCorrectionRule, label: string): CompiledCorrectionRule;
+/** Compile a rule list, labeling errors with their index. */
+export declare function compileCorrectionRules(rules: WearableCorrectionRule[], labelPrefix: string): CompiledCorrectionRule[];
+/** Apply every applicable rule to a piece of transcript text. */
+export declare function applyCorrections(text: string, rules: CompiledCorrectionRule[], sourceId: string): CorrectionApplication;
+export declare function correctionsFilePath(memoryDir: string): string;
+/**
+ * Load CLI-managed correction rules. A missing file means no rules; a
+ * malformed file throws (operators should know their corrections are
+ * not being applied rather than silently losing them).
+ */
+export declare function loadCorrectionsFile(memoryDir: string): Promise<WearableCorrectionRule[]>;
+/** Persist CLI-managed rules atomically (temp file + rename). */
+export declare function saveCorrectionsFile(memoryDir: string, rules: WearableCorrectionRule[]): Promise<void>;
+//# sourceMappingURL=corrections.d.ts.map

package/dist/wearables/corrections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corrections.d.ts","sourceRoot":"","sources":["../../src/wearables/corrections.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AASD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,sBAAsB,EAC5B,KAAK,EAAE,MAAM,GACZ,sBAAsB,CA6CxB;AAED,6DAA6D;AAC7D,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,sBAAsB,EAAE,EAC/B,WAAW,EAAE,MAAM,GAClB,sBAAsB,EAAE,CAI1B;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,sBAAsB,EAAE,EAC/B,QAAQ,EAAE,MAAM,GACf,qBAAqB,CAmBvB;AAWD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAkCnC;AAED,iEAAiE;AACjE,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,sBAAsB,EAAE,GAC9B,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dist/wearables/day-store.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Wearable day-transcript composition and parsing.
+ *
+ * One markdown file per source per day, stored under
+ * `<memoryDir>/wearables/<source>/<YYYY-MM-DD>.md` with YAML
+ * frontmatter. The location is deliberate:
+ *
+ *  - it is OUTSIDE the memory scan roots (facts/, procedures/,
+ *    reasoning-traces/, corrections/), so transcripts never appear as
+ *    memories in recall or governance passes;
+ *  - it is INSIDE the QMD collection root (the memory dir), so day
+ *    transcripts are full-text searchable after the next index update.
+ *
+ * Files are rebuilt idempotently from provider data on every sync; the
+ * body hash in frontmatter lets the pipeline skip rewriting (and
+ * re-extracting) unchanged days.
+ *
+ * This module is pure composition/parsing — file IO lives in
+ * `StorageManager` so encrypted-at-rest deployments and atomic write
+ * semantics are inherited from the same code paths memories use.
+ */
+import type { SpeakerRegistry } from "./speakers.js";
+import type { WearableConversation, WearableDayTranscript, WearableDayTranscriptMeta } from "./types.js";
+export declare const WEARABLES_DIR_NAME = "wearables";
+/**
+ * Day-transcript body serialization format version. Folded into
+ * `hashTranscriptBody` so a version bump invalidates files written by an
+ * older serializer and forces an idempotent rewrite. Decoders gate on this:
+ * only bodies whose parsed meta carries >= this version have escape
+ * sequences decoded; legacy bodies (absent / older) are left byte-for-byte
+ * unchanged so a literal two-character `\n`/`\r` in a pre-escaper
+ * transcript is never altered (issue #1849).
+ */
+export declare const TRANSCRIPT_FORMAT_VERSION = 2;
+/**
+ * Result of parsing a rendered transcript segment line.
+ */
+export interface TranscriptSegmentMatch {
+    /** Speaker label text between the `**` delimiters. */
+    label: string;
+    /** Clock text between the `[` `]` delimiters. */
+    clock: string;
+    /** Segment text after the colon. */
+    text: string;
+}
+/**
+ * Parse a rendered transcript segment line (`**label** [clock]: text`)
+ * into its three components using a linear, bounded scan — a CodeQL-safe
+ * replacement for the polynomial-risk regex that previously matched this
+ * format. Returns null when the line is not a segment line.
+ *
+ * The scan finds the FIRST occurrence of each structural delimiter
+ * (`**` after the label, `]` after the clock) exactly as the original
+ * non-greedy regex did, and verifies the fixed separator characters
+ * (`\s`, `[`, `:`, `\s`) by single-character code-point comparison.
+ * No quantified regex is evaluated on the line (#1849).
+ *
+ * Escaped labels (formatVersion >= 2) never contain an unescaped `**`,
+ * `[`, or `]`, and rendered clocks are always `HH:MM` / `--:--`, so the
+ * first delimiter is always the correct one for every well-formed
+ * transcript. Legacy unescaped labels are used verbatim by the caller
+ * and parsed identically here.
+ */
+export declare function parseTranscriptSegmentLine(line: string): TranscriptSegmentMatch | null;
+export declare function isValidTranscriptDate(date: string): boolean;
+export declare function hashTranscriptBody(body: string): string;
+/**
+ * Escape segment text for the line-based markdown format so that embedded
+ * newlines, carriage returns, and backslashes survive the serialize →
+ * reconstruct round-trip losslessly.  Reversed by `unescapeSegmentText`
+ * (this module — the single decode primitive shared with the fusion
+ * reconstruct path and every view/search/index surface).
+ *
+ * Without this, a segment whose text contains a newline is split across
+ * multiple physical lines; the reconstruct path treats each line
+ * independently and the continuation is silently dropped (or worse, a
+ * continuation line that looks like a heading/clock is mis-parsed).
+ */
+export declare function escapeSegmentText(text: string): string;
+/**
+ * Reverse `escapeSegmentText`. Unknown escape sequences (a lone
+ * backslash followed by a character the escaper never emits) are passed
+ * through literally so legacy transcripts that never went through the
+ * escaper still round-trip their original text. This is the SINGLE
+ * decode primitive: the fusion reconstruct path and every user-facing
+ * view/search/index surface call it so escaped storage never leaks to
+ * display (#1849).
+ */
+export declare function unescapeSegmentText(text: string): string;
+/**
+ * Escape a speaker label for the line-based markdown format so that
+ * markdown-delimiter characters in an arbitrary user/provider label
+ * (`**`, `[`, `]`), the escape character (`\`), and embedded newlines/
+ * carriage returns cannot break `parseTranscriptSegmentLine` parsing.
+ * Without this, a label containing `**` (or `** [clock]:`) can make the
+ * non-greedy delimiter match land on the wrong `**` and mis-parse the
+ * clock/text — or fail to parse the line at all. Reversed by
+ * `unescapeSpeakerLabel` (this module). Legacy transcripts whose labels
+ * were never escaped still parse: `unescapeSpeakerLabel` is a no-op on
+ * any label without a backslash escape sequence (#1849).
+ */
+export declare function escapeSpeakerLabel(label: string): string;
+/**
+ * Reverse `escapeSpeakerLabel`. Unknown escape sequences (a backslash
+ * followed by a character the escaper never emits) are passed through
+ * literally so legacy transcripts with raw labels still round-trip
+ * their original text, mirroring `unescapeSegmentText` for segment text.
+ */
+export declare function unescapeSpeakerLabel(label: string): string;
+/**
+ * Whether a parsed day-transcript's body was written by the escape-aware
+ * serializer (meta carries `formatVersion` >= `TRANSCRIPT_FORMAT_VERSION`).
+ * Legacy bodies (no marker, or an older version) must NOT be decoded: their
+ * literal two-character `\n`, `\r`, and lone backslashes are original
+ * content, not escape sequences (issue #1849).
+ */
+export declare function bodyIsEscaped(meta: {
+    formatVersion?: number;
+} | null | undefined): boolean;
+/**
+ * Decode the escaped segment text AND speaker label of a stored
+ * transcript body into the ORIGINAL forms for user-facing
+ * view/search/index surfaces. Only segment lines are touched: the text
+ * is decoded via `unescapeSegmentText` and the label via
+ * `unescapeSpeakerLabel`; headings, locations, and the H1 header are
+ * NOT escaped on write and pass through unchanged, so a title or
+ * location containing a literal backslash is never altered. The fusion
+ * reconstruct path does NOT use this — it decodes each segment once
+ * during parse — so callers feeding bodies back into reconstruct must
+ * pass the RAW stored body, not a decoded one, to avoid double-decoding.
+ *
+ * FORMAT-AWARE (issue #1849): when `escaped` is falsy (the default) the
+ * body is returned byte-for-byte unchanged. Only bodies written by the
+ * escape-aware serializer (`escaped = true`, derived from
+ * `bodyIsEscaped(meta)`) are decoded, so a legacy transcript's literal
+ * two-character `\n`/`\r` or lone backslash is never altered. Callers
+ * that have the parsed meta should pass `bodyIsEscaped(meta)`.
+ */
+export declare function decodeTranscriptBody(body: string, escaped?: boolean): string;
+/** Compose the markdown body (no frontmatter) for one source/day. */
+export declare function composeDayTranscriptBody(sourceId: string, date: string, timezone: string, conversations: WearableConversation[], registry: SpeakerRegistry): string;
+export declare function composeDayTranscriptMeta(sourceId: string, date: string, timezone: string, conversations: WearableConversation[], registry: SpeakerRegistry, body: string, syncedAt: string): WearableDayTranscriptMeta;
+/** Serialize meta + body into the persisted file format. */
+export declare function serializeDayTranscript(meta: WearableDayTranscriptMeta, body: string): string;
+/**
+ * Parse a persisted day-transcript file. Returns null when the content
+ * does not look like a wearable transcript (wrong kind, missing
+ * frontmatter) so callers can distinguish "not a transcript" from a
+ * read error.
+ */
+export declare function parseDayTranscript(raw: string): WearableDayTranscript | null;
+//# sourceMappingURL=day-store.d.ts.map

package/dist/wearables/day-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"day-store.d.ts","sourceRoot":"","sources":["../../src/wearables/day-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAI9C;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;CACd;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,GACX,sBAAsB,GAAG,IAAI,CAsD/B;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI3D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASvD;AA2BD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GAClD,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,MAAM,CAa1E;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,oBAAoB,EAAE,EACrC,QAAQ,EAAE,eAAe,GACxB,MAAM,CAgCR;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,oBAAoB,EAAE,EACrC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,yBAAyB,CAkB3B;AAED,4DAA4D;AAC5D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,MAAM,GACX,MAAM,CAyBR;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAoD5E"}

package/dist/wearables/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Error thrown by wearables surfaces for caller-correctable problems:
+ * invalid parameters, unknown sources, disabled subsystem, missing
+ * connector packages. Transport layers map this to 400-class responses;
+ * anything else is a backend fault and bubbles to the 500 handler.
+ */
+export declare class WearablesInputError extends Error {
+    constructor(message: string);
+}
+/**
+ * Render a caught error for operator-facing sync warnings and auth
+ * details. Warnings travel back through CLI/MCP/HTTP responses, so
+ * foreign error text never passes through — delegation to the
+ * project-standard `displayErrorDetail` exposes only the error class
+ * and Node errno code. Wearables' own input errors (authored messages,
+ * no foreign text) pass through verbatim.
+ */
+export declare function describeErrorForOperator(err: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/wearables/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/wearables/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAI7D"}