@remnic/core 9.3.630 → 9.3.631

package/dist/{types-2vqxmO0j.d.ts → types-CpMPD8xl.d.ts}

@@ -169,7 +169,9 @@ interface WearableSourceSettings {
     /** Drop extracted facts scored below this importance level. */
     minImportance: ImportanceLevel;
     /**
-     * Cap on memories created per source per day. 0 disables the cap.
+     * Cap on memories created per source per day. 0 (the default)
+     * disables the cap — the smart trust pipeline is the quality gate,
+     * and a count cap would drop real memories on busy days.
      */
     maxMemoriesPerDay: number;
     /**
@@ -239,6 +241,23 @@ interface WearablesConfig {
      * Default false.
      */
     digestEnabled: boolean;
+    /**
+     * Periodically refresh transcripts in-process (long-lived hosts).
+     * Every tick re-syncs `autoSyncDays` ending today — existing day
+     * files included, so the current day keeps growing while the
+     * wearable records. Default true.
+     */
+    autoSyncEnabled: boolean;
+    /** Minutes between auto-sync ticks (1-1440). Default 15. */
+    autoSyncIntervalMinutes: number;
+    /** Rolling window (days ending today) per tick (1-90). Default 2. */
+    autoSyncDays: number;
+    /**
+     * Once-per-local-day deep pass window (days, 0-90) picking up late
+     * uploads and provider re-processing. 0 disables; otherwise must be
+     * >= autoSyncDays. Default 7.
+     */
+    autoSyncDeepDays: number;
     /** Correction rules from config (merged with CLI-managed rules). */
     corrections: WearableCorrectionRule[];
     /** Per-source settings, keyed by connector id. */

package/dist/types.d.ts

@@ -1,3 +1,3 @@
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
-export { y as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, a7 as AgentAccessAuthToken, b2 as AgentAccessHttpConfig, b3 as AgentDefaultsConfig, b4 as AgentPersona, f as AgentPersonaModelConfig, b5 as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, b6 as BehaviorSignalDirection, B as BehaviorSignalEvent, b7 as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, V as BriefingActiveThread, b8 as BriefingCalendarSourceError, aO as BriefingConfig, Q as BriefingFocus, O as BriefingFollowup, aP as BriefingOpenCommitment, X as BriefingRecentEntity, W as BriefingResult, N as BriefingSections, aQ as BriefingWindow, b9 as BufferEntryState, k as BufferState, o as BufferSurpriseEvent, Y as BufferTurn, U as CalendarEvent, S as CalendarSource, ba as CaptureMode, $ as Checkpoint, bb as CodexCliReasoningEffort, bc as CodexCompactionFlushMode, aR as CodexCompatConfig, bd as CodexConnectorConfig, aG as CodingContext, aL as CodingModeConfig, be as CompressionGuidelineActivationState, a9 as CompressionGuidelineOptimizerActionSummary, a8 as CompressionGuidelineOptimizerEventCounts, aa as CompressionGuidelineOptimizerRuleUpdate, bf as CompressionGuidelineOptimizerSourceWindow, C as CompressionGuidelineOptimizerState, bg as ConfidenceTier, bh as ConsolidationAction, bi as ConsolidationItem, aJ as ConsolidationObservation, ag as ConsolidationResult, s as ContinuityImprovementLoop, r as ContinuityIncidentCloseInput, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, bj as ContinuityIncidentState, bk as ContinuityLoopCadence, u as ContinuityLoopReviewInput, bl as ContinuityLoopStatus, t as ContinuityLoopUpsertInput, bm as ContradictionScanConfig, as as ConversationThread, bn as CronConversationRecallMode, bo as CronRecallMode, aS as DEFAULT_RECALL_DISCLOSURE, ah as DaySummaryResult, bp as DreamingConfig, bq as DreamingNarrativePromptStyle, br as DreamsDeepSleepConfig, bs as DreamsLightSleepConfig, au as DreamsPhase, bt as DreamsPhaseStatus, bu as DreamsPhasesConfig, bv as DreamsRemConfig, av as DreamsRunResult, at as DreamsStatusResult, bw as EngramTraceEvent, w as EntityActivityEntry, x as EntityFile, ac as EntityMention, v as EntityRelationship, ad as EntitySchemaDefinition, ae as EntitySchemaSectionDefinition, E as EntityStructuredSection, aK as EntityTimelineEntry, aT as ExtractedFact, bx as ExtractedProcedureStep, by as ExtractedQuestion, bz as ExtractedReasoningTrace, bA as ExtractedReasoningTraceStep, bB as ExtractedRelationship, bC as ExtractionPassSource, af as ExtractionResult, F as FileHygieneConfig, G as GatewayConfig, bD as GitHubLiveConnectorConfig, bE as GmailLiveConnectorConfig, bF as GoogleDriveLiveConnectorConfig, bG as HeartbeatConfig, bH as HeartbeatDetectionMode, a0 as HourlySummary, J as IdentityInjectionMode, a5 as ImportanceLevel, I as ImportanceScore, a2 as LifecycleState, L as LiveConnectorsConfig, bI as LlmTraceCallback, bJ as LlmTraceEvent, ak as MemoryActionEligibilityContext, aU as MemoryActionEligibilitySource, m as MemoryActionEvent, bK as MemoryActionOutcome, bL as MemoryActionPolicyDecision, al as MemoryActionPolicyResult, bM as MemoryActionStatus, ab as MemoryActionType, M as MemoryCategory, g as MemoryFile, j as MemoryFrontmatter, ai as MemoryIntent, n as MemoryLifecycleEvent, am as MemoryLifecycleEventType, an as MemoryLifecycleStateSummary, i as MemoryLink, bN as MemoryLinkType, aV as MemoryObservation, bO as MemoryOsPresetName, z as MemoryProjectionCurrentState, aW as MemoryScope, h as MemoryStatus, D as MemorySummary, l as MetaState, bP as ModelApi, bQ as ModelDefinitionConfig, bR as ModelProviderAuthMode, ao as ModelProviderConfig, bS as NamespacePolicy, ap as NativeKnowledgeConfig, bT as NativeKnowledgeFolderRuleConfig, bU as NativeKnowledgeObsidianVaultConfig, bV as NativeKnowledgeOpenClawWorkspaceConfig, bW as NotionLiveConnectorConfig, P as PluginConfig, a4 as PolicyClass, bX as PrincipalFromSessionKeyMode, bY as PrincipalRule, bZ as ProceduralConfig, aj as QmdSearchExplain, Z as QmdSearchResult, b_ as QuestionEntry, aX as RECALL_DISCLOSURE_LEVELS, b$ as ReasoningEffort, K as RecallDisclosure, c0 as RecallPipelineConfig, H as RecallPlanMode, c1 as RecallSectionConfig, R as RecallTierExplain, c2 as RecallTraceEvent, c3 as RelevanceFeedback, aq as RetrievalTier, c4 as SPECULATIVE_TTL_DAYS, c5 as ScoredEntity, a6 as SecretRef, c6 as SemanticChunkingConfigShape, a1 as SessionObserverBandConfig, c7 as SignalLevel, ar as SignalScanResult, c8 as SlotBehaviorConfig, c9 as SlotMismatchMode, T as TopicScore, _ as TranscriptEntry, ca as TriggerMode, a3 as VerificationState, cb as confidenceTier, b1 as isRecallDisclosure } from './types-2vqxmO0j.js';
+export { y as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, a7 as AgentAccessAuthToken, b2 as AgentAccessHttpConfig, b3 as AgentDefaultsConfig, b4 as AgentPersona, f as AgentPersonaModelConfig, b5 as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, b6 as BehaviorSignalDirection, B as BehaviorSignalEvent, b7 as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, V as BriefingActiveThread, b8 as BriefingCalendarSourceError, aO as BriefingConfig, Q as BriefingFocus, O as BriefingFollowup, aP as BriefingOpenCommitment, X as BriefingRecentEntity, W as BriefingResult, N as BriefingSections, aQ as BriefingWindow, b9 as BufferEntryState, k as BufferState, o as BufferSurpriseEvent, Y as BufferTurn, U as CalendarEvent, S as CalendarSource, ba as CaptureMode, $ as Checkpoint, bb as CodexCliReasoningEffort, bc as CodexCompactionFlushMode, aR as CodexCompatConfig, bd as CodexConnectorConfig, aG as CodingContext, aL as CodingModeConfig, be as CompressionGuidelineActivationState, a9 as CompressionGuidelineOptimizerActionSummary, a8 as CompressionGuidelineOptimizerEventCounts, aa as CompressionGuidelineOptimizerRuleUpdate, bf as CompressionGuidelineOptimizerSourceWindow, C as CompressionGuidelineOptimizerState, bg as ConfidenceTier, bh as ConsolidationAction, bi as ConsolidationItem, aJ as ConsolidationObservation, ag as ConsolidationResult, s as ContinuityImprovementLoop, r as ContinuityIncidentCloseInput, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, bj as ContinuityIncidentState, bk as ContinuityLoopCadence, u as ContinuityLoopReviewInput, bl as ContinuityLoopStatus, t as ContinuityLoopUpsertInput, bm as ContradictionScanConfig, as as ConversationThread, bn as CronConversationRecallMode, bo as CronRecallMode, aS as DEFAULT_RECALL_DISCLOSURE, ah as DaySummaryResult, bp as DreamingConfig, bq as DreamingNarrativePromptStyle, br as DreamsDeepSleepConfig, bs as DreamsLightSleepConfig, au as DreamsPhase, bt as DreamsPhaseStatus, bu as DreamsPhasesConfig, bv as DreamsRemConfig, av as DreamsRunResult, at as DreamsStatusResult, bw as EngramTraceEvent, w as EntityActivityEntry, x as EntityFile, ac as EntityMention, v as EntityRelationship, ad as EntitySchemaDefinition, ae as EntitySchemaSectionDefinition, E as EntityStructuredSection, aK as EntityTimelineEntry, aT as ExtractedFact, bx as ExtractedProcedureStep, by as ExtractedQuestion, bz as ExtractedReasoningTrace, bA as ExtractedReasoningTraceStep, bB as ExtractedRelationship, bC as ExtractionPassSource, af as ExtractionResult, F as FileHygieneConfig, G as GatewayConfig, bD as GitHubLiveConnectorConfig, bE as GmailLiveConnectorConfig, bF as GoogleDriveLiveConnectorConfig, bG as HeartbeatConfig, bH as HeartbeatDetectionMode, a0 as HourlySummary, J as IdentityInjectionMode, a5 as ImportanceLevel, I as ImportanceScore, a2 as LifecycleState, L as LiveConnectorsConfig, bI as LlmTraceCallback, bJ as LlmTraceEvent, ak as MemoryActionEligibilityContext, aU as MemoryActionEligibilitySource, m as MemoryActionEvent, bK as MemoryActionOutcome, bL as MemoryActionPolicyDecision, al as MemoryActionPolicyResult, bM as MemoryActionStatus, ab as MemoryActionType, M as MemoryCategory, g as MemoryFile, j as MemoryFrontmatter, ai as MemoryIntent, n as MemoryLifecycleEvent, am as MemoryLifecycleEventType, an as MemoryLifecycleStateSummary, i as MemoryLink, bN as MemoryLinkType, aV as MemoryObservation, bO as MemoryOsPresetName, z as MemoryProjectionCurrentState, aW as MemoryScope, h as MemoryStatus, D as MemorySummary, l as MetaState, bP as ModelApi, bQ as ModelDefinitionConfig, bR as ModelProviderAuthMode, ao as ModelProviderConfig, bS as NamespacePolicy, ap as NativeKnowledgeConfig, bT as NativeKnowledgeFolderRuleConfig, bU as NativeKnowledgeObsidianVaultConfig, bV as NativeKnowledgeOpenClawWorkspaceConfig, bW as NotionLiveConnectorConfig, P as PluginConfig, a4 as PolicyClass, bX as PrincipalFromSessionKeyMode, bY as PrincipalRule, bZ as ProceduralConfig, aj as QmdSearchExplain, Z as QmdSearchResult, b_ as QuestionEntry, aX as RECALL_DISCLOSURE_LEVELS, b$ as ReasoningEffort, K as RecallDisclosure, c0 as RecallPipelineConfig, H as RecallPlanMode, c1 as RecallSectionConfig, R as RecallTierExplain, c2 as RecallTraceEvent, c3 as RelevanceFeedback, aq as RetrievalTier, c4 as SPECULATIVE_TTL_DAYS, c5 as ScoredEntity, a6 as SecretRef, c6 as SemanticChunkingConfigShape, a1 as SessionObserverBandConfig, c7 as SignalLevel, ar as SignalScanResult, c8 as SlotBehaviorConfig, c9 as SlotMismatchMode, T as TopicScore, _ as TranscriptEntry, ca as TriggerMode, a3 as VerificationState, cb as confidenceTier, b1 as isRecallDisclosure } from './types-CpMPD8xl.js';

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-2vqxmO0j.js';
+import './types-CpMPD8xl.js';
 import './types-BliCnURB.js';
 import './index-DJ9QWMw-.js';
 import './lifecycle.js';

package/dist/verified-recall.js

@@ -1,8 +1,9 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-ZZSXUZF3.js";
+} from "./chunk-YROCXMCK.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-RSKUUEBA.js";
+import "./chunk-QYGIQ5NM.js";
+import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
 import "./chunk-FPNQF475.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.630",
