@remnic/core 9.3.629 → 9.3.631

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, a6 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, a8 as CompressionGuidelineOptimizerActionSummary, a7 as CompressionGuidelineOptimizerEventCounts, a9 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, ab as EntityMention, v as EntityRelationship, ac as EntitySchemaDefinition, ad 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, ae 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, aa as MemoryActionType, M as MemoryCategory, g as MemoryFile, i as MemoryFrontmatter, ai as MemoryIntent, n as MemoryLifecycleEvent, am as MemoryLifecycleEventType, an as MemoryLifecycleStateSummary, h as MemoryLink, bN as MemoryLinkType, aV as MemoryObservation, bO as MemoryOsPresetName, z as MemoryProjectionCurrentState, aW as MemoryScope, j 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, a5 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-BCF2wqKa.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-BCF2wqKa.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-P2D2MM47.js";
+} from "./chunk-YROCXMCK.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-UGHUNQ74.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.629",
+  "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)");
   }
 
@@ -10807,6 +10865,22 @@ export class Orchestrator {
         getStorage: async () =>
           await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
         extract: (turns) => this.extraction.extract(turns),
+        // Smart memoryMode runs candidates through the SAME extraction
+        // judge (cache + defer counters included) the live extraction
+        // pipeline uses, so wearable facts get identical LLM-as-judge
+        // durability gating.
+        judgeFacts: (candidates) =>
+          judgeFactDurability(
+            candidates,
+            this.config,
+            this.localLlm,
+            new FallbackLlmClient(
+              this.config.gatewayConfig,
+              fallbackLlmRuntimeContextFromConfig(this.config),
+            ),
+            this.judgeVerdictCache,
+            this.judgeDeferCounts,
+          ),
         searchBackend: {
           search: async (query, maxResults) => {
             if (!this.qmd.isAvailable()) return null;

package/src/storage.ts

@@ -1168,6 +1168,27 @@ export class ContentHashIndex {
  *   normalizeAttributePairs({ foo: "bar", BAZ: "qux" })
  *   // → "baz: qux; foo: bar"
  */
+/**
+ * Remove the "[Attributes: ...]" suffix `writeMemory` appends to the
+ * stored body when structuredAttributes are present, yielding the raw
+ * fact text for content comparison. Inverse companion of
+ * `normalizeAttributePairs` enrichment. String operations, not regex —
+ * CodeQL js/polynomial-redos on a suffix-anchored pattern over
+ * library-supplied content.
+ */
+export function stripAttributesSuffix(content: string): string {
+  const trimmed = content.trimEnd();
+  if (!trimmed.endsWith("]")) return content.trim();
+  const marker = "\n[Attributes: ";
+  const markerIndex = trimmed.lastIndexOf(marker);
+  if (markerIndex === -1) return content.trim();
+  // The block must be the FINAL line and contain no "]" before the
+  // closing bracket (mirrors the shape normalizeAttributePairs emits).
+  const inner = trimmed.slice(markerIndex + marker.length, -1);
+  if (inner.includes("]") || inner.includes("\n")) return content.trim();
+  return trimmed.slice(0, markerIndex).trim();
+}
+
 export function normalizeAttributePairs(pairs: Record<string, string>): string {
   return Object.entries(pairs)
     .map(([k, v]) => [k.trim().toLowerCase(), v.trim()] as [string, string])
@@ -2596,6 +2617,85 @@ export class StorageManager {
     return days;
   }
 
+  /**
+   * Locate a wearable-sourced memory by exact (trimmed) content,
+   * ignoring the "[Attributes: ...]" suffix writeMemory appends for
+   * structuredAttributes — callers pass the raw fact text. Used by the
+   * smart trust pipeline to find an earlier borderline write when the
+   * same fact re-extracts with stronger evidence.
+   */
+  async findWearableMemoryByContent(
+    content: string,
+  ): Promise<{ id: string; status: MemoryStatus | undefined } | null> {
+    const needle = stripAttributesSuffix(content);
+    const memories = await this.readAllMemories();
+    for (const memory of memories) {
+      if (
+        typeof memory.frontmatter.source === "string" &&
+        memory.frontmatter.source.startsWith("wearable:") &&
+        stripAttributesSuffix(memory.content) === needle
+      ) {
+        return { id: memory.frontmatter.id, status: memory.frontmatter.status };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Promote a pending_review wearable memory to active in place,
+   * merging updated trust evidence into structuredAttributes. Returns
+   * false when the memory is missing or no longer pending_review (a
+   * concurrent review decision wins).
+   */
+  async promoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+    confidence?: number,
+  ): Promise<boolean> {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "active",
+      // Keep frontmatter confidence in step with the re-scored trust —
+      // new smart writes persist trust as confidence, and a promoted
+      // row must not keep its stale borderline value.
+      ...(typeof confidence === "number" && Number.isFinite(confidence)
+        ? { confidence: Math.min(1, Math.max(0, confidence)) }
+        : {}),
+      structuredAttributes: {
+        ...(memory.frontmatter.structuredAttributes ?? {}),
+        ...attributeUpdates,
+      },
+    });
+  }
+
+  /**
+   * Demote a pending_review wearable memory to rejected when a re-pass
+   * produced an explicit judge-reject verdict, merging the evidence.
+   * Returns false when the memory is missing or no longer
+   * pending_review — active rows are NEVER auto-demoted (operator
+   * approvals and accrued recall signals win; contradiction scans and
+   * supersession own active-row retirement).
+   */
+  async demoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+  ): Promise<boolean> {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "rejected",
+      structuredAttributes: {
+        ...(memory.frontmatter.structuredAttributes ?? {}),
+        ...attributeUpdates,
+      },
+    });
+  }
+
   private get factsDir(): string {
     return path.join(this.baseDir, "facts");
   }

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/cli.ts

@@ -125,6 +125,12 @@ function renderSyncSummary(summary: WearableSyncSummary): string {
     `  transcripts written:    ${summary.transcriptsWritten.length > 0 ? summary.transcriptsWritten.join(", ") : "(none — unchanged)"}`,
     `  memories created:       ${summary.memoriesCreated} (skipped ${summary.memoriesSkipped})`,
   ];
+  if (summary.memoriesPromoted > 0) {
+    lines.push(`  memories promoted:      ${summary.memoriesPromoted}`);
+  }
+  if (summary.memoriesDemoted > 0) {
+    lines.push(`  memories demoted:       ${summary.memoriesDemoted}`);
+  }
   if (summary.nativeMemoriesImported > 0) {
     lines.push(`  native memories queued: ${summary.nativeMemoriesImported}`);
   }