@remnic/core 9.3.629 → 9.3.631

package/src/wearables/config.test.ts

@@ -25,17 +25,20 @@ test("boolean-ish strings coerce; garbage booleans throw", () => {
   assert.throws(() => parseWearablesConfig({ enabled: "fales" }), /wearables.enabled/);
 });
 
-test("source settings default to the least-privileged memory mode", () => {
+test("source settings default to the fully-automated smart pipeline", () => {
   const parsed = parseWearablesConfig({
     enabled: true,
     sources: { limitless: { enabled: true } },
   });
   const source = parsed.sources.limitless;
-  assert.equal(source.memoryMode, "review");
+  assert.equal(source.memoryMode, "smart");
+  assert.equal(source.sourceTrust, 0.8);
+  assert.equal(source.autoApproveTrust, 0.7);
+  assert.equal(source.reviewTrust, 0.45);
   assert.equal(source.minConfidence, 0.6);
   assert.equal(source.minImportance, "low");
-  assert.equal(source.maxMemoriesPerDay, 20);
-  assert.equal(source.importNativeMemories, "off");
+  assert.equal(source.maxMemoriesPerDay, 0, "uncapped by default");
+  assert.equal(source.importNativeMemories, "smart");
   assert.deepEqual(source.cleanup, {
     mergeSameSpeaker: true,
     stripFillers: true,
@@ -44,6 +47,32 @@ test("source settings default to the least-privileged memory mode", () => {
   });
 });
 
+test("top-level defaults are full-featured: digest and off-the-record on", () => {
+  const parsed = parseWearablesConfig({});
+  assert.equal(parsed.digestEnabled, true);
+  assert.equal(parsed.offTheRecordEnabled, true);
+  assert.equal(parsed.redactionEnabled, true);
+});
+
+test("trust knobs validate range and ordering", () => {
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { sourceTrust: 1.5 } } }),
+    /sourceTrust must be a number between 0 and 1/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { autoApproveTrust: -1 } } }),
+    /autoApproveTrust/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { reviewTrust: 0.9, autoApproveTrust: 0.7 } } }),
+    /reviewTrust .* must be below autoApproveTrust/,
+  );
+  const parsed = parseWearablesConfig({
+    sources: { bee: { sourceTrust: 0.5, autoApproveTrust: 0.8, reviewTrust: 0.3 } },
+  });
+  assert.equal(parsed.sources.bee.sourceTrust, 0.5);
+});
+
 test("invalid enum values list the valid options", () => {
   assert.throws(
     () =>
@@ -66,15 +95,15 @@ test("maxMemoriesPerDay honors the documented 0-disables value and bounds", () =
     sources: { limitless: { maxMemoriesPerDay: 0 } },
   });
   assert.equal(parsed.sources.limitless.maxMemoriesPerDay, 0);
-  // Over-ceiling values reject instead of silently clamping to 500.
-  assert.throws(
-    () => parseWearablesConfig({ sources: { limitless: { maxMemoriesPerDay: 99999 } } }),
-    /maxMemoriesPerDay must be an integer between 0 and 500/,
-  );
+  // No ceiling: any non-negative integer cap is the operator's call.
   assert.equal(
-    parseWearablesConfig({ sources: { limitless: { maxMemoriesPerDay: 500 } } })
+    parseWearablesConfig({ sources: { limitless: { maxMemoriesPerDay: 99999 } } })
       .sources.limitless.maxMemoriesPerDay,
-    500,
+    99999,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ sources: { limitless: { maxMemoriesPerDay: -1 } } }),
+    /maxMemoriesPerDay must be a non-negative integer/,
   );
   assert.throws(
     () => parseWearablesConfig({ sources: { limitless: { maxMemoriesPerDay: "lots" } } }),
@@ -141,3 +170,53 @@ test("minConfidence rejects out-of-range values instead of clamping", () => {
     0.85,
   );
 });
+
+test("auto-sync defaults to enabled with sane window settings", () => {
+  const parsed = parseWearablesConfig({});
+  assert.equal(parsed.autoSyncEnabled, true);
+  assert.equal(parsed.autoSyncIntervalMinutes, 15);
+  assert.equal(parsed.autoSyncDays, 2);
+  assert.equal(parsed.autoSyncDeepDays, 7);
+});
+
+test("auto-sync knobs parse, coerce, and loud-reject invalid values", () => {
+  const parsed = parseWearablesConfig({
+    autoSyncEnabled: "false",
+    autoSyncIntervalMinutes: "30",
+    autoSyncDays: 3,
+    autoSyncDeepDays: 14,
+  });
+  assert.equal(parsed.autoSyncEnabled, false, "boolean-ish strings coerce");
+  assert.equal(parsed.autoSyncIntervalMinutes, 30, "numeric strings coerce");
+  assert.equal(parsed.autoSyncDays, 3);
+  assert.equal(parsed.autoSyncDeepDays, 14);
+
+  assert.throws(
+    () => parseWearablesConfig({ autoSyncIntervalMinutes: 0 }),
+    /autoSyncIntervalMinutes must be an integer between 1 and 1440/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ autoSyncIntervalMinutes: 2.5 }),
+    /autoSyncIntervalMinutes/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ autoSyncDays: 0 }),
+    /autoSyncDays must be an integer between 1 and 90/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ autoSyncDeepDays: 91 }),
+    /autoSyncDeepDays must be an integer between 0 and 90/,
+  );
+});
+
+test("a deep window narrower than the tick window is rejected, 0 disables", () => {
+  assert.throws(
+    () => parseWearablesConfig({ autoSyncDays: 5, autoSyncDeepDays: 3 }),
+    /autoSyncDeepDays must be 0 \(disabled\) or >= wearables.autoSyncDays/,
+  );
+  assert.equal(parseWearablesConfig({ autoSyncDeepDays: 0 }).autoSyncDeepDays, 0);
+  assert.equal(
+    parseWearablesConfig({ autoSyncDays: 5, autoSyncDeepDays: 5 }).autoSyncDeepDays,
+    5,
+  );
+});