+  "version": "9.3.631",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/orchestrator.ts

@@ -1700,6 +1700,7 @@ export class Orchestrator {
   >();
   private qmdMaintenanceTimer: NodeJS.Timeout | null = null;
   private wearablesServiceInstance: WearablesService | null = null;
+  private wearablesAutoSyncHandle: { stop(): Promise<void> } | null = null;
   private qmdMaintenancePending = false;
   private qmdMaintenanceInFlight = false;
   private lastQmdEmbedAtMs = 0;
@@ -1781,6 +1782,12 @@ export class Orchestrator {
    */
   async destroy(): Promise<void> {
     this.abortDeferredInit();
+    if (this.wearablesAutoSyncHandle) {
+      // Aborts in-flight provider fetches and waits for the tick to
+      // settle, so nothing is writing or reindexing past destroy().
+      await this.wearablesAutoSyncHandle.stop();
+      this.wearablesAutoSyncHandle = null;
+    }
     if (this.qmdMaintenanceTimer) {
       clearTimeout(this.qmdMaintenanceTimer);
       this.qmdMaintenanceTimer = null;
@@ -2957,6 +2964,57 @@ export class Orchestrator {
       }
     }
 
+    // Wearables auto-sync: in-process periodic transcript refresh for
+    // long-lived hosts (default on). Today's transcript keeps growing
+    // while the wearable records; a once-per-local-day deep pass picks
+    // up late uploads and provider re-processing. Static config gate —
+    // sources can't appear at runtime, so checking once here is safe.
+    // The timer is unref'd, so one-shot CLI runs exit naturally without
+    // ever ticking; idempotent across stop/start cycles via the handle
+    // guard. Non-fatal: a failure to start must not break init.
+    if (signal.aborted) return;
+    if (
+      !this.wearablesAutoSyncHandle &&
+      this.config.wearables.enabled &&
+      this.config.wearables.autoSyncEnabled &&
+      Object.values(this.config.wearables.sources).some((source) => source.enabled)
+    ) {
+      try {
+        const { startWearablesAutoSync } = await import("./wearables/auto-sync.js");
+        // Re-check after the await: destroy() may have aborted while
+        // the import was in flight, having found no handle to stop —
+        // starting now would leave a live interval on a destroyed
+        // orchestrator (Cursor review on PR #1464). Handle creation
+        // below is synchronous, so no further window exists.
+        if (signal.aborted) return;
+        this.wearablesAutoSyncHandle = startWearablesAutoSync(
+          {
+            intervalMinutes: this.config.wearables.autoSyncIntervalMinutes,
+            days: this.config.wearables.autoSyncDays,
+            deepDays: this.config.wearables.autoSyncDeepDays,
+            ...(this.config.wearables.timezone !== undefined
+              ? { timezone: this.config.wearables.timezone }
+              : {}),
+          },
+          {
+            sync: (options) => this.getWearablesService().sync(options),
+            log: {
+              info: (message) => log.info(message),
+              warn: (message) => log.warn(message),
+            },
+          },
+        );
+        log.info(
+          `wearables auto-sync started: every ${this.config.wearables.autoSyncIntervalMinutes}m over ${this.config.wearables.autoSyncDays}d (deep ${this.config.wearables.autoSyncDeepDays}d daily)`,
+        );
+      } catch (err) {
+        const { displayErrorDetail } = await import("./runtime/better-sqlite.js");
+        log.warn(
+          `wearables auto-sync failed to start (non-fatal): ${displayErrorDetail(err)}`,
+        );
+      }
+    }
+
     log.info("orchestrator initialized (full — deferred steps complete)");
   }
 

package/src/wearables/auto-sync.test.ts

@@ -0,0 +1,181 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { startWearablesAutoSync } from "./auto-sync.js";
+
+function makeDeps(overrides: { failTimes?: number } = {}) {
+  const calls: Array<{ days: number }> = [];
+  const warnings: string[] = [];
+  let remainingFailures = overrides.failTimes ?? 0;
+  let nowIso = "2026-06-12T10:00:00.000Z";
+  return {
+    calls,
+    warnings,
+    setNow(iso: string) {
+      nowIso = iso;
+    },
+    deps: {
+      sync: async (options: { days: number }) => {
+        if (remainingFailures > 0) {
+          remainingFailures -= 1;
+          throw new Error("provider down");
+        }
+        calls.push(options);
+        return [];
+      },
+      log: {
+        info: () => {},
+        warn: (message: string) => {
+          warnings.push(message);
+        },
+      },
+      now: () => new Date(nowIso),
+    },
+  };
+}
+
+const SETTINGS = {
+  intervalMinutes: 15,
+  days: 2,
+  deepDays: 7,
+  timezone: "UTC",
+};
+
+test("first tick runs the deep window, same-day ticks run the shallow window", async () => {
+  const { calls, deps } = makeDeps();
+  const handle = startWearablesAutoSync(SETTINGS, deps);
+  try {
+    await handle.tick();
+    await handle.tick();
+    await handle.tick();
+    assert.deepEqual(
+      calls.map((call) => call.days),
+      [7, 2, 2],
+      "deep once, then shallow for the rest of the day",
+    );
+  } finally {
+    handle.stop();
+  }
+});
+
+test("a new local day triggers the deep pass again", async () => {
+  const { calls, deps, setNow } = makeDeps();
+  const handle = startWearablesAutoSync(SETTINGS, deps);
+  try {
+    await handle.tick();
+    await handle.tick();
+    setNow("2026-06-13T00:05:00.000Z");
+    await handle.tick();
+    await handle.tick();
+    assert.deepEqual(
+      calls.map((call) => call.days),
+      [7, 2, 7, 2],
+    );
+  } finally {
+    handle.stop();
+  }
+});
+
+test("a failed deep pass retries deep on the next tick, never throws", async () => {
+  const { calls, warnings, deps } = makeDeps({ failTimes: 1 });
+  const handle = startWearablesAutoSync(SETTINGS, deps);
+  try {
+    await handle.tick();
+    assert.equal(calls.length, 0, "first tick failed");
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /retrying on the next tick/);
+    await handle.tick();
+    assert.deepEqual(
+      calls.map((call) => call.days),
+      [7],
+      "deep window retries — a failure must not consume the daily deep slot",
+    );
+  } finally {
+    handle.stop();
+  }
+});
+
+test("deepDays 0 disables the deep pass entirely", async () => {
+  const { calls, deps } = makeDeps();
+  const handle = startWearablesAutoSync({ ...SETTINGS, deepDays: 0 }, deps);
+  try {
+    await handle.tick();
+    await handle.tick();
+    assert.deepEqual(
+      calls.map((call) => call.days),
+      [2, 2],
+    );
+  } finally {
+    handle.stop();
+  }
+});
+
+test("overlapping ticks are skipped, not stacked", async () => {
+  const calls: Array<{ days: number }> = [];
+  let release: (() => void) | null = null;
+  const handle = startWearablesAutoSync(SETTINGS, {
+    sync: async (options) => {
+      calls.push(options);
+      await new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      return [];
+    },
+    log: { info: () => {}, warn: () => {} },
+    now: () => new Date("2026-06-12T10:00:00.000Z"),
+  });
+  try {
+    const first = handle.tick();
+    const second = handle.tick();
+    await second;
+    assert.equal(calls.length, 1, "second tick is a no-op while the first runs");
+    release!();
+    await first;
+  } finally {
+    handle.stop();
+  }
+});
+
+test("stop() prevents any further ticks", async () => {
+  const { calls, deps } = makeDeps();
+  const handle = startWearablesAutoSync(SETTINGS, deps);
+  await handle.stop();
+  await handle.tick();
+  assert.equal(calls.length, 0);
+});
+
+test("stop() aborts the in-flight sync and awaits its settlement", async () => {
+  const warnings: string[] = [];
+  let sawSignal: AbortSignal | undefined;
+  let syncSettled = false;
+  const handle = startWearablesAutoSync(SETTINGS, {
+    sync: async (options) => {
+      sawSignal = options.signal;
+      // Hang until the shutdown abort arrives, like a slow provider.
+      await new Promise<void>((_resolve, reject) => {
+        options.signal!.addEventListener("abort", () =>
+          reject(new Error("aborted")),
+        );
+      }).finally(() => {
+        syncSettled = true;
+      });
+    },
+    log: {
+      info: () => {},
+      warn: (message: string) => {
+        warnings.push(message);
+      },
+    },
+    now: () => new Date("2026-06-12T10:00:00.000Z"),
+  });
+  const inFlight = handle.tick();
+  assert.ok(sawSignal instanceof AbortSignal, "sync receives the abort signal");
+  await handle.stop();
+  assert.equal(syncSettled, true, "stop() resolves only after the tick settled");
+  assert.equal(
+    warnings.length,
+    0,
+    "an abort raised by shutdown is intentional, never warned",
+  );
+  await inFlight;
+});

package/src/wearables/auto-sync.ts

@@ -0,0 +1,129 @@
+/**
+ * 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.
+ */
+
+import { describeErrorForOperator } from "./errors.js";
+import { dateInTimezone, defaultTimezone } from "./pipeline.js";
+
+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 function startWearablesAutoSync(
+  settings: WearablesAutoSyncSettings,
+  deps: WearablesAutoSyncDeps,
+): WearablesAutoSyncHandle {
+  let inFlight: Promise<void> | null = null;
+  let stopped = false;
+  let lastDeepDate: string | null = null;
+  // Aborting cancels the in-flight sync's provider fetches promptly on
+  // shutdown — without it, a slow tick would keep writing/reindexing
+  // after orchestrator.destroy() while a restarted host starts a
+  // second scheduler (Kilo review on PR #1464).
+  const abortController = new AbortController();
+
+  const tick = async (): Promise<void> => {
+    // Overlap guard: a slow provider or large deep window must never
+    // stack a second sync on top of a running one. The skipped call
+    // resolves immediately — it must NOT await the running tick, or a
+    // caller holding both promises could deadlock itself.
+    if (inFlight || stopped) return;
+    const run = (async () => {
+      try {
+        const now = deps.now ? deps.now() : new Date();
+        const today = dateInTimezone(now, settings.timezone ?? defaultTimezone());
+        const deep = settings.deepDays > 0 && lastDeepDate !== today;
+        const days = deep ? settings.deepDays : settings.days;
+        await deps.sync({ days, signal: abortController.signal });
+        // Mark the deep pass done only AFTER it succeeded — a failed
+        // deep pass retries on the next tick instead of silently
+        // waiting for tomorrow (CLAUDE.md rule 25's "confirm before
+        // consuming the one-shot" shape).
+        if (deep) lastDeepDate = today;
+        deps.log.info(
+          `wearables auto-sync: refreshed ${days}-day window${deep ? " (daily deep pass)" : ""}`,
+        );
+      } catch (err) {
+        // An abort raised by stop() is intentional shutdown, not a
+        // failure — warning about it would be noise in every clean
+        // shutdown log.
+        if (!stopped) {
+          deps.log.warn(
+            `wearables auto-sync failed: ${describeErrorForOperator(err)} — retrying on the next tick`,
+          );
+        }
+      } finally {
+        inFlight = null;
+      }
+    })();
+    inFlight = run;
+    await run;
+  };
+
+  const timer = setInterval(() => {
+    void tick();
+  }, settings.intervalMinutes * 60_000);
+  timer.unref?.();
+
+  return {
+    tick,
+    stop: async () => {
+      stopped = true;
+      clearInterval(timer);
+      abortController.abort();
+      // tick() never rejects (all paths caught), so this only waits.
+      if (inFlight) await inFlight;
+    },
+  };
+}

package/src/wearables/config.test.ts

@@ -37,7 +37,7 @@ test("source settings default to the fully-automated smart pipeline", () => {
   assert.equal(source.reviewTrust, 0.45);
   assert.equal(source.minConfidence, 0.6);
   assert.equal(source.minImportance, "low");
-  assert.equal(source.maxMemoriesPerDay, 50);
+  assert.equal(source.maxMemoriesPerDay, 0, "uncapped by default");
   assert.equal(source.importNativeMemories, "smart");
   assert.deepEqual(source.cleanup, {
     mergeSameSpeaker: true,
@@ -95,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" } } }),
@@ -170,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

@@ -34,8 +34,16 @@ 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 = 50;
-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;
@@ -71,6 +79,10 @@ export function defaultWearablesConfig(): WearablesConfig {
     redactionPatterns: [],
     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: {},
   };
@@ -198,11 +210,10 @@ 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
@@ -323,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");
@@ -358,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,
   };