package/src/wearables/config.ts

@@ -22,7 +22,7 @@ import type {
 
 export const KNOWN_WEARABLE_SOURCE_IDS = ["limitless", "bee", "omi"] as const;
 
-const MEMORY_MODES: WearableMemoryMode[] = ["off", "review", "auto"];
+const MEMORY_MODES: WearableMemoryMode[] = ["off", "review", "auto", "smart"];
 const IMPORTANCE_LEVELS: ImportanceLevel[] = [
   "trivial",
   "low",
@@ -30,12 +30,23 @@ const IMPORTANCE_LEVELS: ImportanceLevel[] = [
   "high",
   "critical",
 ];
-const NATIVE_IMPORT_MODES = ["off", "review"] as const;
+const NATIVE_IMPORT_MODES = ["off", "review", "smart"] as const;
 
 const DEFAULT_MIN_CONFIDENCE = 0.6;
 const DEFAULT_MIN_IMPORTANCE: ImportanceLevel = "low";
-const DEFAULT_MAX_MEMORIES_PER_DAY = 20;
-const MAX_MEMORIES_PER_DAY_CEILING = 500;
+// Uncapped by default — wearables capture full days and the smart trust
+// pipeline is the quality gate; a count cap would drop real memories on
+// busy days. Operators who want a ceiling set any positive integer.
+const DEFAULT_MAX_MEMORIES_PER_DAY = 0;
+const DEFAULT_AUTO_SYNC_ENABLED = true;
+const DEFAULT_AUTO_SYNC_INTERVAL_MINUTES = 15;
+const MAX_AUTO_SYNC_INTERVAL_MINUTES = 1440;
+const DEFAULT_AUTO_SYNC_DAYS = 2;
+const DEFAULT_AUTO_SYNC_DEEP_DAYS = 7;
+const MAX_AUTO_SYNC_WINDOW_DAYS = 90;
+const DEFAULT_SOURCE_TRUST = 0.8;
+const DEFAULT_AUTO_APPROVE_TRUST = 0.7;
+const DEFAULT_REVIEW_TRUST = 0.45;
 
 export function defaultWearableCleanupSettings(): WearableCleanupSettings {
   return {
@@ -49,11 +60,14 @@ export function defaultWearableCleanupSettings(): WearableCleanupSettings {
 export function defaultWearableSourceSettings(): WearableSourceSettings {
   return {
     enabled: false,
-    memoryMode: "review",
+    memoryMode: "smart",
+    sourceTrust: DEFAULT_SOURCE_TRUST,
+    autoApproveTrust: DEFAULT_AUTO_APPROVE_TRUST,
+    reviewTrust: DEFAULT_REVIEW_TRUST,
     minConfidence: DEFAULT_MIN_CONFIDENCE,
     minImportance: DEFAULT_MIN_IMPORTANCE,
     maxMemoriesPerDay: DEFAULT_MAX_MEMORIES_PER_DAY,
-    importNativeMemories: "off",
+    importNativeMemories: "smart",
     cleanup: defaultWearableCleanupSettings(),
   };
 }
@@ -63,8 +77,12 @@ export function defaultWearablesConfig(): WearablesConfig {
     enabled: false,
     redactionEnabled: true,
     redactionPatterns: [],
-    offTheRecordEnabled: false,
-    digestEnabled: false,
+    offTheRecordEnabled: true,
+    digestEnabled: true,
+    autoSyncEnabled: DEFAULT_AUTO_SYNC_ENABLED,
+    autoSyncIntervalMinutes: DEFAULT_AUTO_SYNC_INTERVAL_MINUTES,
+    autoSyncDays: DEFAULT_AUTO_SYNC_DAYS,
+    autoSyncDeepDays: DEFAULT_AUTO_SYNC_DEEP_DAYS,
     corrections: [],
     sources: {},
   };
@@ -192,17 +210,39 @@ function parseSourceSettings(
     raw.maxMemoriesPerDay !== undefined &&
     (maxPerDayRaw === undefined ||
       !Number.isInteger(maxPerDayRaw) ||
-      maxPerDayRaw < 0 ||
-      maxPerDayRaw > MAX_MEMORIES_PER_DAY_CEILING)
+      maxPerDayRaw < 0)
   ) {
     throw new Error(
-      `${keyPath}.maxMemoriesPerDay must be an integer between 0 and ${MAX_MEMORIES_PER_DAY_CEILING} (0 disables the cap); got ${JSON.stringify(raw.maxMemoriesPerDay)}`,
+      `${keyPath}.maxMemoriesPerDay must be a non-negative integer (0, the default, disables the cap); got ${JSON.stringify(raw.maxMemoriesPerDay)}`,
     );
   }
   // 0 is the documented "disable the cap" value — honored here AND in
   // the schema minimum (CLAUDE.md rule 45).
   const maxMemoriesPerDay = maxPerDayRaw ?? defaults.maxMemoriesPerDay;
 
+  const parseUnitInterval = (value: unknown, name: string, fallback: number): number => {
+    if (value === undefined) return fallback;
+    const coerced = coerceNumber(value);
+    if (coerced === undefined || coerced < 0 || coerced > 1) {
+      throw new Error(
+        `${keyPath}.${name} must be a number between 0 and 1 (got ${JSON.stringify(value)})`,
+      );
+    }
+    return coerced;
+  };
+  const sourceTrust = parseUnitInterval(raw.sourceTrust, "sourceTrust", defaults.sourceTrust);
+  const autoApproveTrust = parseUnitInterval(
+    raw.autoApproveTrust,
+    "autoApproveTrust",
+    defaults.autoApproveTrust,
+  );
+  const reviewTrust = parseUnitInterval(raw.reviewTrust, "reviewTrust", defaults.reviewTrust);
+  if (reviewTrust >= autoApproveTrust) {
+    throw new Error(
+      `${keyPath}.reviewTrust (${reviewTrust}) must be below autoApproveTrust (${autoApproveTrust})`,
+    );
+  }
+
   const rawCleanup =
     raw.cleanup === undefined ? {} : requireObject(raw.cleanup, `${keyPath}.cleanup`);
   const cleanup: WearableCleanupSettings = {
@@ -240,6 +280,9 @@ function parseSourceSettings(
       MEMORY_MODES,
       defaults.memoryMode,
     ),
+    sourceTrust,
+    autoApproveTrust,
+    reviewTrust,
     minConfidence,
     minImportance: parseEnum(
       raw.minImportance,
@@ -291,6 +334,57 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
     compileRedactionPatterns(redactionPatterns);
   }
 
+  const parseBoundedInt = (
+    value: unknown,
+    name: string,
+    fallback: number,
+    min: number,
+    max: number,
+  ): number => {
+    if (value === undefined) return fallback;
+    const coerced = coerceNumber(value);
+    if (
+      coerced === undefined ||
+      !Number.isInteger(coerced) ||
+      coerced < min ||
+      coerced > max
+    ) {
+      throw new Error(
+        `${name} must be an integer between ${min} and ${max}; got ${JSON.stringify(value)}`,
+      );
+    }
+    return coerced;
+  };
+  const autoSyncIntervalMinutes = parseBoundedInt(
+    raw.autoSyncIntervalMinutes,
+    "wearables.autoSyncIntervalMinutes",
+    defaults.autoSyncIntervalMinutes,
+    1,
+    MAX_AUTO_SYNC_INTERVAL_MINUTES,
+  );
+  const autoSyncDays = parseBoundedInt(
+    raw.autoSyncDays,
+    "wearables.autoSyncDays",
+    defaults.autoSyncDays,
+    1,
+    MAX_AUTO_SYNC_WINDOW_DAYS,
+  );
+  const autoSyncDeepDays = parseBoundedInt(
+    raw.autoSyncDeepDays,
+    "wearables.autoSyncDeepDays",
+    defaults.autoSyncDeepDays,
+    0,
+    MAX_AUTO_SYNC_WINDOW_DAYS,
+  );
+  // A deep window narrower than the every-tick window would make the
+  // "deep" pass fetch LESS than a normal tick — reject the confusion
+  // instead of silently honoring it (0 disables the deep pass).
+  if (autoSyncDeepDays !== 0 && autoSyncDeepDays < autoSyncDays) {
+    throw new Error(
+      `wearables.autoSyncDeepDays must be 0 (disabled) or >= wearables.autoSyncDays (${autoSyncDays}); got ${autoSyncDeepDays}`,
+    );
+  }
+
   const sources: Record<string, WearableSourceSettings> = {};
   if (raw.sources !== undefined) {
     const rawSources = requireObject(raw.sources, "wearables.sources");
@@ -326,6 +420,14 @@ export function parseWearablesConfig(value: unknown): WearablesConfig {
       "wearables.digestEnabled",
       defaults.digestEnabled,
     ),
+    autoSyncEnabled: parseBool(
+      raw.autoSyncEnabled,
+      "wearables.autoSyncEnabled",
+      defaults.autoSyncEnabled,
+    ),
+    autoSyncIntervalMinutes,
+    autoSyncDays,
+    autoSyncDeepDays,
     corrections: parseCorrectionRules(raw.corrections, "wearables.corrections"),
     sources,
   };